bak_RootCnvSvc-04-01-14/src/EvtRec/EvtRecTrackCnv.cxx

Go to the documentation of this file.

#include <algorithm>
#include "GaudiKernel/MsgStream.h"
 
#include "EventModel/EventModel.h"
#include "EvtRecEvent/EvtRecObject.h"
#include "EvtRecEvent/EvtRecTrack.h"
 
#include "RootEventData/TEvtRecObject.h"
#include "RootEventData/TEvtRecTrack.h"
 
#include "RootCnvSvc/RootAddress.h"
#include "RootCnvSvc/EvtRec/EvtRecCnv.h"
#include "RootCnvSvc/EvtRec/EvtRecTrackCnv.h"
 
EvtRecTrackCnv::EvtRecTrackCnv(ISvcLocator* svc)
   : RootEventBaseCnv(classID(), svc)
{
   m_rootBranchname = "m_evtRecTrackCol";
   m_adresses.push_back(&m_evtRecTrackCol);
   m_evtRecTrackCol = 0;
}
 
StatusCode EvtRecTrackCnv::TObjectToDataObject(DataObject*& refpObject) {
  // creation of TDS object from root object
  MsgStream log(msgSvc(), "EvtRecTrackCnv");
  log << MSG::DEBUG << "EvtRecTrackCnv::TObjectToDataObject" << endreq;
 
  // create the TDS location for the EvtRecTrack Collection
  EvtRecTrackCol* evtRecTrackCol = new EvtRecTrackCol;
  refpObject = evtRecTrackCol;
 
  if ( ! m_evtRecTrackCol ) return StatusCode::SUCCESS;
 
  IDataProviderSvc* dataSvc = 0;
  StatusCode sc = serviceLocator()->getService("EventDataSvc",
    IDataProviderSvc::interfaceID(), (IInterface*&)dataSvc);
  if ( sc.isFailure() ) {
     log << MSG::FATAL << "Could not get EventDataSvc in EvtRecTrackCnv" << endreq;
     return sc;
  }
 
  /*SmartDataPtr<RecMdcTrackCol> mdcTrackCol(dataSvc, EventModel::Recon::RecMdcTrackCol);
  if ( ! mdcTrackCol ) {
     log << MSG::INFO << "Could not find RecMdcTrackCol" << endreq;
  }
 
  SmartDataPtr<RecMdcKalTrackCol> mdcKalTrackCol(dataSvc, EventModel::Recon::RecMdcKalTrackCol);
  if ( ! mdcKalTrackCol ) {
     log << MSG::INFO << "Could not find RecMdcKalTrackCol" << endreq;
  }
 
  SmartDataPtr<RecMdcDedxCol> mdcDedxCol(dataSvc, EventModel::Recon::RecMdcDedxCol);
  if ( ! mdcDedxCol ) {
     log << MSG::INFO << "Could not find RecMdcDedxCol" << endreq;
  }
 
  SmartDataPtr<RecExtTrackCol> extTrackCol(dataSvc, EventModel::Recon::RecExtTrackCol);
  if ( ! extTrackCol ) {
     log << MSG::INFO << "Could not find RecExtTrackCol" << endreq;
  }
 
  SmartDataPtr<RecTofTrackCol> tofTrackCol(dataSvc, EventModel::Recon::RecTofTrackCol);
  if ( ! tofTrackCol ) {
     log << MSG::INFO << "Could not find RecTofTrackCol" << endreq;
  }
 
  SmartDataPtr<RecEmcShowerCol> emcShowerCol(dataSvc, EventModel::Recon::RecEmcShowerCol);
  if ( ! emcShowerCol ) {
     log << MSG::INFO << "Could not find RecEmcShowerCol" << endreq;
  }
 
  SmartDataPtr<RecMucTrackCol> mucTrackCol(dataSvc, EventModel::Recon::RecMucTrackCol);
  if ( ! mucTrackCol ) {
     log << MSG::INFO << "Could not find RecMucTrackCol" << endreq;
  }*/
 
  //-----------------Dst to Rec convert in case of no Rec data in TDS
  int trackID;
 
  // Retrieve Mdc Track 
  SmartDataPtr<RecMdcTrackCol> mdcTrackCol(dataSvc, EventModel::Recon::RecMdcTrackCol);
  if(!mdcTrackCol)
  {
    log << MSG::INFO << "Could not find RecMdcTrackCol" << endreq;
    SmartDataPtr<DstMdcTrackCol> dstMdcTrackCol(dataSvc,"/Event/Dst/DstMdcTrackCol");
    if (!dstMdcTrackCol) {
      log << MSG::INFO << "Could not find DstMdcTrackCol" << endreq;
    } 
    else {
      RecMdcTrackCol* mdcTrackCol = new RecMdcTrackCol();
      DstMdcTrackCol::iterator iter_mdc = dstMdcTrackCol->begin();
      trackID = 0;
      for (;iter_mdc != dstMdcTrackCol->end(); iter_mdc++, trackID++) {
        RecMdcTrack* recMdcTrack = new RecMdcTrack(); 
        *recMdcTrack = **iter_mdc;
        (*mdcTrackCol).push_back(recMdcTrack);
        log << MSG::INFO 
            << " Mdc Track ID = " << trackID
              << " Mdc Track Nster = " << (*iter_mdc)->nster()
              << endreq; 
      } 
      sc = dataSvc->registerObject(EventModel::Recon::RecMdcTrackCol,mdcTrackCol);
    }
  }
 
  // Retrieve MdcKal track 
  SmartDataPtr<RecMdcKalTrackCol> mdcKalTrackCol(dataSvc, EventModel::Recon::RecMdcKalTrackCol);
  if (!mdcKalTrackCol) {
    log << MSG::INFO << "Could not find RecMdcKalTrackCol" << endreq;
    SmartDataPtr<DstMdcKalTrackCol> dstMdcKalTrackCol(dataSvc,"/Event/Dst/DstMdcKalTrackCol");
    if(!dstMdcKalTrackCol) {
      log << MSG::INFO << "Could not find DstMdcKalTrackCol" << endreq;
    }
    else {
      RecMdcKalTrackCol* mdcKalTrackCol = new RecMdcKalTrackCol();
      DstMdcKalTrackCol::iterator iter_mdc = dstMdcKalTrackCol->begin();
      trackID = 0;
      for (;iter_mdc != dstMdcKalTrackCol->end(); iter_mdc++, trackID++) {
        RecMdcKalTrack* recMdcKalTrack = new RecMdcKalTrack();
        *recMdcKalTrack = **iter_mdc;
        (*mdcKalTrackCol).push_back(recMdcKalTrack);
        log << MSG::INFO
            << " MdcKalTrack ID = " << trackID
            << " MdcKalTrack Nster = " << (*iter_mdc)->nster()
            << " MdcKalTrack poca = " << (*iter_mdc)->poca()
            << endreq;
      }
      sc = dataSvc->registerObject(EventModel::Recon::RecMdcKalTrackCol, mdcKalTrackCol);   
    }
  }
 
  // Retrieve MdcDedx 
  SmartDataPtr<RecMdcDedxCol> mdcDedxCol(dataSvc, EventModel::Recon::RecMdcDedxCol);
  if (!mdcDedxCol) {
    log <<MSG::INFO << "Could not find RecMdcDedxCol" << endreq;
    SmartDataPtr<DstMdcDedxCol> dstMdcDedxCol(dataSvc,"/Event/Dst/DstMdcDedxCol");
    if(!dstMdcDedxCol) {
      log <<MSG::INFO << "Could not find DstMdcDedxCol" << endreq;
    }
    else {
      RecMdcDedxCol* mdcDedxCol = new RecMdcDedxCol();
      DstMdcDedxCol::iterator iter_mdc = dstMdcDedxCol->begin();
      trackID=0;
      for (;iter_mdc != dstMdcDedxCol->end(); iter_mdc++, trackID++) {
        RecMdcDedx* recMdcDedx = new RecMdcDedx();
        *recMdcDedx= **iter_mdc;
        (*mdcDedxCol).push_back(recMdcDedx);
        log << MSG::INFO
            << " MdcDedx ID = " << trackID
            << " MdcDedx " 
            << endreq;
      }
      sc = dataSvc->registerObject(EventModel::Recon::RecMdcDedxCol, mdcDedxCol);
    }
  } 
  // Retrieve Cgem Track 
  SmartDataPtr<RecCgemTrackCol> cgemTrackCol(dataSvc, EventModel::Recon::RecCgemTrackCol);
  if(!cgemTrackCol)
  {
    log << MSG::INFO << "Could not find RecCgemTrackCol" << endreq;
    SmartDataPtr<DstCgemTrackCol> dstCgemTrackCol(dataSvc,"/Event/Dst/DstCgemTrackCol");
    if (!dstCgemTrackCol) {
      log << MSG::INFO << "Could not find DstCgemTrackCol" << endreq;
    } 
    else {
      RecCgemTrackCol* cgemTrackCol = new RecCgemTrackCol();
      DstCgemTrackCol::iterator iter_cgem = dstCgemTrackCol->begin();
      trackID = 0;
      for (;iter_cgem != dstCgemTrackCol->end(); iter_cgem++, trackID++) {
        RecCgemTrack* recCgemTrack = new RecCgemTrack(); 
        *recCgemTrack = **iter_cgem;
        (*cgemTrackCol).push_back(recCgemTrack);
        log << MSG::INFO 
            << " Cgem Track ID = " << trackID
              << endreq; 
      } 
      sc = dataSvc->registerObject(EventModel::Recon::RecCgemTrackCol,cgemTrackCol);
    }
  }
  
  // Retrieve Cgem segment ; add by sunxh
  SmartDataPtr<RecCgemSegmentCol> cgemSegmentCol(dataSvc, EventModel::Recon::RecCgemSegmentCol);
  if(!cgemSegmentCol)
  {
    log << MSG::INFO << "Could not find RecCgemSegmentCol" << endreq;
    SmartDataPtr<DstCgemSegmentCol> dstCgemSegmentCol(dataSvc,"/Event/Dst/DstCgemSegmentCol");
    if (!dstCgemSegmentCol) {
      log << MSG::INFO << "Could not find DstCgemSegmentCol" << endreq;
    } 
    else {
      RecCgemSegmentCol* cgemSegmentCol = new RecCgemSegmentCol();
      DstCgemSegmentCol::iterator iter_cgem = dstCgemSegmentCol->begin();
      trackID = 0;
      for (;iter_cgem != dstCgemSegmentCol->end(); iter_cgem++, trackID++) {
        RecCgemSegment* recCgemSegment = new RecCgemSegment(); 
        *recCgemSegment = **iter_cgem;
        (*cgemSegmentCol).push_back(recCgemSegment);
        log << MSG::INFO 
            << " Cgem Track ID = " << trackID
              << endreq; 
      } 
      sc = dataSvc->registerObject(EventModel::Recon::RecCgemSegmentCol,cgemSegmentCol);
    }
  }
 
  // Retrieve CgemKal track 
  SmartDataPtr<RecCgemKalTrackCol> cgemKalTrackCol(dataSvc, EventModel::Recon::RecCgemKalTrackCol);
  if (!cgemKalTrackCol) {
    log << MSG::INFO << "Could not find RecCgemKalTrackCol" << endreq;
    SmartDataPtr<DstCgemKalTrackCol> dstCgemKalTrackCol(dataSvc,"/Event/Dst/DstCgemKalTrackCol");
    if(!dstCgemKalTrackCol) {
      log << MSG::INFO << "Could not find DstCgemKalTrackCol" << endreq;
    }
    else {
      RecCgemKalTrackCol* cgemKalTrackCol = new RecCgemKalTrackCol();
      DstCgemKalTrackCol::iterator iter_cgem = dstCgemKalTrackCol->begin();
      trackID = 0;
      for (;iter_cgem != dstCgemKalTrackCol->end(); iter_cgem++, trackID++) {
        RecCgemKalTrack* recCgemKalTrack = new RecCgemKalTrack();
        *recCgemKalTrack = **iter_cgem;
        (*cgemKalTrackCol).push_back(recCgemKalTrack);
        log << MSG::INFO
            << " CgemKalTrack ID = " << trackID
            << " CgemKalTrack poca = " << (*iter_cgem)->poca()
            << endreq;
      }
      sc = dataSvc->registerObject(EventModel::Recon::RecCgemKalTrackCol, cgemKalTrackCol); 
    }
  }
 
  // Retrieve CgemDedx 
  SmartDataPtr<RecCgemDedxCol> cgemDedxCol(dataSvc, EventModel::Recon::RecCgemDedxCol);
  if (!cgemDedxCol) {
    log <<MSG::INFO << "Could not find RecCgemDedxCol" << endreq;
    SmartDataPtr<DstCgemDedxCol> dstCgemDedxCol(dataSvc,"/Event/Dst/DstCgemDedxCol");
    if(!dstCgemDedxCol) {
      log <<MSG::INFO << "Could not find DstCgemDedxCol" << endreq;
    }
    else {
      RecCgemDedxCol* cgemDedxCol = new RecCgemDedxCol();
      DstCgemDedxCol::iterator iter_cgem = dstCgemDedxCol->begin();
      trackID=0;
      for (;iter_cgem != dstCgemDedxCol->end(); iter_cgem++, trackID++) {
        RecCgemDedx* recCgemDedx = new RecCgemDedx();
        *recCgemDedx= **iter_cgem;
        (*cgemDedxCol).push_back(recCgemDedx);
        log << MSG::INFO
            << " CgemDedx ID = " << trackID
            << " CgemDedx " 
            << endreq;
      }
      sc = dataSvc->registerObject(EventModel::Recon::RecCgemDedxCol, cgemDedxCol);
    }
  } 
  
  // Retrieve Ext track 
  SmartDataPtr<RecExtTrackCol> extTrackCol(dataSvc, EventModel::Recon::RecExtTrackCol);
  if (!extTrackCol) {
    log <<MSG::INFO << "Could not find RecExtTrackCol" << endreq;
    SmartDataPtr<DstExtTrackCol> dstExtTrackCol(dataSvc,"/Event/Dst/DstExtTrackCol");
    if(!dstExtTrackCol) {
      log <<MSG::INFO << "Could not find DstExtTrackCol" << endreq;
    }
    else {
      RecExtTrackCol* extTrackCol = new RecExtTrackCol();
      DstExtTrackCol::iterator iter_ext = dstExtTrackCol->begin();
      trackID=0;
      for (;iter_ext != dstExtTrackCol->end(); iter_ext++, trackID++) {
        RecExtTrack* recExtTrack = new RecExtTrack();
        *recExtTrack = **iter_ext;
        (*extTrackCol).push_back(recExtTrack);
        log << MSG::INFO
            << " ExtTrack ID = " << trackID
            << endreq;
      }
      sc = dataSvc->registerObject(EventModel::Recon::RecExtTrackCol, extTrackCol);
    }
  }
      
  // Retrieve Tof Track 
  SmartDataPtr<RecTofTrackCol> tofTrackCol(dataSvc, EventModel::Recon::RecTofTrackCol);
  if ( !tofTrackCol ) {
    log << MSG::INFO << "Could not find TofTrackCol" << endreq;
    SmartDataPtr<DstTofTrackCol> dstTofTrackCol(dataSvc,"/Event/Dst/DstTofTrackCol");
    if(!dstTofTrackCol) {
      log << MSG::INFO << "Could not find DstTofTrackCol" << endreq;
    }
    else {
      RecTofTrackCol* tofTrackCol = new RecTofTrackCol();
      DstTofTrackCol::iterator iter_tof = dstTofTrackCol->begin();
      for (;iter_tof != dstTofTrackCol->end(); iter_tof++) {
        RecTofTrack* recTofTrack = new RecTofTrack();
        *recTofTrack = **iter_tof;
        (*tofTrackCol).push_back(recTofTrack);
        log << MSG::INFO
        << "Tof Track ID = " << (*iter_tof)->tofTrackID()
        << " Track ID = " << (*iter_tof)->trackID()
        << " Tof Counter ID = "<<(*iter_tof)->tofID()
        << " Quality = "<< (*iter_tof)->quality()
            << endreq;
      }
      sc = dataSvc->registerObject(EventModel::Recon::RecTofTrackCol, tofTrackCol);
    }
  }
 
 
  // Retrieve Emc shower 
  SmartDataPtr<RecEmcShowerCol> emcShowerCol(dataSvc, EventModel::Recon::RecEmcShowerCol);
  if (!emcShowerCol) {
    log << MSG::INFO << "Could not find RecEmcShowerCol" << endreq;
    SmartDataPtr<DstEmcShowerCol> dstEmcShowerCol(dataSvc,"/Event/Dst/DstEmcShowerCol");
    if(!dstEmcShowerCol) {
      log << MSG::INFO << "Could not find DstEmcShowerCol" << endreq;
    }
    else {
      RecEmcShowerCol* emcShowerCol = new RecEmcShowerCol();
      DstEmcShowerCol::iterator iter_emc = dstEmcShowerCol->begin();
      trackID=0;
      for (;iter_emc != dstEmcShowerCol->end(); iter_emc++, trackID++) {
        RecEmcShower* recEmcShower = new RecEmcShower();
        *recEmcShower = **iter_emc;
        (*emcShowerCol).push_back(recEmcShower);
        log << MSG::INFO
            << " EmcShower ID = " << trackID
            << " EmcShower energy = " << (*iter_emc)->energy()
            << endreq;
      }
      sc = dataSvc->registerObject(EventModel::Recon::RecEmcShowerCol, emcShowerCol);
    }
  }
 
  // Retrieve Muc Track 
  SmartDataPtr<RecMucTrackCol> mucTrackCol(dataSvc, EventModel::Recon::RecMucTrackCol);
  if (!mucTrackCol) {
    log <<MSG::INFO << "Could not find RecMucTrackCol" << endreq;
    SmartDataPtr<DstMucTrackCol> dstMucTrackCol(dataSvc,"/Event/Dst/DstMucTrackCol");
    if(!dstMucTrackCol) {
      log <<MSG::INFO << "Could not find DstMucTrackCol" << endreq;
    }
    else {
      RecMucTrackCol* mucTrackCol = new RecMucTrackCol();
      DstMucTrackCol::iterator iter_muc = dstMucTrackCol->begin();
      trackID=0;
      for (;iter_muc != dstMucTrackCol->end(); iter_muc++, trackID++) {
        RecMucTrack* recMucTrack = new RecMucTrack();
        *recMucTrack = **iter_muc;
        (*mucTrackCol).push_back(recMucTrack);
        log << MSG::INFO
            << " MucTrack ID = "<< trackID
            <<endreq;
      }
      sc = dataSvc->registerObject(EventModel::Recon::RecMucTrackCol, mucTrackCol);
    }
  }
 
  // convert
  TIter evtRecTrackIter(m_evtRecTrackCol);
  TEvtRecTrack* evtRecTrackRoot = 0;
  while ( (evtRecTrackRoot = (TEvtRecTrack*)evtRecTrackIter.Next() ) ) {
     EvtRecTrack* evtRecTrack = new EvtRecTrack();
     m_common.m_rootEvtRecTrackMap[evtRecTrackRoot] = evtRecTrack;
     // set ....
     evtRecTrack->setTrackId( evtRecTrackRoot->trackId() );
     evtRecTrack->setPartId( evtRecTrackRoot->partId() );
     evtRecTrack->setQuality( evtRecTrackRoot->quality() );
 
     int mdcTrackId = evtRecTrackRoot->mdcTrackId();
     if ( mdcTrackId >= 0 ) {
    evtRecTrack->setMdcTrack(
          dynamic_cast<RecMdcTrack*>(mdcTrackCol->containedObject(mdcTrackId))
          );
     }
 
     int mdcKalTrackId = evtRecTrackRoot->mdcKalTrackId();
     if ( mdcKalTrackId >= 0 ) {
    evtRecTrack->setMdcKalTrack(
          dynamic_cast<RecMdcKalTrack*>(mdcKalTrackCol->containedObject(mdcKalTrackId))
          );
     }
 
     int mdcDedxId = evtRecTrackRoot->mdcDedxId();
     if ( mdcDedxId >= 0 ) {
    evtRecTrack->setMdcDedx(
          dynamic_cast<RecMdcDedx*>(mdcDedxCol->containedObject(mdcDedxId))
          );
     }
 
     int cgemSegmentId = evtRecTrackRoot->cgemSegmentId();
     if ( cgemSegmentId >= 0 ) {
    evtRecTrack->setCgemSegment(
          dynamic_cast<RecCgemSegment*>(cgemSegmentCol->containedObject(cgemSegmentId))
          );
     }
 
     int cgemTrackId = evtRecTrackRoot->cgemTrackId();
     if ( cgemTrackId >= 0 ) {
    evtRecTrack->setCgemTrack(
          dynamic_cast<RecCgemTrack*>(cgemTrackCol->containedObject(cgemTrackId))
          );
     }
 
     int cgemKalTrackId = evtRecTrackRoot->cgemKalTrackId();
     if ( cgemKalTrackId >= 0 ) {
    evtRecTrack->setCgemKalTrack(
          dynamic_cast<RecCgemKalTrack*>(cgemKalTrackCol->containedObject(cgemKalTrackId))
          );
     }
 
     int cgemDedxId = evtRecTrackRoot->cgemDedxId();
     if ( cgemDedxId >= 0 ) {
    evtRecTrack->setCgemDedx(
          dynamic_cast<RecCgemDedx*>(cgemDedxCol->containedObject(cgemDedxId))
          );
     }
 
     int extTrackId = evtRecTrackRoot->extTrackId();
     if ( extTrackId >= 0 ) {
    evtRecTrack->setExtTrack(
          dynamic_cast<RecExtTrack*>(extTrackCol->containedObject(extTrackId))
          );
     }
 
     const std::vector<int>& tofTrackIds = evtRecTrackRoot->tofTrackIds();
     for ( unsigned int i = 0; i < tofTrackIds.size(); i++) {
    RecTofTrack* tofTrack = dynamic_cast<RecTofTrack*>(tofTrackCol->containedObject(tofTrackIds[i]));
    evtRecTrack->addTofTrack(tofTrack);
     }
 
     int emcShowerId = evtRecTrackRoot->emcShowerId();
     if ( emcShowerId >= 0 ) {
    evtRecTrack->setEmcShower(
          dynamic_cast<RecEmcShower*>(emcShowerCol->containedObject(emcShowerId))
          );
     }
 
     int mucTrackId = evtRecTrackRoot->mucTrackId();
     if ( mucTrackId >= 0 ) {
    evtRecTrack->setMucTrack(
          dynamic_cast<RecMucTrack*>(mucTrackCol->containedObject(mucTrackId))
          );
     }
 
     evtRecTrackCol->push_back(evtRecTrack);
  }
 
  delete m_evtRecTrackCol;
  m_evtRecTrackCol = 0;
  return StatusCode::SUCCESS;
}
 
StatusCode EvtRecTrackCnv::DataObjectToTObject(DataObject* obj, RootAddress* rootaddr) {
  MsgStream log(msgSvc(), "EvtRecTrackCnv");
  log << MSG::DEBUG << "EvtRecTrackCnv::DataObjectToTObject" << endreq;
 
  EvtRecTrackCol* evtRecTrackCol = dynamic_cast<EvtRecTrackCol*> (obj);
  if ( ! evtRecTrackCol ) {
    log << MSG::ERROR << "Could not downcast to EvtRecTrackCol" << endreq;
    return StatusCode::FAILURE;
  }
 
  DataObject* evt = NULL;
  StatusCode sc = m_eds->findObject(EventModel::EvtRec::Event, evt);
  if ( sc.isFailure() ) {
     log << MSG::ERROR << "Could not get EvtRecObject in TDS" << endreq;
     return StatusCode::FAILURE;
  }
  EvtRecObject* devtTds = dynamic_cast<EvtRecObject*> (evt);
  if ( ! devtTds ) {
    log << MSG::ERROR << "EvtRecTrackCnv: Could not downcast to TDS EvtRecObject" << endreq;
  }
 
  IOpaqueAddress *addr;
  m_cnvSvc->getEvtRecCnv()->createRep(evt, addr);
  TEvtRecObject* recEvt = m_cnvSvc->getEvtRecCnv()->getWriteObject();
 
  const TObjArray* m_evtRecTrackCol = recEvt->getEvtRecTrackCol();
  if ( ! m_evtRecTrackCol ) return StatusCode::SUCCESS;
 
  IDataProviderSvc* dataSvc = 0;
  sc = serviceLocator()->getService("EventDataSvc",
    IDataProviderSvc::interfaceID(), (IInterface*&)dataSvc);
  if ( sc.isFailure() ) {
     log << MSG::FATAL << "Could not get EventDataSvc in EvtRecTrackCnv" << endreq;
     return sc;
  }
 
  RecMdcTrackCol::iterator    mdcTrackColbegin,    mdcTrackColend;
  RecMdcKalTrackCol::iterator mdcKalTrackColbegin, mdcKalTrackColend;
  RecMdcDedxCol::iterator     mdcDedxColbegin,     mdcDedxColend;
  RecCgemSegmentCol::iterator    cgemSegmentColbegin,    cgemSegmentColend;
  RecCgemTrackCol::iterator    cgemTrackColbegin,    cgemTrackColend;
  RecCgemKalTrackCol::iterator cgemKalTrackColbegin, cgemKalTrackColend;
  RecCgemDedxCol::iterator     cgemDedxColbegin,     cgemDedxColend;
  RecExtTrackCol::iterator    extTrackColbegin,    extTrackColend;
  RecTofTrackCol::iterator    tofTrackColbegin,    tofTrackColend;
  RecEmcShowerCol::iterator   emcShowerColbegin,   emcShowerColend;
  RecMucTrackCol::iterator    mucTrackColbegin,    mucTrackColend;
 
  SmartDataPtr<RecMdcTrackCol> mdcTrackCol(dataSvc, EventModel::Recon::RecMdcTrackCol);
  if ( ! mdcTrackCol ) {
     log << MSG::INFO << "Could not find RecMdcTrackCol" << endreq;
  }
  else {
     mdcTrackColbegin = mdcTrackCol->begin();
     mdcTrackColend   = mdcTrackCol->end();
  }
 
  SmartDataPtr<RecMdcKalTrackCol> mdcKalTrackCol(dataSvc, EventModel::Recon::RecMdcKalTrackCol);
  if ( ! mdcKalTrackCol ) {
     log << MSG::INFO << "Could not find RecMdcKalTrackCol" << endreq;
  }
  else {
     mdcKalTrackColbegin = mdcKalTrackCol->begin();
     mdcKalTrackColend   = mdcKalTrackCol->end();
  }
 
  SmartDataPtr<RecMdcDedxCol> mdcDedxCol(dataSvc, EventModel::Recon::RecMdcDedxCol);
  if ( ! mdcDedxCol ) {
     log << MSG::INFO << "Could not find RecMdcDedxCol" << endreq;
  }
  else {
     mdcDedxColbegin = mdcDedxCol->begin();
     mdcDedxColend   = mdcDedxCol->end();
  }
 
  SmartDataPtr<RecCgemSegmentCol> cgemSegmentCol(dataSvc, EventModel::Recon::RecCgemSegmentCol);
  if ( ! cgemSegmentCol ) {
     log << MSG::INFO << "Could not find RecCgemSegmentCol" << endreq;
  }
  else {
     cgemSegmentColbegin = cgemSegmentCol->begin();
     cgemSegmentColend   = cgemSegmentCol->end();
  }
 
  SmartDataPtr<RecCgemTrackCol> cgemTrackCol(dataSvc, EventModel::Recon::RecCgemTrackCol);
  if ( ! cgemTrackCol ) {
     log << MSG::INFO << "Could not find RecCgemTrackCol" << endreq;
  }
  else {
     cgemTrackColbegin = cgemTrackCol->begin();
     cgemTrackColend   = cgemTrackCol->end();
  }
 
  SmartDataPtr<RecCgemKalTrackCol> cgemKalTrackCol(dataSvc, EventModel::Recon::RecCgemKalTrackCol);
  if ( ! cgemKalTrackCol ) {
     log << MSG::INFO << "Could not find RecCgemKalTrackCol" << endreq;
  }
  else {
     cgemKalTrackColbegin = cgemKalTrackCol->begin();
     cgemKalTrackColend   = cgemKalTrackCol->end();
  }
 
  SmartDataPtr<RecCgemDedxCol> cgemDedxCol(dataSvc, EventModel::Recon::RecCgemDedxCol);
  if ( ! cgemDedxCol ) {
     log << MSG::INFO << "Could not find RecCgemDedxCol" << endreq;
  }
  else {
     cgemDedxColbegin = cgemDedxCol->begin();
     cgemDedxColend   = cgemDedxCol->end();
  }
 
  SmartDataPtr<RecExtTrackCol> extTrackCol(dataSvc, EventModel::Recon::RecExtTrackCol);
  if ( ! extTrackCol ) {
     log << MSG::INFO << "Could not find RecExtTrackCol" << endreq;
  }
  else {
     extTrackColbegin = extTrackCol->begin();
     extTrackColend   = extTrackCol->end();
  }
 
  SmartDataPtr<RecTofTrackCol> tofTrackCol(dataSvc, EventModel::Recon::RecTofTrackCol);
  if ( ! tofTrackCol ) {
     log << MSG::INFO << "Could not find RecTofTrackCol" << endreq;
  }
  else {
     tofTrackColbegin = tofTrackCol->begin();
     tofTrackColend   = tofTrackCol->end();
  }
 
  SmartDataPtr<RecEmcShowerCol> emcShowerCol(dataSvc, EventModel::Recon::RecEmcShowerCol);
  if ( ! emcShowerCol ) {
     log << MSG::INFO << "Could not find RecEmcShowerCol" << endreq;
  }
  else {
     emcShowerColbegin = emcShowerCol->begin();
     emcShowerColend   = emcShowerCol->end();
  }
 
  SmartDataPtr<RecMucTrackCol> mucTrackCol(dataSvc, EventModel::Recon::RecMucTrackCol);
  if ( ! mucTrackCol ) {
     log << MSG::INFO << "Could not find RecMucTrackCol" << endreq;
  }
  else {
     mucTrackColbegin = mucTrackCol->begin();
     mucTrackColend   = mucTrackCol->end();
  }
 
  // convert
  recEvt->clearEvtRecTrackCol();
  EvtRecTrackCol::const_iterator evtRecTrack = evtRecTrackCol->begin();
 
  for ( ; evtRecTrack != evtRecTrackCol->end(); evtRecTrack++) {
     EvtRecTrack* ptr = *evtRecTrack;
     TEvtRecTrack* evtRecTrackRoot = new TEvtRecTrack();
     // set ...
     evtRecTrackRoot->setTrackId( ptr->trackId() );
     evtRecTrackRoot->setPartId( ptr->partId() );
     evtRecTrackRoot->setQuality( ptr->quality() );
 
     if ( ptr->isMdcTrackValid() ) {
    RecMdcTrackCol::iterator it = find(mdcTrackColbegin, mdcTrackColend, ptr->mdcTrack());
    evtRecTrackRoot->setMdcTrackId( it - mdcTrackColbegin );
     }
     if ( ptr->isMdcKalTrackValid() ) {
    RecMdcKalTrackCol::iterator it = find(mdcKalTrackColbegin, mdcKalTrackColend, ptr->mdcKalTrack());
    evtRecTrackRoot->setMdcKalTrackId( it - mdcKalTrackColbegin );
     }
     if ( ptr->isMdcDedxValid() ) {
    RecMdcDedxCol::iterator it = find(mdcDedxColbegin, mdcDedxColend, ptr->mdcDedx());
    evtRecTrackRoot->setMdcDedxId( it - mdcDedxColbegin );
     }
     if ( ptr->isCgemTrackValid() ) {
    RecCgemTrackCol::iterator it = find(cgemTrackColbegin, cgemTrackColend, ptr->cgemTrack());
    evtRecTrackRoot->setCgemTrackId( it - cgemTrackColbegin );
     }
     if ( ptr->isCgemSegmentValid() ) {
    RecCgemSegmentCol::iterator it = find(cgemSegmentColbegin, cgemSegmentColend, ptr->cgemSegment());
    evtRecTrackRoot->setCgemSegmentId( it - cgemSegmentColbegin );
     }
     if ( ptr->isCgemKalTrackValid() ) {
    RecCgemKalTrackCol::iterator it = find(cgemKalTrackColbegin, cgemKalTrackColend, ptr->cgemKalTrack());
    evtRecTrackRoot->setCgemKalTrackId( it - cgemKalTrackColbegin );
     }
     if ( ptr->isCgemDedxValid() ) {
    RecCgemDedxCol::iterator it = find(cgemDedxColbegin, cgemDedxColend, ptr->cgemDedx());
    evtRecTrackRoot->setCgemDedxId( it - cgemDedxColbegin );
     }
     if ( ptr->isExtTrackValid() ) {
    RecExtTrackCol::iterator it = find(extTrackColbegin, extTrackColend, ptr->extTrack());
    evtRecTrackRoot->setExtTrackId( it - extTrackColbegin );
     }
     if ( ptr->isTofTrackValid() ) {
    SmartRefVector<RecTofTrack> tofTrackVec = ptr->tofTrack();
    for ( unsigned int i = 0; i < tofTrackVec.size(); i++ ) {
       RecTofTrackCol::iterator it = find(tofTrackColbegin, tofTrackColend, tofTrackVec[i]);
       evtRecTrackRoot->addTofTrackId( it - tofTrackColbegin );
    }
     }
     if ( ptr->isEmcShowerValid() ) {
    RecEmcShowerCol::iterator it = find(emcShowerColbegin, emcShowerColend, ptr->emcShower());
    evtRecTrackRoot->setEmcShowerId( it - emcShowerColbegin );
     }
     if ( ptr->isMucTrackValid() ) {
    RecMucTrackCol::iterator it = find(mucTrackColbegin, mucTrackColend, ptr->mucTrack());
    evtRecTrackRoot->setMucTrackId( it - mucTrackColbegin );
     }
 
     recEvt->addEvtRecTrack(evtRecTrackRoot);
  }
 
  return StatusCode::SUCCESS;
}