EventWriter.cxx

Go to the documentation of this file.

#include "EventWriter.h"
#include "DataInfoSvc/IDataInfoSvc.h"
 
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/IAppMgrUI.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/SmartIF.h"
#include <algorithm> // for find
#include <fstream>
#include <iostream>
 
/////////////////////////////////////////////////////////////////////////////
// int EventWriter::counter = 0;    // static data member
DECLARE_COMPONENT( EventWriter )
EventWriter::EventWriter( const std::string& name, ISvcLocator* pSvcLocator )
    : Algorithm( name, pSvcLocator ) {
  m_itemNames.push_back( "/Event" );
  m_itemNames.push_back( "/Event/EventHeader" );
  m_itemNames.push_back( "/Event/Navigator" );
 
  m_itemNames.push_back( "/Event/Digi" );
  m_itemNames.push_back( "/Event/Digi/MdcDigiCol" );
  m_itemNames.push_back( "/Event/Digi/TofDigiCol" );
  m_itemNames.push_back( "/Event/Digi/EmcDigiCol" );
  m_itemNames.push_back( "/Event/Digi/MucDigiCol" );
 
  m_itemNames.push_back( "/Event/Hlt" );
  m_itemNames.push_back( "/Event/Hlt/HltRawCol" );
  m_itemNames.push_back( "/Event/Hlt/HltInf" );
  // m_itemNames.push_back("/Event/Hlt/DstHltInf");
 
  m_itemNames.push_back( "/Event/Recon" );
  //  m_itemNames.push_back("/Event/Recon/RecMdcHitCol");
  m_itemNames.push_back( "/Event/Recon/RecMdcTrackCol" );
  //   m_itemNames.push_back("/Event/Recon/MdcHOTCol");
  m_itemNames.push_back( "/Event/Recon/RecMdcDedxCol" );
  //    m_itemNames.push_back("/Event/Recon/RecMdcDedxHitCol");
  m_itemNames.push_back( "/Event/Recon/RecMdcKalTrackCol" );
  //   m_itemNames.push_back("/Event/Recon/RecMdcKalHelixSegCol");
  m_itemNames.push_back( "/Event/Recon/RecEsTimeCol" );
  m_itemNames.push_back( "/Event/Recon/RecExtTrackCol" );
  //    m_itemNames.push_back("/Event/Recon/RecBTofHitCol");
  //    m_itemNames.push_back("/Event/Recon/RecETofHitCol");
  m_itemNames.push_back( "/Event/Recon/RecTofTrackCol" );
  //    m_itemNames.push_back("/Event/Recon/RecBTofCalHitCol");
  //    m_itemNames.push_back("/Event/Recon/RecETofCalHitCol");
  m_itemNames.push_back( "/Event/Recon/RecEmcHitCol" );
  m_itemNames.push_back( "/Event/Recon/RecEmcClusterCol" );
  m_itemNames.push_back( "/Event/Recon/RecEmcShowerCol" );
  //    m_itemNames.push_back("/Event/Recon/MucRecHitCol");
  m_itemNames.push_back( "/Event/Recon/RecMucTrackCol" );
  m_itemNames.push_back( "/Event/Recon/EvtRecEvent" );
  m_itemNames.push_back( "/Event/Recon/EvtRecTrackCol" );
  //    m_itemNames.push_back("/Event/Recon/EvtRecVertexCol");
 
  // Part 1: Declare the properties
  declareProperty( "digiRootOutputFile", m_dofileName = "event.rec" );
  declareProperty( "ItemList", m_itemNames );
  declareProperty( "RunMode", m_mode = 2 );
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
EventWriter::~EventWriter() {
  // Part 1: Get the messaging service, print where you are
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << " EventWriter ~EventWriter()" << endmsg;
}
 
//**************************************************************************
StatusCode EventWriter::initialize() {
 
  // Part 1: Get the messaging service, print where you are
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << " EventWriter initialize()" << endmsg;
 
  StatusCode status = serviceLocator()->service( "RootCnvSvc", m_cnvSvc, false );
 
  if ( !status.isSuccess() )
    status = serviceLocator()->service( "EventCnvSvc", m_cnvSvc, true );
 
  status = serviceLocator()->service( "EventCnvSvc", m_pConversionSvc, true );
  if ( !status.isSuccess() )
  {
    log << MSG::FATAL << "Unable to locate IConversionSvc interface" << endmsg;
    return status;
  }
 
  status = serviceLocator()->service( "EventDataSvc", m_pDataProvider, true );
  if ( !status.isSuccess() )
  {
    log << MSG::FATAL << "Unable to locate IDataProviderSvc interface" << endmsg;
    return status;
  }
 
  if ( m_mode == 2 )
  { // OfflineMode
    m_single_outputFiles = new TFile( m_dofileName.c_str(), "RECREATE" );
    if ( m_single_outputFiles->IsZombie() || ( !m_single_outputFiles->IsWritable() ) )
    {
      std::cout << "EventWriter ERROR::Can't not open file" << m_dofileName.c_str()
                << std::endl;
      exit( 1 );
    }
 
    m_single_outputTrees = new TTree( "Event", "Event" );
    m_jobInfoTree        = new TTree( "JobInfoTree", "Job info" );
    jobInfo              = new TJobInfo;
  }
  else if ( m_mode == 3 )
  { // DistBossMode
    log << MSG::FATAL << "The DistBossMode has been abandoned!" << endmsg;
    return StatusCode::FAILURE;
  }
  else
  {
    log << MSG::FATAL << "Unvalid RunMode @ initialize(): " << m_mode << endmsg;
    exit( 1 );
  }
 
  status = getSvc();
  if ( !status.isSuccess() )
  {
    log << MSG::FATAL << "can not getSvc" << endmsg;
    return status;
  }
  st = 0;
 
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
StatusCode EventWriter::getSvc() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "getSvc()" << endmsg;
  StatusCode status = StatusCode::SUCCESS;
  if ( m_itemNames.empty() )
  {
    log << MSG::ERROR << "no ItemList from the jobOption" << endmsg;
    return StatusCode::FAILURE;
  }
  //   ItemNames    m_itemNames;
  clearItems( m_itemList );
  ItemNames::iterator i;
  for ( i = m_itemNames.begin(); i != m_itemNames.end(); i++ ) { addItem( m_itemList, *i ); }
  return status;
}
 
StatusCode EventWriter::execute() {
 
  // Part 1: Get the messaging service, print where you are
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "EventWriter execute()" << endmsg;
  collectObjects().ignore();
 
  if ( m_mode == 2 )
  { // OfflineMode
    if ( st != 1 )
    {
      if ( m_common.m_rectrackEvt )
        m_single_outputTrees->Branch( "TRecEvent", "TRecTrackEvent", &m_common.m_rectrackEvt,
                                      3200000, 1 );
      if ( m_common.m_evtRecObject )
        m_single_outputTrees->Branch( "TEvtRecObject", "TEvtRecObject",
                                      &m_common.m_evtRecObject, 3200000, 1 );
      if ( m_common.m_dstEvt )
        m_single_outputTrees->Branch( "TDstEvent", "TDstEvent", &m_common.m_dstEvt, 3200000,
                                      1 );
      if ( m_common.m_recEvt )
        m_single_outputTrees->Branch( "TDigiEvent", "TDigiEvent", &m_common.m_recEvt, 3200000,
                                      1 );
      if ( m_common.m_EvtHeader )
        m_single_outputTrees->Branch( "TEvtHeader", "TEvtHeader", &m_common.m_EvtHeader,
                                      3200000, 1 );
      if ( m_common.m_EvtNavigator )
        m_single_outputTrees->Branch( "TEvtNavigator", "TEvtNavigator",
                                      &m_common.m_EvtNavigator, 3200000, 1 );
      if ( m_common.m_hltEvt )
        m_single_outputTrees->Branch( "THltEvent", "THltEvent", &m_common.m_hltEvt, 3200000,
                                      1 );
      if ( m_common.m_mcEvt )
        m_single_outputTrees->Branch( "TMcEvent", "TMcEvent", &m_common.m_mcEvt, 3200000, 1 );
      if ( m_common.m_trigEvt )
        m_single_outputTrees->Branch( "TTrigEvent", "TTrigEvent", &m_common.m_trigEvt, 3200000,
                                      1 );
      m_jobInfoTree->Branch( "JobInfo", &jobInfo );
      st = 1;
    }
 
    if ( m_single_outputFiles->IsZombie() || ( !m_single_outputFiles->IsOpen() ) )
    {
      std::cout << "EventWriter ERROR::The ROOT File:" << m_dofileName.c_str()
                << "status is false" << std::endl;
      exit( 1 );
    }
    int nb = m_single_outputTrees->Fill();
    if ( nb == -1 )
    {
      log << MSG::FATAL << "Error in fill tree (EventWriter) "
          << m_single_outputTrees->GetName() << " with " << nb << " bytes" << endmsg;
      exit( 1 );
    }
 
    m_single_outputFiles = m_single_outputTrees->GetCurrentFile();
  }
  else if ( m_mode == 3 )
  { // DistBossMode
    log << MSG::FATAL << "The DistBossMode has been abandoned!" << endmsg;
    return StatusCode::FAILURE;
  }
 
  m_common.clear();
 
  return StatusCode::SUCCESS;
}
 
void EventWriter::addItem( Items& itms, const std::string& descriptor ) {
  MsgStream   log( msgSvc(), name() );
  int         level = 0;
  size_t      sep   = descriptor.rfind( "#" );
  std::string obj_path( descriptor, 0, sep );
  std::string slevel( descriptor, sep + 1, descriptor.length() );
  if ( slevel == "*" ) { level = 9999999; }
  else { level = atoi( slevel.c_str() ); }
  size_t idx = obj_path.find( "/", 1 );
  while ( idx != std::string::npos )
  {
    std::string sub_item = obj_path.substr( 0, idx );
    if ( 0 == findItem( sub_item ) ) { addItem( itms, sub_item + "#1" ); }
    idx = obj_path.find( "/", idx + 1 );
  }
  DataStoreItem* item = new DataStoreItem( obj_path, level );
  log << MSG::DEBUG << "Adding OutputStream item " << item->path() << " with " << item->depth()
      << " level(s)." << endmsg;
  itms.push_back( item );
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
void EventWriter::clearItems( Items& itms ) {
  for ( Items::iterator i = itms.begin(); i != itms.end(); i++ ) { delete ( *i ); }
  itms.erase( itms.begin(), itms.end() );
}
 
DataStoreItem* EventWriter::findItem( const std::string& path ) {
  for ( Items::const_iterator i = m_itemList.begin(); i != m_itemList.end(); ++i )
  {
    if ( ( *i )->path() == path ) return ( *i );
  }
  return 0;
}
 
StatusCode EventWriter::collectObjects() {
  MsgStream       log( msgSvc(), name() );
  StatusCode      status = StatusCode::SUCCESS;
  Items::iterator i;
 
  // Traverse the tree and collect the requested objects
  //    status = m_pConversionSvc->connectOutput(f_rootOutputFile.c_str(), "recreate");
 
  for ( i = m_itemList.begin(); i != m_itemList.end(); i++ )
  {
    DataObject*     obj      = 0;
    IOpaqueAddress* pAddress = 0;
    m_currentItem            = ( *i );
 
    status = m_pDataProvider->retrieveObject( m_currentItem->path(), obj );
    if ( status.isSuccess() )
    {
      status = m_pConversionSvc->createRep( obj, pAddress );
      // IRegistry *pReg = obj->registry();
      // pReg->setAddress(pAddress);
      // status = m_pConversionSvc->fillRepRefs(pReg->address(), *i);
    }
    else
    {
      log << MSG::ERROR
          << "Cannot write mandatory object(s) (Not found): " << m_currentItem->path()
          << endmsg;
    }
  }
 
  return status;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
StatusCode EventWriter::finalize() {
 
  // Part 1: Get the messaging service, print where you are
  MsgStream log( msgSvc(), name() );
  int       st = 1;
  std::cout << "11111111111111111111111111" << std::endl;
 
  if ( m_mode == 2 )
  { // OfflineMode
    m_bossVer = getenv( "BES_RELEASE" );
    log << MSG::INFO << "fill boss version: " << m_bossVer << endmsg;
 
    string tmpJobOptions = getJobOptions();
    m_jobOptions.push_back( tmpJobOptions );
 
    if ( m_decayOptions.size() == 0 ) m_decayOptions = getDecayOptions();
 
    jobInfo->setBossVer( m_bossVer );
    jobInfo->setJobOptions( m_jobOptions );
    jobInfo->setDecayOptions( m_decayOptions );
 
    m_jobInfoTree->Fill();
 
    st = m_single_outputFiles->Write();
    if ( st == 0 )
    {
      log << MSG::FATAL << "can not write to the file " << m_dofileName.c_str() << endmsg;
      exit( 1 );
    }
    m_single_outputFiles->Close();
 
    delete m_single_outputFiles;
    delete jobInfo;
  }
 
  if ( m_mode == 3 )
  { // DistBossMode
    log << MSG::FATAL << "The DistBossMode has been abandoned!" << endmsg;
    return StatusCode::FAILURE;
  }
 
  log << MSG::INFO << "EventWriter finalize()" << endmsg;
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
std::string EventWriter::getJobOptions() {
  MsgStream   log( msgSvc(), name() );
  IInterface* iface = Gaudi::createApplicationMgr();
  SmartIF<IProperty> propMgr( iface );
  std::string        path;
  propMgr->getProperty( "JobOptionsPath", path ).ignore();
  log << MSG::INFO << "JobOptions file for current job: " << path << endmsg;
  ifstream fin( path.c_str() );
  string   jobOptions;
  string   tempString;
  while ( getline( fin, tempString ) )
  {
    if ( tempString.size() > 0 && tempString.find( "//" ) > tempString.size() )
    {
      jobOptions += tempString;
      jobOptions += "\n";
    }
  }
  log << MSG::INFO << "JobOptions: " << endmsg << jobOptions << endmsg;
  return jobOptions;
}
 
std::string EventWriter::getDecayOptions() {
  MsgStream     log( msgSvc(), name() );
  ISvcLocator*  svcLocator = Gaudi::svcLocator();
  IDataInfoSvc* jobInfoSvc;
  string        decayOptions;
  StatusCode    status = svcLocator->service( "DataInfoSvc", jobInfoSvc );
  if ( status.isSuccess() )
  {
    log << MSG::INFO << "get the DataInfoSvc" << endmsg;
    decayOptions = jobInfoSvc->getDecayOptions();
    log << MSG::INFO << "get decay options" << endmsg << decayOptions << endmsg;
  }
  else { log << MSG::WARNING << "could not get the DataInfoSvc. Ignore it." << endmsg; }
  return decayOptions;
}