TRecTrackEvent.cxx

Go to the documentation of this file.

#include "RootEventData/TRecTrackEvent.h"
#include "TCollection.h"  // Declares TIter
 
ClassImp(TRecTrackEvent)
 
// Allocate the TObjArray just once
 
TObjArray *TRecTrackEvent::s_staticRecMdcTrackCol = 0;
TObjArray *TRecTrackEvent::s_staticRecMdcHitCol = 0;
TObjArray *TRecTrackEvent::s_staticRecCgemTrackCol = 0;
TObjArray *TRecTrackEvent::s_staticRecCgemSegmentCol = 0;
TObjArray *TRecTrackEvent::s_staticRecCgemHitCol = 0;
TObjArray *TRecTrackEvent::s_staticRecCgemClusterCol = 0;
TObjArray *TRecTrackEvent::s_staticTofTrackCol = 0;
TObjArray *TRecTrackEvent::s_staticEmcHitCol = 0;
TObjArray *TRecTrackEvent::s_staticEmcClusterCol = 0;
TObjArray *TRecTrackEvent::s_staticEmcShowerCol = 0;
TObjArray *TRecTrackEvent::s_staticMucTrackCol = 0;
TObjArray *TRecTrackEvent::s_staticRecMdcDedxCol = 0;
TObjArray *TRecTrackEvent::s_staticRecMdcDedxHitCol = 0;
TObjArray *TRecTrackEvent::s_staticRecCgemDedxCol = 0;
TObjArray *TRecTrackEvent::s_staticRecCgemDedxHitCol = 0;
TObjArray *TRecTrackEvent::s_staticExtTrackCol = 0;
TObjArray *TRecTrackEvent::s_staticRecMdcKalTrackCol = 0;
TObjArray *TRecTrackEvent::s_staticRecMdcKalHelixSegCol = 0;
TObjArray *TRecTrackEvent::s_staticRecCgemKalTrackCol = 0;
TObjArray *TRecTrackEvent::s_staticRecCgemKalHelixSegCol = 0;
TObjArray *TRecTrackEvent::s_staticEvTimeCol = 0;
TObjArray *TRecTrackEvent::s_staticRecZddChannelCol = 0;
 
//***************************************************************
TRecTrackEvent::TRecTrackEvent() 
{
   //Dst Track
     //Rec Track 
     if (!s_staticRecMdcTrackCol) {
            s_staticRecMdcTrackCol = new TObjArray();
     }
     m_recMdcTrackCol = s_staticRecMdcTrackCol;
 
     if (!s_staticRecMdcHitCol) {
       s_staticRecMdcHitCol = new TObjArray(); 
     }
     m_recMdcHitCol = s_staticRecMdcHitCol;
 
     if (!s_staticRecCgemTrackCol) {
            s_staticRecCgemTrackCol = new TObjArray();
     }
     m_recCgemTrackCol = s_staticRecCgemTrackCol;
 
     if (!s_staticRecCgemSegmentCol) {
            s_staticRecCgemSegmentCol = new TObjArray();
     }
     m_recCgemSegmentCol = s_staticRecCgemSegmentCol;
 
     if (!s_staticRecCgemHitCol) {
       s_staticRecCgemHitCol = new TObjArray(); 
     }
     m_recCgemHitCol = s_staticRecCgemHitCol;
 
     if (!s_staticRecCgemClusterCol) {
         s_staticRecCgemClusterCol =  new TObjArray();
     }
     m_recCgemClusterCol =  s_staticRecCgemClusterCol;
 
     if (! s_staticTofTrackCol ){
       s_staticTofTrackCol = new TObjArray();
     }
     m_recTofTrackCol = s_staticTofTrackCol;
 
     if (!s_staticEmcHitCol ){
        s_staticEmcHitCol = new TObjArray();
     }
     m_recEmcHitCol = s_staticEmcHitCol;
 
     if (!s_staticEmcClusterCol ){
        s_staticEmcClusterCol = new TObjArray();
     }
     m_recEmcClusterCol = s_staticEmcClusterCol;
   
     if (!s_staticEmcShowerCol ){
        s_staticEmcShowerCol = new TObjArray();
     }
     m_recEmcShowerCol = s_staticEmcShowerCol;
   
     
    if (! s_staticMucTrackCol ){
           s_staticMucTrackCol = new TObjArray();
     }
     m_recMucTrackCol = s_staticMucTrackCol;
 
     if (! s_staticRecMdcDedxCol ){
       s_staticRecMdcDedxCol = new TObjArray();
     }
     m_recMdcDedxCol = s_staticRecMdcDedxCol;
 
     if (! s_staticRecMdcDedxHitCol ){
       s_staticRecMdcDedxHitCol = new TObjArray();
     }
     m_recMdcDedxHitCol = s_staticRecMdcDedxHitCol;
 
     if (! s_staticRecCgemDedxCol ){
       s_staticRecCgemDedxCol = new TObjArray();
     }
     m_recCgemDedxCol = s_staticRecCgemDedxCol;
 
     if (! s_staticRecCgemDedxHitCol ){
       s_staticRecCgemDedxHitCol = new TObjArray();
     }
     m_recCgemDedxHitCol = s_staticRecCgemDedxHitCol;
 
 
     if (! s_staticExtTrackCol ){
            s_staticExtTrackCol = new TObjArray();
      }
      m_recExtTrackCol = s_staticExtTrackCol;
     
    
     if (! s_staticRecMdcKalTrackCol ){
       s_staticRecMdcKalTrackCol = new TObjArray();
     }
     m_recMdcKalTrackCol = s_staticRecMdcKalTrackCol;
 
     if (! s_staticRecMdcKalHelixSegCol ){
       s_staticRecMdcKalHelixSegCol = new TObjArray();
     }
     m_recMdcKalHelixSegCol = s_staticRecMdcKalHelixSegCol;
 
     if (! s_staticRecCgemKalTrackCol ){
       s_staticRecCgemKalTrackCol = new TObjArray();
     }
     m_recCgemKalTrackCol = s_staticRecCgemKalTrackCol;
 
     if (! s_staticRecCgemKalHelixSegCol ){
       s_staticRecCgemKalHelixSegCol = new TObjArray();
     }
     m_recCgemKalHelixSegCol = s_staticRecCgemKalHelixSegCol;
 
     if(! s_staticEvTimeCol ){
          s_staticEvTimeCol = new TObjArray();
     }
     m_recEvTimeCol = s_staticEvTimeCol;
 
     if ( ! s_staticRecZddChannelCol ) {
     s_staticRecZddChannelCol = new TObjArray();
     }
     m_recZddChannelCol = s_staticRecZddChannelCol;
 
     Clear();
    
}
 
//*****************************************************************
TRecTrackEvent::~TRecTrackEvent() {
    
    /****************************    Dst Track *************************/
    if(m_recMdcTrackCol == s_staticRecMdcTrackCol) s_staticRecMdcTrackCol = 0;
     m_recMdcTrackCol->Delete();
     delete m_recMdcTrackCol;
     m_recMdcTrackCol = 0;
 
    if(m_recMdcHitCol == s_staticRecMdcHitCol) s_staticRecMdcHitCol = 0;
     m_recMdcHitCol->Delete();
     delete m_recMdcHitCol;
     m_recMdcHitCol = 0;
 
    if(m_recCgemTrackCol == s_staticRecCgemTrackCol) s_staticRecCgemTrackCol = 0;
     m_recCgemTrackCol->Delete();
     delete m_recCgemTrackCol;
     m_recCgemTrackCol = 0;
 
    if(m_recCgemSegmentCol == s_staticRecCgemSegmentCol) s_staticRecCgemSegmentCol = 0;
     m_recCgemSegmentCol->Delete();
     delete m_recCgemSegmentCol;
     m_recCgemSegmentCol = 0;
 
    if(m_recCgemHitCol == s_staticRecCgemHitCol) s_staticRecCgemHitCol = 0;
     m_recCgemHitCol->Delete();
     delete m_recCgemHitCol;
     m_recCgemHitCol = 0;
 
     if(m_recCgemClusterCol == s_staticRecCgemClusterCol) s_staticRecCgemClusterCol = 0;
     m_recCgemClusterCol->Delete();
     delete m_recCgemClusterCol;
     m_recCgemClusterCol = 0;
 
     if(m_recTofTrackCol == s_staticTofTrackCol ) s_staticTofTrackCol = 0;
     m_recTofTrackCol->Delete();
     delete m_recTofTrackCol;
     m_recTofTrackCol = 0;
 
     if(m_recEmcHitCol == s_staticEmcHitCol) s_staticEmcHitCol = 0;
     m_recEmcHitCol->Delete();
     delete m_recEmcHitCol;
     m_recEmcHitCol = 0;
 
     if(m_recEmcClusterCol == s_staticEmcClusterCol) s_staticEmcClusterCol = 0;
     m_recEmcClusterCol->Delete();
     delete m_recEmcClusterCol;
     m_recEmcClusterCol = 0;
 
     if(m_recEmcShowerCol == s_staticEmcShowerCol) s_staticEmcShowerCol = 0;
     m_recEmcShowerCol->Delete();
     delete m_recEmcShowerCol;
     m_recEmcShowerCol = 0;
 
 
     if(m_recMucTrackCol == s_staticMucTrackCol ) s_staticMucTrackCol = 0;
     m_recMucTrackCol->Delete();
     delete m_recMucTrackCol;
     m_recMucTrackCol = 0;
 
     if(m_recMdcDedxCol == s_staticRecMdcDedxCol ) s_staticRecMdcDedxCol = 0;
     m_recMdcDedxCol->Delete();
     delete m_recMdcDedxCol;
     m_recMdcDedxCol = 0;
 
     if(m_recMdcDedxHitCol == s_staticRecMdcDedxHitCol ) s_staticRecMdcDedxHitCol = 0;
     m_recMdcDedxHitCol->Delete();
     delete m_recMdcDedxHitCol;
     m_recMdcDedxHitCol = 0;
 
     if(m_recCgemDedxCol == s_staticRecCgemDedxCol ) s_staticRecCgemDedxCol = 0;
     m_recCgemDedxCol->Delete();
     delete m_recCgemDedxCol;
     m_recCgemDedxCol = 0;
 
     if(m_recCgemDedxHitCol == s_staticRecCgemDedxHitCol ) s_staticRecCgemDedxHitCol = 0;
     m_recCgemDedxHitCol->Delete();
     delete m_recCgemDedxHitCol;
     m_recCgemDedxHitCol = 0;
 
 
     if(m_recExtTrackCol == s_staticExtTrackCol ) s_staticExtTrackCol = 0;
     m_recExtTrackCol->Delete();
     delete m_recExtTrackCol;
     m_recExtTrackCol = 0;
    
    if(m_recMdcKalTrackCol == s_staticRecMdcKalTrackCol ) s_staticRecMdcKalTrackCol = 0;
    m_recMdcKalTrackCol->Delete();
    delete m_recMdcKalTrackCol;
    m_recMdcKalTrackCol = 0;
 
    if(m_recMdcKalHelixSegCol == s_staticRecMdcKalHelixSegCol ) s_staticRecMdcKalHelixSegCol = 0;
    m_recMdcKalHelixSegCol->Delete();
    delete m_recMdcKalHelixSegCol;
    m_recMdcKalHelixSegCol = 0;
 
    if(m_recCgemKalTrackCol == s_staticRecCgemKalTrackCol ) s_staticRecCgemKalTrackCol = 0;
    m_recCgemKalTrackCol->Delete();
    delete m_recCgemKalTrackCol;
    m_recCgemKalTrackCol = 0;
 
    if(m_recCgemKalHelixSegCol == s_staticRecCgemKalHelixSegCol ) s_staticRecCgemKalHelixSegCol = 0;
    m_recCgemKalHelixSegCol->Delete();
    delete m_recCgemKalHelixSegCol;
    m_recCgemKalHelixSegCol = 0;
 
    if(m_recEvTimeCol == s_staticEvTimeCol ) s_staticEvTimeCol = 0;
    m_recEvTimeCol->Delete();
    delete m_recEvTimeCol;
    m_recEvTimeCol = 0; 
 
    if ( m_recZddChannelCol == s_staticRecZddChannelCol ) s_staticRecZddChannelCol = 0;
    m_recZddChannelCol->Delete();
    delete m_recZddChannelCol;
    m_recZddChannelCol = 0;
}
 
//*****************************************************************
void TRecTrackEvent::initialize(){ 
}
  
//*****************************************************************
void TRecTrackEvent::Clear(Option_t *option) {
 
}
 
//*****************************************************************************
void TRecTrackEvent::Print(Option_t *option) const {
    TObject::Print(option);
}
 
 
/****************     Dst Track     ************************/
/// Mdc
 void TRecTrackEvent::addRecMdcTrack(TRecMdcTrack *Track) {
     m_recMdcTrackCol->Add(Track);
 }
 
 const TRecMdcTrack* TRecTrackEvent::getRecMdcTrack(Int_t i) const {
     if (Int_t(i) >= m_recMdcTrackCol->GetEntries())
            return 0;
     return (TRecMdcTrack*)m_recMdcTrackCol->At(i);
 }
 
 void TRecTrackEvent::addRecMdcHit(TRecMdcHit *Hit) {
     m_recMdcHitCol->Add(Hit);
 }
 
 const TRecMdcHit* TRecTrackEvent::getRecMdcHit(Int_t i) const {
     if (Int_t(i) >= m_recMdcHitCol->GetEntries())
            return 0;
     return (TRecMdcHit*)m_recMdcHitCol->At(i);
 }
 
/// Cgem
 void TRecTrackEvent::addRecCgemSegment(TRecCgemSegment *Segment) {
     m_recCgemSegmentCol->Add(Segment);
 }
 
 const TRecCgemSegment* TRecTrackEvent::getRecCgemSegment(Int_t i) const {
     if (Int_t(i) >= m_recCgemSegmentCol->GetEntries())
            return 0;
     return (TRecCgemSegment*)m_recCgemSegmentCol->At(i);
 }
 
 void TRecTrackEvent::addRecCgemTrack(TRecCgemTrack *Track) {
     m_recCgemTrackCol->Add(Track);
 }
 
 const TRecCgemTrack* TRecTrackEvent::getRecCgemTrack(Int_t i) const {
     if (Int_t(i) >= m_recCgemTrackCol->GetEntries())
            return 0;
     return (TRecCgemTrack*)m_recCgemTrackCol->At(i);
 }
 
 void TRecTrackEvent::addRecCgemHit(TRecCgemHit *Hit) {
     m_recCgemHitCol->Add(Hit);
 }
 
 const TRecCgemHit* TRecTrackEvent::getRecCgemHit(Int_t i) const {
     if (Int_t(i) >= m_recCgemHitCol->GetEntries())
            return 0;
     return (TRecCgemHit*)m_recCgemHitCol->At(i);
 }
 
 void TRecTrackEvent::addRecCgemCluster(TRecCgemCluster *Cluster) {
     m_recCgemClusterCol->Add(Cluster);
 }
 const TRecCgemCluster* TRecTrackEvent::getRecCgemCluster(Int_t i)const{
     if(Int_t(i) >= m_recCgemClusterCol->GetEntries())
         return 0;
     return (TRecCgemCluster*)m_recCgemClusterCol->At(i);
 }
 
///Tof
void  TRecTrackEvent::addTofTrack(TRecTofTrack * Track){
  m_recTofTrackCol->Add(Track);
}
 
const TRecTofTrack*  TRecTrackEvent::getTofTrack(Int_t i) const {
  if(Int_t(i) >=m_recTofTrackCol->GetEntries())
    return 0;
  return (TRecTofTrack*) m_recTofTrackCol->At(i);
}
 
 ///Emc
 void TRecTrackEvent::addEmcHit(TRecEmcHit * Track) {
     m_recEmcHitCol->Add(Track);
 }
 
 const TRecEmcHit* TRecTrackEvent::getEmcHit( Int_t i) const {
     if(Int_t(i) >= m_recEmcHitCol->GetEntries())
       return 0;
     return (TRecEmcHit*)m_recEmcHitCol->At(i);
 }
 
 void TRecTrackEvent::addEmcCluster(TRecEmcCluster * Track) {
     m_recEmcClusterCol->Add(Track);
 }
 
 const TRecEmcCluster* TRecTrackEvent::getEmcCluster( Int_t i) const {
     if(Int_t(i) >= m_recEmcClusterCol->GetEntries())
       return 0;
     return (TRecEmcCluster*)m_recEmcClusterCol->At(i);
 }
 
 void TRecTrackEvent::addEmcShower(TRecEmcShower * Track) {
     m_recEmcShowerCol->Add(Track);
 }
 
 const TRecEmcShower* TRecTrackEvent::getEmcShower( Int_t i) const {
     if(Int_t(i) >= m_recEmcShowerCol->GetEntries())
       return 0;
     return (TRecEmcShower*)m_recEmcShowerCol->At(i);
 }
 
    ///Muc 
void  TRecTrackEvent::addMucTrack(TRecMucTrack * Track){
    m_recMucTrackCol->Add(Track);
}
 
 
const TRecMucTrack*  TRecTrackEvent::getMucTrack(Int_t i) const {
    if(Int_t(i) >=m_recMucTrackCol->GetEntries())
        return 0;
    return (TRecMucTrack*) m_recMucTrackCol->At(i);
}
 
///Dedx
 void  TRecTrackEvent::addRecMdcDedx(TRecMdcDedx * Track){
     m_recMdcDedxCol->Add(Track);
 }
 
 
 const TRecMdcDedx*  TRecTrackEvent::getRecMdcDedx(Int_t i) const {
    if(Int_t(i) >=m_recMdcDedxCol->GetEntries())
        return 0;
    return (TRecMdcDedx*) m_recMdcDedxCol->At(i);
 }
 
 
void  TRecTrackEvent::addRecMdcDedxHit(TRecMdcDedxHit * Track){
  m_recMdcDedxHitCol->Add(Track);
}
 
 
 const TRecMdcDedxHit*  TRecTrackEvent::getRecMdcDedxHit(Int_t i) const {
   if(Int_t(i) >=m_recMdcDedxHitCol->GetEntries())
     return 0;
   return (TRecMdcDedxHit*) m_recMdcDedxHitCol->At(i);
 }
 
 void  TRecTrackEvent::addRecCgemDedx(TRecCgemDedx * Track){
     m_recCgemDedxCol->Add(Track);
 }
 
 
 const TRecCgemDedx*  TRecTrackEvent::getRecCgemDedx(Int_t i) const {
    if(Int_t(i) >=m_recCgemDedxCol->GetEntries())
        return 0;
    return (TRecCgemDedx*) m_recCgemDedxCol->At(i);
 }
 
 
void  TRecTrackEvent::addRecCgemDedxHit(TRecCgemDedxHit * Track){
  m_recCgemDedxHitCol->Add(Track);
}
 
 
 const TRecCgemDedxHit*  TRecTrackEvent::getRecCgemDedxHit(Int_t i) const {
   if(Int_t(i) >=m_recCgemDedxHitCol->GetEntries())
     return 0;
   return (TRecCgemDedxHit*) m_recCgemDedxHitCol->At(i);
 }
 
// // Ext
 void  TRecTrackEvent::addExtTrack(TRecExtTrack * Track){
     m_recExtTrackCol->Add(Track);
 }
 
 const TRecExtTrack*  TRecTrackEvent::getExtTrack(Int_t i) const {
         if(Int_t(i) >=m_recExtTrackCol->GetEntries())
               return 0;
       return (TRecExtTrack*) m_recExtTrackCol->At(i);
 }
 
//RecMdcKal
void  TRecTrackEvent::addRecMdcKalTrack(TRecMdcKalTrack * Track){
    m_recMdcKalTrackCol->Add(Track);
}
 
const TRecMdcKalTrack*  TRecTrackEvent::getRecMdcKalTrack(Int_t i) const {
     if(Int_t(i) >=m_recMdcKalTrackCol->GetEntries())
    return 0;
     return (TRecMdcKalTrack*) m_recMdcKalTrackCol->At(i);
}
 
void TRecTrackEvent::addRecMdcKalHelixSeg(TRecMdcKalHelixSeg * Track){
    m_recMdcKalHelixSegCol->Add(Track);
}
 
const TRecMdcKalHelixSeg* TRecTrackEvent::getRecMdcKalHelixSeg(Int_t i) const {
    if(Int_t(i) >= m_recMdcKalHelixSegCol->GetEntries())
        return 0;
    return ( TRecMdcKalHelixSeg*) m_recMdcKalHelixSegCol->At(i);
}
 
//RecCgemKal
void  TRecTrackEvent::addRecCgemKalTrack(TRecCgemKalTrack * Track){
    m_recCgemKalTrackCol->Add(Track);
}
 
const TRecCgemKalTrack*  TRecTrackEvent::getRecCgemKalTrack(Int_t i) const {
     if(Int_t(i) >=m_recCgemKalTrackCol->GetEntries())
    return 0;
     return (TRecCgemKalTrack*) m_recCgemKalTrackCol->At(i);
}
 
void TRecTrackEvent::addRecCgemKalHelixSeg(TRecCgemKalHelixSeg * Track){
    m_recCgemKalHelixSegCol->Add(Track);
}
 
const TRecCgemKalHelixSeg* TRecTrackEvent::getRecCgemKalHelixSeg(Int_t i) const {
    if(Int_t(i) >= m_recCgemKalHelixSegCol->GetEntries())
        return 0;
    return ( TRecCgemKalHelixSeg*) m_recCgemKalHelixSegCol->At(i);
}
 
//EsTime
void  TRecTrackEvent::addEvTime(TRecEvTime * Track){
    m_recEvTimeCol->Add(Track);
}
 
const TRecEvTime*  TRecTrackEvent::getEvTime(Int_t i) const {
     if(Int_t(i) >=m_recEvTimeCol->GetEntries())
    return 0;
     return (TRecEvTime*) m_recEvTimeCol->At(i);
}
 
// ZDD
void TRecTrackEvent::addRecZddChannel(TRecZddChannel* zdd) {
  m_recZddChannelCol->Add(zdd);
}
 
const TRecZddChannel* TRecTrackEvent::getRecZddChannel(Int_t i) const {
  if ( i >= m_recZddChannelCol->GetEntries() || i < 0 )
     return 0;
  return (TRecZddChannel*) m_recZddChannelCol->At(i);
}