RootRawEvtReader.cxx

Go to the documentation of this file.

#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
 
#include "TBranch.h"
#include "TFile.h"
#include "TObjArray.h"
#include "TTree.h"
 
#include "RawEvent/DigiEvent.h" //TDS object
 
// Digi
#include "EmcRawEvent/EmcDigi.h"
#include "MdcRawEvent/MdcDigi.h"
#include "MucRawEvent/MucDigi.h"
#include "TofRawEvent/TofDigi.h"
 
#include "RootEventData/TEmcDigi.h"
#include "RootEventData/TMdcDigi.h"
#include "RootEventData/TMucDigi.h"
#include "RootEventData/TTofDigi.h"
 
#include "RootRawEvtReader.h"
 
/////////////////////////////////////////////////////////////////////////////
DECLARE_COMPONENT( RootRawEvtReader )
 
RootRawEvtReader::RootRawEvtReader( const std::string& name, ISvcLocator* pSvcLocator )
    : Algorithm( name, pSvcLocator ) {
 
  declareProperty( "MdcDigi", m_mdcDigi = 1 );
  declareProperty( "TofDigi", m_tofDigi = 1 );
  declareProperty( "EmcDigi", m_emcDigi = 1 );
  declareProperty( "MucDigi", m_mucDigi = 1 );
  declareProperty( "InputFiles", m_inputFiles );
 
  m_totalEvents    = 0;
  m_fileNumber     = 0;
  m_tempNumber     = -1;
  m_currentEntries = -1;
  m_currentEntry   = -1;
}
 
RootRawEvtReader::~RootRawEvtReader() {}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode RootRawEvtReader::initialize() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in initialize()" << endmsg;
 
  ISvcLocator* svcLocator = Gaudi::svcLocator();
  StatusCode   sc         = svcLocator->service( "EventDataSvc", m_evtSvc );
  if ( sc.isFailure() ) std::cout << "Could not accesss EventDataSvc!" << std::endl;
 
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode RootRawEvtReader::execute() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in execute()" << endmsg;
 
  DigiEvent* aDigiEvent = new DigiEvent;
  StatusCode sc         = m_evtSvc->registerObject( "/Event/Digi", aDigiEvent );
  if ( sc != StatusCode::SUCCESS )
  { std::cout << "Could not register DigiEvent" << std::endl; }
 
  if ( m_tempNumber != m_fileNumber )
  {
    m_currentEntry = 0;
    TFile* m_input = TFile::Open( m_inputFiles[m_fileNumber].c_str(), "READ" );
    std::cout << "input file: " << m_inputFiles[m_fileNumber].c_str() << std::endl;
    m_tree = (TTree*)m_input->Get( "Event" );
    m_tree->SetMakeClass( 1 );
    m_currentEntries = (Int_t)m_tree->GetEntries();
    std::cout << "m_currentEntries: " << m_currentEntries << std::endl;
 
    m_tempNumber = m_fileNumber;
  }
 
  if ( m_mdcDigi ) readMdc( m_currentEntry ).ignore();
 
  if ( m_tofDigi ) readTof( m_currentEntry ).ignore();
 
  if ( m_emcDigi ) readEmc( m_currentEntry ).ignore();
 
  if ( m_mucDigi ) readMuc( m_currentEntry ).ignore();
 
  log << MSG::INFO << "current Entry: " << m_currentEntry << endmsg;
  // std::cout << "current Entry: "<< m_currentEntry << std::endl;
  m_currentEntry++;
 
  if ( m_currentEntry == m_currentEntries ) { m_fileNumber++; }
 
  m_totalEvents++;
  log << MSG::INFO << "total events: " << m_totalEvents << endmsg;
  // std::cout << "total events: "<< m_totalEvents << std::endl;
 
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode RootRawEvtReader::readMdc( int entry ) {
  TBranch* branch = m_tree->GetBranch( "m_mdcDigiCol" );
 
  TObjArray* mdcDigiCol;
  branch->SetAddress( &mdcDigiCol );
  mdcDigiCol = 0;
 
  branch->GetEntry( entry );
 
  // commonData m_common;
 
  TIter       mdcDigiIter( mdcDigiCol );
  MdcDigiCol* mdcDigiTdsCol = new MdcDigiCol;
  TMdcDigi*   mdcDigiRoot   = 0;
 
  while ( ( mdcDigiRoot = (TMdcDigi*)mdcDigiIter.Next() ) )
  {
    unsigned int id         = mdcDigiRoot->getIntId();
    unsigned int time       = mdcDigiRoot->getTimeChannel();
    unsigned int charge     = mdcDigiRoot->getChargeChannel();
    unsigned int overflow   = mdcDigiRoot->getOverflow();
    int          trackIndex = mdcDigiRoot->getTrackIndex();
 
    MdcDigi* mdcDigiTds = new MdcDigi( id );
    // m_common.m_rootMdcDigiMap[mdcDigiRoot] = mdcDigiTds;
    mdcDigiTds->setTimeChannel( time );
    mdcDigiTds->setChargeChannel( charge );
    mdcDigiTds->setOverflow( overflow );
    mdcDigiTds->setTrackIndex( trackIndex );
    mdcDigiTdsCol->push_back( mdcDigiTds );
    /*std::cout<<"trackID: "<<trackIndex;
    std::cout<<"  charge: "<<charge;
    std::cout<<"  time: "<<time<<std::endl;*/
  }
 
  // register MDC digits collection to TDS
  StatusCode scMdc = m_evtSvc->registerObject( "/Event/Digi/MdcDigiCol", mdcDigiTdsCol );
  if ( scMdc != StatusCode::SUCCESS )
    std::cout << "Could not register MDC digi collection" << std::endl;
 
  return StatusCode::SUCCESS;
}
 
StatusCode RootRawEvtReader::readTof( int entry ) {
  TBranch* branch = m_tree->GetBranch( "m_tofDigiCol" );
 
  TObjArray* tofDigiCol;
  branch->SetAddress( &tofDigiCol );
  tofDigiCol = 0;
 
  branch->GetEntry( entry );
 
  // commonData m_common;
 
  TIter       tofDigiIter( tofDigiCol );
  TofDigiCol* tofDigiTdsCol = new TofDigiCol;
  TTofDigi*   tofDigiRoot   = 0;
 
  while ( ( tofDigiRoot = (TTofDigi*)tofDigiIter.Next() ) )
  {
    unsigned int id         = tofDigiRoot->getIntId();
    unsigned int time       = tofDigiRoot->getTimeChannel();
    unsigned int charge     = tofDigiRoot->getChargeChannel();
    unsigned int overflow   = tofDigiRoot->getOverflow();
    int          trackIndex = tofDigiRoot->getTrackIndex();
 
    TofDigi* tofDigiTds = new TofDigi( id );
    // m_common.m_rootTofDigiMap[tofDigiRoot] = tofDigiTds;
    tofDigiTds->setTimeChannel( time );
    tofDigiTds->setChargeChannel( charge );
    tofDigiTds->setOverflow( overflow );
    tofDigiTds->setTrackIndex( trackIndex );
    tofDigiTdsCol->push_back( tofDigiTds );
  }
 
  // register TOF digits collection to TDS
  StatusCode scTof = m_evtSvc->registerObject( "/Event/Digi/TofDigiCol", tofDigiTdsCol );
  if ( scTof != StatusCode::SUCCESS )
    std::cout << "Could not register TOF digi collection" << std::endl;
 
  return StatusCode::SUCCESS;
}
 
StatusCode RootRawEvtReader::readEmc( int entry ) {
  TBranch* branch = m_tree->GetBranch( "m_emcDigiCol" );
 
  TObjArray* emcDigiCol;
  branch->SetAddress( &emcDigiCol );
  emcDigiCol = 0;
 
  branch->GetEntry( entry );
 
  // commonData m_common;
 
  TIter       emcDigiIter( emcDigiCol );
  EmcDigiCol* emcDigiTdsCol = new EmcDigiCol;
  TEmcDigi*   emcDigiRoot   = 0;
 
  while ( ( emcDigiRoot = (TEmcDigi*)emcDigiIter.Next() ) )
  {
    unsigned int id         = emcDigiRoot->getIntId();
    unsigned int time       = emcDigiRoot->getTimeChannel();
    unsigned int charge     = emcDigiRoot->getChargeChannel();
    unsigned int measure    = emcDigiRoot->getMeasure();
    int          trackIndex = emcDigiRoot->getTrackIndex();
 
    EmcDigi* emcDigiTds = new EmcDigi( id );
    // m_common.m_rootEmcDigiMap[emcDigiRoot] = emcDigiTds;
    emcDigiTds->setTimeChannel( time );
    emcDigiTds->setChargeChannel( charge );
    emcDigiTds->setMeasure( measure );
    emcDigiTds->setTrackIndex( trackIndex );
    emcDigiTdsCol->push_back( emcDigiTds );
  }
 
  // register EMC digits collection to TDS
  StatusCode scEmc = m_evtSvc->registerObject( "/Event/Digi/EmcDigiCol", emcDigiTdsCol );
  if ( scEmc != StatusCode::SUCCESS )
    std::cout << "Could not register EMC digi collection" << std::endl;
 
  return StatusCode::SUCCESS;
}
 
StatusCode RootRawEvtReader::readMuc( int entry ) {
  TBranch* branch = m_tree->GetBranch( "m_mucDigiCol" );
 
  TObjArray* mucDigiCol;
  branch->SetAddress( &mucDigiCol );
  mucDigiCol = 0;
 
  branch->GetEntry( entry );
 
  // commonData m_common;
 
  TIter       mucDigiIter( mucDigiCol );
  MucDigiCol* mucDigiTdsCol = new MucDigiCol;
  TMucDigi*   mucDigiRoot   = 0;
 
  while ( ( mucDigiRoot = (TMucDigi*)mucDigiIter.Next() ) )
  {
    unsigned int id         = mucDigiRoot->getIntId();
    unsigned int time       = mucDigiRoot->getTimeChannel();
    unsigned int charge     = mucDigiRoot->getChargeChannel();
    int          trackIndex = mucDigiRoot->getTrackIndex();
 
    MucDigi* mucDigiTds = new MucDigi( id );
    // m_common.m_rootMucDigiMap[mucDigiRoot] = mucDigiTds;
    mucDigiTds->setTimeChannel( time );
    mucDigiTds->setChargeChannel( charge );
    mucDigiTds->setTrackIndex( trackIndex );
    mucDigiTdsCol->push_back( mucDigiTds );
  }
 
  // register MUC digits collection to TDS
  StatusCode scMuc = m_evtSvc->registerObject( "/Event/Digi/MucDigiCol", mucDigiTdsCol );
  if ( scMuc != StatusCode::SUCCESS )
    std::cout << "Could not register MUC digi collection" << std::endl;
 
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode RootRawEvtReader::finalize() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in finalize()" << endmsg;
 
  return StatusCode::SUCCESS;
}