EventWriterTool.cxx

Go to the documentation of this file.

#include <Gaudi/PluginServiceV2.h>
#include <GaudiKernel/IAppMgrUI.h>
#include <TTree.h>
#include <fstream>
#include <string>
#include <vector>
 
#include "DataInfoSvc/IDataInfoSvc.h"
#include "RootEventData/TJobInfo.h"
 
#include "EventWriterTool.h"
 
DECLARE_COMPONENT( EventWriterTool )
 
StatusCode EventWriterTool::initialize() {
  info() << "In initialize()" << endmsg;
 
  StatusCode sc = service( "RootCnvSvc", m_cnvSvc, false );
  if ( !sc.isSuccess() ) sc = service( "EventCnvSvc", m_cnvSvc, true );
  if ( !sc.isSuccess() )
  {
    error() << "Unable to locate IRootCnvSvc interface" << endmsg;
    return sc;
  }
 
  sc = service( "EventDataSvc", m_pDataProvider, true );
  if ( !sc.isSuccess() )
  {
    error() << "Unable to locate IDataProviderSvc interface" << endmsg;
    return sc;
  }
 
  if ( m_mode == 2 )
  { // Offline
    m_outputFile = new TFile( m_dofileName.value().c_str(), "RECREATE" );
    if ( m_outputFile->IsZombie() || !m_outputFile->IsWritable() )
    {
      error() << "Can't open file " << m_dofileName.value() << endmsg;
      return StatusCode::FAILURE;
    }
 
    m_outputTree  = new TTree( "Event", "Event" );
    m_jobInfoTree = new TTree( "JobInfoTree", "Job info" );
    m_jobInfo     = new TJobInfo;
  }
  else if ( m_mode == 3 )
  {
    error() << "The DistBossMode has been abandoned!" << endmsg;
    return StatusCode::FAILURE;
  }
  else
  {
    error() << "Invalid RunMode @ initialize(): " << m_mode << endmsg;
    return StatusCode::FAILURE;
  }
 
  // get services
  if ( m_itemNames.empty() )
  {
    error() << "no ItemList from the jobOption" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // clear items
  for ( auto& item : m_itemLists ) { delete item; }
  m_itemLists.clear();
 
  // add items
  for ( const auto& item : m_itemNames ) { addItem( m_itemLists, item ); }
 
  // reset status
  m_st = 0;
 
  return StatusCode::SUCCESS;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void EventWriterTool::addItem( std::vector<DataStoreItem*>& items,
                             const std::string&           descriptor ) {
  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 = std::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 ( findItem( sub_item ) == nullptr ) addItem( items, sub_item + "#1" );
    idx = obj_path.find( "/", idx + 1 );
  }
 
  DataStoreItem* item = new DataStoreItem( obj_path, level );
  debug() << "Adding OutputStream item " << item->path() << " with " << item->depth()
          << " level(s)." << endmsg;
 
  items.push_back( item );
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
DataStoreItem* EventWriterTool::findItem( const std::string& path ) {
  for ( const auto& item : m_itemLists )
  {
    if ( item->path() == path ) return item;
  }
  return nullptr;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
StatusCode EventWriterTool::write() {
  info() << "In write()" << endmsg;
 
  /* Collect objects */
  StatusCode sc;
  for ( const auto& item : m_itemLists )
  {
    DataObject*     obj      = nullptr;
    IOpaqueAddress* pAddress = nullptr;
 
    sc = m_pDataProvider->retrieveObject( item->path(), obj );
    if ( !sc.isSuccess() )
    { error() << "Cannot write mandatory object(s) (Not found): " << item->path() << endmsg; }
    else
    {
      sc = dynamic_cast<IConversionSvc*>( m_cnvSvc )->createRep( obj, pAddress );
 
      // Only warn here because old version of `EventWriter` did so.
      if ( !sc.isSuccess() )
        warning() << "Failed to create rep for " << item->path() << endmsg;
    }
  }
 
  /* Write to file */
  if ( m_mode == 2 )
  {
    if ( m_st != 1 )
    {
      if ( m_commonData.m_rectrackEvt )
        m_outputTree->Branch( "TRecEvent", "TRecTrackEvent", &m_commonData.m_rectrackEvt,
                              3200000, 1 );
      if ( m_commonData.m_evtRecObject )
        m_outputTree->Branch( "TEvtRecObject", "TEvtRecObject", &m_commonData.m_evtRecObject,
                              3200000, 1 );
      if ( m_commonData.m_dstEvt )
        m_outputTree->Branch( "TDstEvent", "TDstEvent", &m_commonData.m_dstEvt, 3200000, 1 );
      if ( m_commonData.m_recEvt )
        m_outputTree->Branch( "TDigiEvent", "TDigiEvent", &m_commonData.m_recEvt, 3200000, 1 );
      if ( m_commonData.m_EvtHeader )
        m_outputTree->Branch( "TEvtHeader", "TEvtHeader", &m_commonData.m_EvtHeader, 3200000,
                              1 );
      if ( m_commonData.m_EvtNavigator )
        m_outputTree->Branch( "TEvtNavigator", "TEvtNavigator", &m_commonData.m_EvtNavigator,
                              3200000, 1 );
      if ( m_commonData.m_hltEvt )
        m_outputTree->Branch( "THltEvent", "THltEvent", &m_commonData.m_hltEvt, 3200000, 1 );
      if ( m_commonData.m_mcEvt )
        m_outputTree->Branch( "TMcEvent", "TMcEvent", &m_commonData.m_mcEvt, 3200000, 1 );
      if ( m_commonData.m_trigEvt )
        m_outputTree->Branch( "TTrigEvent", "TTrigEvent", &m_commonData.m_trigEvt, 3200000,
                              1 );
      m_jobInfoTree->Branch( "JobInfo", &m_jobInfo );
      m_st = 1;
    }
 
    if ( m_outputFile->IsZombie() || !m_outputFile->IsOpen() )
    {
      error() << "Can not write to the file " << m_dofileName << endmsg;
      return StatusCode::FAILURE;
    }
 
    int nb = m_outputTree->Fill();
    if ( nb == -1 )
    {
      error() << "Error in fill tree (EventWriter) " << m_outputTree->GetName() << " with "
              << nb << " bytes" << endmsg;
      return StatusCode::FAILURE;
    }
 
    m_outputFile = m_outputTree->GetCurrentFile();
  }
  else if ( m_mode == 3 )
  {
    error() << "The DistBossMode has been deprecated!" << endmsg;
    return StatusCode::FAILURE;
  }
 
  m_commonData.clear();
 
  return StatusCode::SUCCESS;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
StatusCode EventWriterTool::finalize() {
  info() << "In finalize()" << endmsg;
 
  if ( m_mode == 2 )
  {
    char* bossVer = getenv( "BES_RELEASE" );
    info() << "fill boss version: " << bossVer << endmsg;
 
    /* Get jobOptions */
    std::string path;
    auto        mgrProp = SmartIF<IProperty>( Gaudi::createApplicationMgr() );
    mgrProp->getProperty( "JobOptionsPath", path ).ignore();
 
    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";
      }
    }
    // info() << "JobOptions: " << endmsg << jobOptions << endmsg;
 
    vector<string> jobOptionsVec = { jobOptions };
 
    auto   jobInfoSvc = service<IDataInfoSvc>( "DataInfoSvc" );
    string decayOptions;
    if ( !jobInfoSvc ) warning() << "Could not get DataInfoSvc" << endmsg;
    else
    {
      decayOptions = jobInfoSvc->getDecayOptions();
      info() << "Get decay options: " << decayOptions << endmsg;
    }
 
    m_jobInfo->setBossVer( bossVer );
    m_jobInfo->setJobOptions( jobOptionsVec );
    m_jobInfo->setDecayOptions( decayOptions );
 
    m_jobInfoTree->Fill();
 
    m_st = m_outputFile->Write();
    if ( m_st == 0 )
    {
      error() << "Can not write to the file " << m_dofileName << endmsg;
      return StatusCode::FAILURE;
    }
    m_outputFile->Close();
 
    delete m_outputFile;
    delete m_jobInfo;
 
    m_outputFile = nullptr;
    m_outputTree = nullptr;
  }
 
  if ( m_mode == 3 )
  {
    error() << "The DistBossMode has been deprecated!" << endmsg;
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}