RootCnvSvc.cxx

Go to the documentation of this file.

#define RootCnvSvc_CXX
#include "GaudiKernel/SmartIF.h"
#include <filesystem>
#include <iostream>
 
#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/RegistryEntry.h"
 
#include "DstEvent/DstEvent.h"
#include "HltEvent/HltEvent.h" //fucd
#include "McTruth/McEvent.h"
#include "RawEvent/DigiEvent.h"
#include "RootCnvSvc/RootInterface.h"
#include "TrigEvent/TrigEvent.h" //caogf
 
#include "RootCnvSvc/RootAddress.h"
#include "RootCnvSvc/RootCnvSvc.h"
#include "RootCnvSvc/RootEvtSelector.h"
 
#include "RootCnvSvc/Digi/DigiCnv.h"
#include "RootCnvSvc/Digi/EmcDigiCnv.h"
#include "RootCnvSvc/Digi/LumiDigiCnv.h"
#include "RootCnvSvc/Digi/MdcDigiCnv.h"
#include "RootCnvSvc/Digi/MucDigiCnv.h"
#include "RootCnvSvc/Digi/TofDigiCnv.h"
#include "RootCnvSvc/Dst/DstCnv.h"
#include "RootCnvSvc/Dst/EmcTrackCnv.h"
#include "RootCnvSvc/Dst/ExtTrackCnv.h"
#include "RootCnvSvc/Dst/MdcDedxCnv.h"
#include "RootCnvSvc/Dst/MdcKalTrackCnv.h"
#include "RootCnvSvc/Dst/MdcTrackCnv.h"
#include "RootCnvSvc/Dst/MucTrackCnv.h"
#include "RootCnvSvc/Dst/TofTrackCnv.h"
#include "RootCnvSvc/EventCnv.h"
#include "RootCnvSvc/Mc/EmcMcHitCnv.h"
#include "RootCnvSvc/Mc/McCnv.h"
#include "RootCnvSvc/Mc/McParticleCnv.h"
#include "RootCnvSvc/Mc/MdcMcHitCnv.h"
#include "RootCnvSvc/Mc/MucMcHitCnv.h"
#include "RootCnvSvc/Mc/TofMcHitCnv.h"
 
#include "RootCnvSvc/Rec/RecBTofCalHitCnv.h"
#include "RootCnvSvc/Rec/RecETofCalHitCnv.h"
#include "RootCnvSvc/Rec/RecEmcClusterCnv.h"
#include "RootCnvSvc/Rec/RecEmcHitCnv.h"
#include "RootCnvSvc/Rec/RecEmcShowerCnv.h"
#include "RootCnvSvc/Rec/RecEvTimeCnv.h"
#include "RootCnvSvc/Rec/RecExtTrackCnv.h"
#include "RootCnvSvc/Rec/RecMdcDedxCnv.h"
#include "RootCnvSvc/Rec/RecMdcDedxHitCnv.h"
#include "RootCnvSvc/Rec/RecMdcHitCnv.h"
#include "RootCnvSvc/Rec/RecMdcKalHelixSegCnv.h"
#include "RootCnvSvc/Rec/RecMdcKalTrackCnv.h"
#include "RootCnvSvc/Rec/RecMdcTrackCnv.h"
#include "RootCnvSvc/Rec/RecMucRecHitCnv.h"
#include "RootCnvSvc/Rec/RecMucTrackCnv.h"
#include "RootCnvSvc/Rec/RecTofTrackCnv.h"
#include "RootCnvSvc/Rec/RecTrackCnv.h"
 
#include "RootCnvSvc/EvtRec/EvtRecCnv.h"
#include "RootCnvSvc/EvtRec/EvtRecDTagCnv.h"
#include "RootCnvSvc/EvtRec/EvtRecEtaToGGCnv.h"
#include "RootCnvSvc/EvtRec/EvtRecEventCnv.h"
#include "RootCnvSvc/EvtRec/EvtRecPi0Cnv.h"
#include "RootCnvSvc/EvtRec/EvtRecPrimaryVertexCnv.h"
#include "RootCnvSvc/EvtRec/EvtRecTrackCnv.h"
#include "RootCnvSvc/EvtRec/EvtRecVeeVertexCnv.h"
#include "RootCnvSvc/Rec/RecZddChannelCnv.h"
 
#include "RootCnvSvc/Trig/TrigCnv.h"
#include "RootCnvSvc/Trig/TrigDataCnv.h"
 
#include "RootCnvSvc/Hlt/DstHltInfCnv.h"
#include "RootCnvSvc/Hlt/HltCnv.h"
#include "RootCnvSvc/Hlt/HltInfCnv.h"
#include "RootCnvSvc/Hlt/HltRawCnv.h"
 
#include "RootCnvSvc/EvtHeaderCnv.h"
#include "RootCnvSvc/EvtNavigatorCnv.h"
 
#include <math.h>
 
using namespace std;
 
// RCS Id for identification of object version
static const char* rcsid = "$Id: RootCnvSvc.cxx,v 1.74 2022/02/21 22:04:49 maqm Exp $";
 
DECLARE_COMPONENT( RootCnvSvc )
 
// Instantiation of a static factory class used by clients to create
// instances of this service
// static const SvcFactory<RootCnvSvc> s_RootCnvSvcFactory;
// const ISvcFactory& RootCnvSvcFactory = s_RootCnvSvcFactory;
 
RootCnvSvc::RootCnvSvc( const std::string& name, ISvcLocator* svc )
    : base_class( name, svc, ROOT_StorageType ), m_minSplit( 1 ), m_evtsel( 0 ) {
 
  // Digi
  declareProperty( "digiTreeName", m_dtreeName = "Event" ); //"Rec"->"Event"
 
  declareProperty( "digiRootInputFile", m_difileName );
  declareProperty( "digiRootOutputFile", m_dofileName = "" );
 
  // Split mode for writing the TTree [0,99]
  declareProperty( "digiSplitMode", m_dsplitMode = m_minSplit );
  // Buffer size for writing ROOT data
  declareProperty( "digiBufferSize", m_dbufSize = 3200000 );
  // ROOT default compression
  declareProperty( "digiCompressionLevel", m_dcompressionLevel = 1 );
  declareProperty( "selectFromTag", m_selectFromTag = 0 );
  declareProperty( "tagInputFile", m_tagInputFile );
  // declareProperty("tagFileFormat", m_tagFileFormat=1);
 
  declareProperty( "readETS", m_readETS = false );
}
 
StatusCode RootCnvSvc::initialize() {
  // Purpose and Method:  Setup GLAST's Event Converter Service.
  //   Associate RootCnvSvc with the EventDataSvc
  //   Associate the list of known converters with this RootCnvSvc
  //   configure map of leaves
 
  MsgStream log( msgSvc(), name() );
 
  StatusCode sc;
  log << MSG::DEBUG << "RootCnvSvc::initialize" << endmsg;
 
  IService* isvc = 0;
  sc             = serviceLocator()->getService( "RootEvtSelector", isvc, false );
  if ( !sc.isSuccess() ) sc = serviceLocator()->getService( "EventSelector", isvc, false );
  if ( sc.isSuccess() )
  { sc = isvc->queryInterface( IID_IRootEvtSelector, (void**)&m_evtsel ); }
  if ( sc.isFailure() )
  {
    log << MSG::WARNING << "Unable to start event selector service within RootCnvSvc"
        << endmsg;
  }
 
  m_rootInterface = RootInterface::Instance( name() );
  if ( !m_rootInterface )
    log << MSG::ERROR << "Unable to start Root service within RootCnvSvc" << endmsg;
 
  StatusCode status = ConversionSvc::initialize();
  if ( status.isSuccess() )
  {
    //        ISvcLocator* svclocator = serviceLocator();  [unused for now]
    IDataProviderSvc* pIDP = 0;
    // Set event data service
    status = service( "EventDataSvc", pIDP, true );
    if ( status.isSuccess() ) { status = setDataProvider( pIDP ); }
    else { return status; }
 
    // Add converters to the service
    status = addConverters();
    if ( !status.isSuccess() )
    {
      log << MSG::ERROR << "Unable to add converters to the service" << endmsg;
      return status;
    }
 
    // Now we have to configure the map of leaves
    // Which should contain the association of converters with
    // paths on the TDS
    for ( LeafMap::iterator k = m_leaves.begin(); k != m_leaves.end(); k++ )
    {
      std::string path = ( *k ).first;
      for ( LeafMap::iterator j = m_leaves.begin(); j != m_leaves.end(); j++ )
      {
        std::string path2 = ( *j ).first;
        std::string pp    = ( *j ).first.substr( 0, ( *j ).first.rfind( "/" ) );
        if ( path == pp && path != ( *j ).first )
        { ( *k ).second->push_back( ( *j ).second ); }
      }
    }
  }
 
  // get properties and tell RootInterface about files
  status = initFiles();
 
  m_rootInterface->setSelectFromTag( m_selectFromTag );
  if ( m_selectFromTag && m_tagInputFile.empty() ) { m_tagInputFile = m_difileName; }
  m_rootInterface->setTagInputFile( m_tagInputFile );
  // m_rootInterface->setTagFileFormat(m_tagFileFormat);
 
  return status;
}
 
StatusCode RootCnvSvc::finalize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "RootCnvSvc::finalize" << endmsg;
 
  ConversionSvc::finalize();
  // log << MSG::INFO<<"this is the end of RootCnvsvc finalize"<<endmsg;
  for ( LeafMap::iterator k = m_leaves.begin(); k != m_leaves.end(); k++ )
  { delete ( *k ).second; }
  m_leaves.erase( m_leaves.begin(), m_leaves.end() );
 
  return m_rootInterface->finalize();
}
 
StatusCode RootCnvSvc::initFiles() {
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "RootCnvSvc::initFiles" << endmsg;
  StatusCode sc = StatusCode::SUCCESS;
 
  // Use the Job options service to set the Algorithm's parameters
  // This will retrieve parameters set in the job options file
  // setProperties();
 
  // Read inpout files files from job options
  int nSize = m_difileName.size();
  log << MSG::INFO << "Root Input files " << nSize << endmsg;
  if ( nSize == 0 )
  {
    log << MSG::INFO << "Unable to find input file" << endmsg;
    // return StatusCode::FAILURE;
  }
 
  for ( int i = 0; i < nSize; i++ )
  {
    facilities::Util::expandEnvVar( &m_difileName[i] );
    /*std::string s=m_difileName[i];
    std::vector<int> wildcardPos;
    for(int pos=0;pos<s.size();pos++) {
      pos=s.find_first_of('?',pos);
      if(pos!=-1) {
        wildcardPos.push_back(pos);
      }
      else{
        break;
      }
    }
    if(wildcardPos.size()!=0) {
      int nEnd=facilities::Util::catchOptionVal(&s)+1;
      int maxNo=pow(10.,(int)wildcardPos.size());
      if(nEnd!=0&&nEnd<maxNo) maxNo=nEnd;
      int nStart=facilities::Util::catchOptionVal(&s,0,"&(",")");
      int i=1;
      if(nStart!=-1) i=nStart;
      if(nStart>nEnd) log<<MSG::WARNING<<"file's StartNo>EndNo"<<endmsg;
      for(;i<maxNo;i++){
        std::vector<int>::iterator it=wildcardPos.end();
        int id=i;
        while(it!=wildcardPos.begin()){
          it--;
          char c=id%10+48;
          id /=10;
          s.replace((*it),1,1,c);
        }
        if(access(s.c_str(),0)!=-1) {
          sc = m_rootInterface->addInput(m_dtreeName,s);
          if (sc.isFailure()) return sc;
        }
      }
    }
    else {*/
 
    // Check if the file exists
    if ( !filesystem::is_regular_file( m_difileName[i] ) )
    {
      error() << "Input file does not exist: " << m_difileName[i] << endmsg;
      return StatusCode::FAILURE;
    }
 
    sc = m_rootInterface->addInput( m_dtreeName, m_difileName[i] );
    if ( sc.isFailure() ) return sc;
    // }
  }
 
  // facilities::Util::expandEnvVar(&m_difileName[0]);
  // sc = m_rootInterface->addInput(m_dtreeName,m_difileName[0]);
  // if (sc.isFailure()) return sc;
 
  // Digi
  // facilities::Util::expandEnvVar(&m_difileName);
  facilities::Util::expandEnvVar( &m_dofileName );
  // sc = m_rootInterface->addInput(m_dtreeName,m_difileName);
  // if (sc.isFailure()) return sc;
 
  if ( m_dsplitMode < m_minSplit )
  {
    log << MSG::WARNING << "RootCnvSvc::initFiles Recon splitlevel cant be lower than "
        << m_minSplit << ", reset" << endmsg;
    m_dsplitMode = m_minSplit;
  }
 
  if ( "" != m_dofileName )
  {
    sc = m_rootInterface->addOutput( m_dtreeName, m_dofileName, m_dsplitMode, m_dbufSize,
                                     m_dcompressionLevel );
  }
  else { log << MSG::WARNING << "No specified digiRootOutputFile!" << endmsg; }
 
  return sc;
}
 
StatusCode RootCnvSvc::declareObject( const Leaf& leaf ) {
  // Purpose and Method:  Callback from each of the individual converters that allows
  //  association of TDS path and converter.
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "RootCnvSvc::declareObject " << leaf.path << " classid: " << leaf.clid
      << endmsg;
  Leaf*                              ll = new Leaf( leaf );
  std::pair<LeafMap::iterator, bool> p =
      m_leaves.insert( LeafMap::value_type( leaf.path, ll ) );
  if ( p.second ) { return StatusCode::SUCCESS; }
  delete ll;
  return StatusCode::FAILURE;
}
 
/// Update state of the service
StatusCode RootCnvSvc::updateServiceState( IOpaqueAddress* pAddress ) {
 
  // not sure about the use of recid or bank...
  MsgStream log( msgSvc(), name() );
 
  log << MSG::DEBUG << "RootCnvSvc::updateServiceState" << endmsg;
 
  StatusCode status = StatusCode::FAILURE;
  IRegistry* ent    = pAddress->registry();
  if ( 0 != ent )
  {
    SmartIF<IDataManagerSvc> iaddrReg( dataProvider() );
    //       if ( 0 != iaddrReg )   {
    status                 = StatusCode::SUCCESS;
    std::string       path = ent->identifier();
    LeafMap::iterator itm  = m_leaves.find( path );
    if ( itm != m_leaves.end() )
    {
      Leaf* leaf = ( *itm ).second;
      if ( 0 != leaf )
      {
        for ( Leaf::iterator il = leaf->begin(); il != leaf->end(); il++ )
        {
          IOpaqueAddress* newAddr  = 0;
          unsigned long   ipars[2] = { 0, 0 }; //
          if ( m_evtsel ) ipars[0] = m_evtsel->getRecId();
 
          std::string spars[3] = { ( *il )->path, ( *il )->treename, ( *il )->branchname };
 
          StatusCode ir =
              createAddress( ROOT_StorageType, ( *il )->clid, spars, ipars, newAddr );
          log << MSG::DEBUG << "RootCnvSvc::updateService "
              << " *****  " << ( *il )->clid << " *****  " << ( *il )->path << endmsg;
 
          if ( ir.isSuccess() )
          {
            ir = iaddrReg->registerAddress( ( *il )->path, newAddr );
            if ( !ir.isSuccess() )
            {
              newAddr->release();
              status = ir;
            }
          }
        }
      }
    }
  }
  return StatusCode::SUCCESS;
}
 
// StatusCode RootCnvSvc::queryInterface( const InterfaceID& riid, void** ppvInterface ) {
 
//   if ( IID_IRootCnvSvc == riid ) { *ppvInterface = (RootCnvSvc*)this; }
//   else
//   {
//     // Interface is not directly availible: try out a base class
//     return ConversionSvc::queryInterface( riid, ppvInterface );
//   }
//   addRef();
//   return StatusCode::SUCCESS;
// }
 
StatusCode RootCnvSvc::createAddress( long int svc_type, const CLID& clid,
                                      const std::string* spars, const unsigned long* ipars,
                                      IOpaqueAddress*& refpAddress ) {
  MsgStream log( msgSvc(), name() );
 
  if ( svc_type != repSvcType() )
  {
    log << MSG::ERROR << "RootCnvSvc::bad storage type" << svc_type << endmsg;
    return StatusCode::FAILURE;
  }
 
  std::string path       = spars[0];
  std::string treename   = spars[1];
  std::string branchname = spars[2];
  int         entry      = ipars[0];
  if ( path.size() == 0 ) path = "/Event";
  refpAddress = new RootAddress( ROOT_StorageType, clid, path, treename, branchname, entry );
  return StatusCode::SUCCESS;
}
 
StatusCode RootCnvSvc::commitOutput( const std::string& output, bool do_commit ) {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "RootCnvSvc::commitOutput starts." << endmsg;
 
  StatusCode sc = m_rootInterface->fillTrees();
  if ( sc.isFailure() ) log << MSG::ERROR << "No Root tree was filled" << endmsg;
 
  // objects must be cleared after fill
  else
  {
    TObject* oEvtHeader = m_evtheaderCnv->getWriteObject();
    if ( oEvtHeader ) oEvtHeader->Clear();
    TObject* oEvtNavigator = m_evtnavigatorCnv->getWriteObject();
    if ( oEvtNavigator ) oEvtNavigator->Clear();
    TObject* o = m_dCnv->getWriteObject();
    if ( o ) o->Clear();
    TObject* oDst = m_dstCnv->getWriteObject();
    if ( oDst ) oDst->Clear();
    TObject* oMc = m_mcCnv->getWriteObject();
    if ( oMc ) oMc->Clear();
    TObject* oRecTrack = m_rectrackCnv->getWriteObject();
    if ( oRecTrack ) oRecTrack->Clear();
    TObject* oEvtRecEvent = m_evtRecCnv->getWriteObject();
    if ( oEvtRecEvent ) oEvtRecEvent->Clear();
    TObject* oTrig = m_trigCnv->getWriteObject();
    if ( oTrig ) oTrig->Clear();
    TObject* oHlt = m_hltCnv->getWriteObject();
    if ( oHlt ) oHlt->Clear();
  }
  m_common.clear();
 
  return sc;
}
 
StatusCode RootCnvSvc::createAddress( DataObject* obj, IOpaqueAddress*& newAddr ) {
 
  //    create address for this object
  MsgStream log( msgSvc(), name() );
 
  log << MSG::DEBUG << "RootCnvSvc::createAddress" << endmsg;
 
  StatusCode status = StatusCode::FAILURE;
  IRegistry* ent    = obj->registry();
 
  if ( 0 != ent )
  {
    SmartIF<IDataManagerSvc> iaddrReg( dataProvider() );
    std::string              path = ent->identifier();
    LeafMap::iterator        itm  = m_leaves.find( path );
 
    if ( itm != m_leaves.end() )
    {
      Leaf* leaf = ( *itm ).second;
      if ( 0 != leaf )
      {
        std::string spars[3];
        spars[0] = path;
        spars[1] = leaf->treename;
        spars[2] = leaf->branchname;
 
        unsigned long ipars[2] = { 0, 0 };
        if ( m_evtsel ) ipars[0] = m_evtsel->getRecId();
 
        status = addressCreator()->createAddress( ROOT_StorageType, leaf->clid, spars, ipars,
                                                  newAddr );
        if ( status.isSuccess() )
        {
          status = iaddrReg->registerAddress( (IRegistry*)0, path, newAddr );
          if ( !status.isSuccess() ) { newAddr->release(); }
        }
        return StatusCode::SUCCESS;
      }
    }
    else { log << MSG::ERROR << "Leaf not found for path: " << path << endmsg; }
  }
  return status;
}
 
StatusCode RootCnvSvc::createAddress( std::string path, IOpaqueAddress*& newAddr ) {
 
  //    create address for this object
  MsgStream log( msgSvc(), name() );
 
  StatusCode               status;
  LeafMap::iterator        itm = m_leaves.find( path );
  SmartIF<IDataManagerSvc> iaddrReg( dataProvider() );
  if ( itm != m_leaves.end() )
  {
    Leaf* leaf = ( *itm ).second;
    if ( 0 != leaf )
    {
      std::string spars[3];
      spars[0] = path;
      spars[1] = leaf->treename;
      spars[2] = leaf->branchname;
 
      unsigned long ipars[2] = { 0, 0 };
      if ( m_evtsel ) ipars[0] = m_evtsel->getRecId();
      status = addressCreator()->createAddress( ROOT_StorageType, leaf->clid, spars, ipars,
                                                newAddr );
      if ( status.isSuccess() )
      {
        status = iaddrReg->registerAddress( (IRegistry*)0, path, newAddr );
        if ( !status.isSuccess() ) { newAddr->release(); }
      }
      return StatusCode::SUCCESS;
    }
  }
 
  return StatusCode::FAILURE;
}
 
/// Add converters to the service
StatusCode RootCnvSvc::addConverters() {
  MsgStream log( msgSvc(), name() );
  declareObject(
      Leaf( EventModel::Dst::DstMdcDedxCol, MdcDedxCnv::classID(), "Event", "m_mdcDedxCol" ) );
  declareObject( Leaf( EventModel::Dst::Event, DstCnv::classID(), "Event", "" ) );
  declareObject(
      Leaf( EventModel::Digi::EmcDigiCol, EmcDigiCnv::classID(), "Event", "m_emcDigiCol" ) );
  declareObject(
      Leaf( EventModel::MC::EmcMcHitCol, EmcMcHitCnv::classID(), "Event", "m_emcMcHitCol" ) );
  declareObject( Leaf( EventModel::Dst::DstEmcShowerCol, EmcTrackCnv::classID(), "Event",
                       "m_emcTrackCol" ) );
 
  declareObject( Leaf( "/Event", EventCnv::classID(), "", "" ) );
  if ( m_readETS )
  {
    declareObject(
        Leaf( EventModel::EventHeader, EvtHeaderCnv::classID(), "Event",
              "m_runId:m_eventId:m_time:m_eventTag:m_flag1:m_flag2:m_etsT1:m_etsT2" ) );
  }
  else
  {
    declareObject( Leaf( EventModel::EventHeader, EvtHeaderCnv::classID(), "Event",
                         "m_runId:m_eventId:m_time:m_eventTag:m_flag1:m_flag2" ) );
  }
  declareObject( Leaf( EventModel::Navigator, EvtNavigatorCnv::classID(), "Event",
                       "m_mcMdcMcHits:m_mcMdcTracks:m_mcEmcMcHits:m_mcEmcRecShowers" ) );
  declareObject( Leaf( EventModel::Dst::DstExtTrackCol, ExtTrackCnv::classID(), "Event",
                       "m_extTrackCol" ) );
  declareObject( Leaf( EventModel::MC::Event, McCnv::classID(), "Event", "" ) );
  declareObject( Leaf( EventModel::MC::McParticleCol, McParticleCnv::classID(), "Event",
                       "m_mcParticleCol" ) );
  declareObject(
      Leaf( EventModel::Digi::MdcDigiCol, MdcDigiCnv::classID(), "Event", "m_mdcDigiCol" ) );
  declareObject( Leaf( EventModel::Dst::DstMdcKalTrackCol, MdcKalTrackCnv::classID(), "Event",
                       "m_mdcKalTrackCol" ) );
  declareObject(
      Leaf( EventModel::MC::MdcMcHitCol, MdcMcHitCnv::classID(), "Event", "m_mdcMcHitCol" ) );
  declareObject( Leaf( EventModel::Dst::DstMdcTrackCol, MdcTrackCnv::classID(), "Event",
                       "m_mdcTrackCol" ) );
  declareObject(
      Leaf( EventModel::Digi::MucDigiCol, MucDigiCnv::classID(), "Event", "m_mucDigiCol" ) );
  declareObject(
      Leaf( EventModel::MC::MucMcHitCol, MucMcHitCnv::classID(), "Event", "m_mucMcHitCol" ) );
  declareObject( Leaf( EventModel::Dst::DstMucTrackCol, MucTrackCnv::classID(), "Event",
                       "m_mucTrackCol" ) );
  declareObject( Leaf( EventModel::Digi::Event, DigiCnv::classID(), "Event", "m_fromMc" ) );
  declareObject(
      Leaf( EventModel::Digi::TofDigiCol, TofDigiCnv::classID(), "Event", "m_tofDigiCol" ) );
  declareObject(
      Leaf( EventModel::MC::TofMcHitCol, TofMcHitCnv::classID(), "Event", "m_tofMcHitCol" ) );
  declareObject( Leaf( EventModel::Dst::DstTofTrackCol, TofTrackCnv::classID(), "Event",
                       "m_tofTrackCol" ) );
  // declareObject(Leaf("/Event/Digi/LumiDigiCol", LumiDigiCnv::classID(), "Event",
  // "m_lumiDigiCol"));
  declareObject( Leaf( EventModel::Digi::LumiDigiCol, LumiDigiCnv::classID(), "Event",
                       "m_lumiDigiCol" ) );
 
  declareObject( Leaf( EventModel::Trig::Event, TrigCnv::classID(), "Event", "" ) );
  declareObject(
      Leaf( EventModel::Trig::TrigData, TrigDataCnv::classID(), "Event", "m_trigData" ) );
 
  declareObject( Leaf( EventModel::Hlt::Event, HltCnv::classID(), "Event", "" ) );
  declareObject(
      Leaf( EventModel::Hlt::HltRawCol, HltRawCnv::classID(), "Event", "m_hltRawCol" ) );
  declareObject( Leaf( EventModel::Hlt::HltInf, HltInfCnv::classID(), "Event", "m_hltInf" ) );
  declareObject(
      Leaf( EventModel::Hlt::DstHltInf, DstHltInfCnv::classID(), "Event", "m_dstHltInf" ) );
 
  declareObject( Leaf( EventModel::Recon::Event, RecTrackCnv::classID(), "Event", "" ) );
 
  declareObject( Leaf( EventModel::Recon::RecMdcTrackCol, RecMdcTrackCnv::classID(), "Event",
                       "m_recMdcTrackCol" ) );
  declareObject( Leaf( EventModel::Recon::RecMdcHitCol, RecMdcHitCnv::classID(), "Event",
                       "m_recMdcHitCol" ) );
  declareObject( Leaf( EventModel::Recon::RecMdcKalTrackCol, RecMdcKalTrackCnv::classID(),
                       "Event", "m_recMdcKalTrackCol" ) );
  declareObject( Leaf( EventModel::Recon::RecMdcKalHelixSegCol,
                       RecMdcKalHelixSegCnv::classID(), "Event", "m_recMdcKalHelixSegCol" ) );
  declareObject( Leaf( EventModel::Recon::RecMdcDedxCol, RecMdcDedxCnv::classID(), "Event",
                       "m_recMdcDedxCol" ) );
  declareObject( Leaf( EventModel::Recon::RecMdcDedxHitCol, RecMdcDedxHitCnv::classID(),
                       "Event", "m_recMdcDedxHitCol" ) );
 
  declareObject( Leaf( EventModel::Recon::RecEsTimeCol, RecEvTimeCnv::classID(), "Event",
                       "m_recEvTimeCol" ) );
  declareObject( Leaf( EventModel::Recon::RecTofTrackCol, RecTofTrackCnv::classID(), "Event",
                       "m_recTofTrackCol" ) );
  declareObject( Leaf( EventModel::Recon::RecBTofCalHitCol, RecBTofCalHitCnv::classID(),
                       "Event", "m_recBTofCalHitCol" ) );
  declareObject( Leaf( EventModel::Recon::RecETofCalHitCol, RecETofCalHitCnv::classID(),
                       "Event", "m_recETofCalHitCol" ) );
  declareObject( Leaf( EventModel::Recon::RecEmcHitCol, RecEmcHitCnv::classID(), "Event",
                       "m_recEmcHitCol" ) );
  declareObject( Leaf( EventModel::Recon::RecEmcClusterCol, RecEmcClusterCnv::classID(),
                       "Event", "m_recEmcClusterCol" ) );
  declareObject( Leaf( EventModel::Recon::RecEmcShowerCol, RecEmcShowerCnv::classID(), "Event",
                       "m_recEmcShowerCol" ) );
  declareObject( Leaf( EventModel::Recon::RecMucTrackCol, RecMucTrackCnv::classID(), "Event",
                       "m_recMucTrackCol" ) );
  declareObject( Leaf( EventModel::Recon::MucRecHitCol, RecMucRecHitCnv::classID(), "Event",
                       "m_recMucHitCol" ) );
  declareObject( Leaf( EventModel::Recon::RecExtTrackCol, RecExtTrackCnv::classID(), "Event",
                       "m_recExtTrackCol" ) );
  declareObject( Leaf( EventModel::Recon::RecZddChannelCol, RecZddChannelCnv::classID(),
                       "Event", "m_recZddChannelCol" ) );
  declareObject( Leaf( EventModel::EvtRec::Event, EvtRecCnv::classID(), "Event", "" ) );
  declareObject( Leaf( EventModel::EvtRec::EvtRecEvent, EvtRecEventCnv::classID(), "Event",
                       "m_evtRecEvent" ) );
  declareObject( Leaf( EventModel::EvtRec::EvtRecTrackCol, EvtRecTrackCnv::classID(), "Event",
                       "m_evtRecTrackCol" ) );
  declareObject( Leaf( EventModel::EvtRec::EvtRecPrimaryVertex,
                       EvtRecPrimaryVertexCnv::classID(), "Event", "m_evtRecPrimaryVertex" ) );
  declareObject( Leaf( EventModel::EvtRec::EvtRecVeeVertexCol, EvtRecVeeVertexCnv::classID(),
                       "Event", "m_evtRecVeeVertexCol" ) );
  declareObject( Leaf( EventModel::EvtRec::EvtRecPi0Col, EvtRecPi0Cnv::classID(), "Event",
                       "m_evtRecPi0Col" ) );
  declareObject( Leaf( EventModel::EvtRec::EvtRecEtaToGGCol, EvtRecEtaToGGCnv::classID(),
                       "Event", "m_evtRecEtaToGGCol" ) );
  declareObject( Leaf( EventModel::EvtRec::EvtRecDTagCol, EvtRecDTagCnv::classID(), "Event",
                       "m_evtRecDTagCol" ) );
 
  return StatusCode::SUCCESS;
}
 
IConverter* RootCnvSvc::createConverter( long typ, const CLID& wanted,
                                         const ICnvFactory* fac ) {
  if ( wanted == MdcDedxCnv::classID() ) return new MdcDedxCnv( serviceLocator().get() );
  if ( wanted == DstCnv::classID() ) return new DstCnv( serviceLocator().get() );
  if ( wanted == EmcDigiCnv::classID() ) return new EmcDigiCnv( serviceLocator().get() );
  if ( wanted == EmcMcHitCnv::classID() ) return new EmcMcHitCnv( serviceLocator().get() );
  if ( wanted == EmcTrackCnv::classID() ) return new EmcTrackCnv( serviceLocator().get() );
  if ( wanted == EventCnv::classID() ) return new EventCnv( serviceLocator().get() );
  if ( wanted == EvtHeaderCnv::classID() ) return new EvtHeaderCnv( serviceLocator().get() );
  if ( wanted == EvtNavigatorCnv::classID() )
    return new EvtNavigatorCnv( serviceLocator().get() );
  if ( wanted == ExtTrackCnv::classID() ) return new ExtTrackCnv( serviceLocator().get() );
  if ( wanted == McCnv::classID() ) return new McCnv( serviceLocator().get() );
  if ( wanted == McParticleCnv::classID() ) return new McParticleCnv( serviceLocator().get() );
  if ( wanted == MdcDigiCnv::classID() ) return new MdcDigiCnv( serviceLocator().get() );
  if ( wanted == MdcKalTrackCnv::classID() )
    return new MdcKalTrackCnv( serviceLocator().get() );
  if ( wanted == MdcMcHitCnv::classID() ) return new MdcMcHitCnv( serviceLocator().get() );
  if ( wanted == MdcTrackCnv::classID() ) return new MdcTrackCnv( serviceLocator().get() );
  if ( wanted == MucDigiCnv::classID() ) return new MucDigiCnv( serviceLocator().get() );
  if ( wanted == MucMcHitCnv::classID() ) return new MucMcHitCnv( serviceLocator().get() );
  if ( wanted == MucTrackCnv::classID() ) return new MucTrackCnv( serviceLocator().get() );
  if ( wanted == DigiCnv::classID() ) return new DigiCnv( serviceLocator().get() );
  if ( wanted == TofDigiCnv::classID() ) return new TofDigiCnv( serviceLocator().get() );
  if ( wanted == TofMcHitCnv::classID() ) return new TofMcHitCnv( serviceLocator().get() );
  if ( wanted == TofTrackCnv::classID() ) return new TofTrackCnv( serviceLocator().get() );
  if ( wanted == LumiDigiCnv::classID() ) return new LumiDigiCnv( serviceLocator().get() );
  if ( wanted == TrigCnv::classID() ) return new TrigCnv( serviceLocator().get() );
  if ( wanted == TrigDataCnv::classID() ) return new TrigDataCnv( serviceLocator().get() );
  if ( wanted == HltCnv::classID() ) return new HltCnv( serviceLocator().get() );
  if ( wanted == HltRawCnv::classID() ) return new HltRawCnv( serviceLocator().get() );
  if ( wanted == HltInfCnv::classID() ) return new HltInfCnv( serviceLocator().get() );
  if ( wanted == DstHltInfCnv::classID() ) return new DstHltInfCnv( serviceLocator().get() );
  if ( wanted == RecTrackCnv::classID() ) return new RecTrackCnv( serviceLocator().get() );
  if ( wanted == RecMdcTrackCnv::classID() )
    return new RecMdcTrackCnv( serviceLocator().get() );
  if ( wanted == RecMdcHitCnv::classID() ) return new RecMdcHitCnv( serviceLocator().get() );
  if ( wanted == RecMdcKalTrackCnv::classID() )
    return new RecMdcKalTrackCnv( serviceLocator().get() );
  if ( wanted == RecMdcKalHelixSegCnv::classID() )
    return new RecMdcKalHelixSegCnv( serviceLocator().get() );
  if ( wanted == RecMdcDedxCnv::classID() ) return new RecMdcDedxCnv( serviceLocator().get() );
  if ( wanted == RecMdcDedxHitCnv::classID() )
    return new RecMdcDedxHitCnv( serviceLocator().get() );
  if ( wanted == RecEvTimeCnv::classID() ) return new RecEvTimeCnv( serviceLocator().get() );
  if ( wanted == RecTofTrackCnv::classID() )
    return new RecTofTrackCnv( serviceLocator().get() );
  if ( wanted == RecBTofCalHitCnv::classID() )
    return new RecBTofCalHitCnv( serviceLocator().get() );
  if ( wanted == RecETofCalHitCnv::classID() )
    return new RecETofCalHitCnv( serviceLocator().get() );
  if ( wanted == RecEmcHitCnv::classID() ) return new RecEmcHitCnv( serviceLocator().get() );
  if ( wanted == RecEmcClusterCnv::classID() )
    return new RecEmcClusterCnv( serviceLocator().get() );
  if ( wanted == RecEmcShowerCnv::classID() )
    return new RecEmcShowerCnv( serviceLocator().get() );
  if ( wanted == RecMucTrackCnv::classID() )
    return new RecMucTrackCnv( serviceLocator().get() );
  if ( wanted == RecMucRecHitCnv::classID() )
    return new RecMucRecHitCnv( serviceLocator().get() );
  if ( wanted == RecExtTrackCnv::classID() )
    return new RecExtTrackCnv( serviceLocator().get() );
  if ( wanted == RecZddChannelCnv::classID() )
    return new RecZddChannelCnv( serviceLocator().get() );
  if ( wanted == EvtRecCnv::classID() ) return new EvtRecCnv( serviceLocator().get() );
  if ( wanted == EvtRecEventCnv::classID() )
    return new EvtRecEventCnv( serviceLocator().get() );
  if ( wanted == EvtRecTrackCnv::classID() )
    return new EvtRecTrackCnv( serviceLocator().get() );
  if ( wanted == EvtRecPrimaryVertexCnv::classID() )
    return new EvtRecPrimaryVertexCnv( serviceLocator().get() );
  if ( wanted == EvtRecVeeVertexCnv::classID() )
    return new EvtRecVeeVertexCnv( serviceLocator().get() );
  if ( wanted == EvtRecPi0Cnv::classID() ) return new EvtRecPi0Cnv( serviceLocator().get() );
  if ( wanted == EvtRecEtaToGGCnv::classID() )
    return new EvtRecEtaToGGCnv( serviceLocator().get() );
  if ( wanted == EvtRecDTagCnv::classID() ) return new EvtRecDTagCnv( serviceLocator().get() );
 
  return ConversionSvc::createConverter( typ, wanted, fac );
}