TRecTrackEvent.h

Go to the documentation of this file.

#ifndef ROOT_TRecTrackEvent_H
#define ROOT_TRecTrackEvent_H 1
 
#include "TObject.h"
#include "TClonesArray.h"
#include "TObjArray.h"
 
#include "TRecMdcTrack.h"
#include "TRecMdcKalTrack.h"
#include "TRecMdcHit.h"
#include "TRecCgemTrack.h"
#include "TRecCgemSegment.h"
#include "TRecCgemKalTrack.h"
#include "TRecCgemHit.h"
#include "TRecCgemCluster.h"
#include "TTofTrack.h"
#include "TRecTofTrack.h"
#include "TRecEmcHit.h"
#include "TRecEmcCluster.h"
#include "TRecEmcShower.h"
#include "TRecMucTrack.h"
#include "TRecMdcDedx.h"
#include "TRecMdcDedxHit.h"
#include "TRecCgemDedx.h"
#include "TRecCgemDedxHit.h"
#include "TRecExtTrack.h"
#include "TRecEvTime.h"
#include "TRecMdcKalHelixSeg.h"
#include "TRecCgemKalHelixSeg.h"
#include "TRecZddChannel.h"
 
class TRecTrackEvent : public TObject {
    
public:
 
    TRecTrackEvent();
    virtual ~TRecTrackEvent();
 
    void initialize();
 
    void Clear(Option_t *option="");
 
    void Print(Option_t *option="") const;
 
 
  //  inline Bool_t getFromMc() { return m_fromMc; };
 
 
   // ********************* Dst Track ******************************/
   /// retrieve the whole TObjArray of RecMdcTrack Data 
     const TObjArray* getRecMdcTrackCol() const { return m_recMdcTrackCol; }; 
    
     /// Add a TkrTrack into the Mdc data collection 
     void addRecMdcTrack(TRecMdcTrack *Track); 
    
     /// retrieve a MdcTrack from the collection, using the index into the array 
     const TRecMdcTrack* getRecMdcTrack(Int_t i) const; 
  
     /// clear the whole array (necessary because of the consts-s) 
     void clearRecMdcTrackCol() { m_recMdcTrackCol->Clear(); } 
 
     /// retrieve the whole TObjArray of RecMdcHit Data 
     const TObjArray* getRecMdcHitCol() const { return m_recMdcHitCol; };
    
     /// Add a Rec Mdc Hit into the Mdc data collection 
     void addRecMdcHit(TRecMdcHit *Hit); 
    
     /// retrieve a RecMdcHit from the collection, using the index into the array 
     const TRecMdcHit* getRecMdcHit(Int_t i) const;
     /// clear the whole array (necessary because of the consts-s) 
     void clearRecMdcHitCol() { m_recMdcHitCol->Clear(); }
 
   /// retrieve the whole TObjArray of RecCgemTrack Data 
     const TObjArray* getRecCgemTrackCol() const { return m_recCgemTrackCol; }; 
    
     /// Add a TkrTrack into the Cgem data collection 
     void addRecCgemTrack(TRecCgemTrack *Track); 
    
     /// retrieve a CgemTrack from the collection, using the index into the array 
     const TRecCgemTrack* getRecCgemTrack(Int_t i) const; 
  
     /// clear the whole array (necessary because of the consts-s) 
     void clearRecCgemTrackCol() { m_recCgemTrackCol->Clear(); } 
 
   /// retrieve the whole TObjArray of RecCgemSegment Data 
     const TObjArray* getRecCgemSegmentCol() const { return m_recCgemSegmentCol; }; 
    
     /// Add a TkrSegment into the Cgem data collection 
     void addRecCgemSegment(TRecCgemSegment *Segment); 
    
     /// retrieve a CgemSegment from the collection, using the index into the array 
     const TRecCgemSegment* getRecCgemSegment(Int_t i) const; 
  
     /// clear the whole array (necessary because of the consts-s) 
     void clearRecCgemSegmentCol() { m_recCgemSegmentCol->Clear(); } 
 
     /// retrieve the whole TObjArray of RecCgemHit Data 
     const TObjArray* getRecCgemHitCol() const { return m_recCgemHitCol; };
    
     /// Add a Rec Cgem Hit into the Cgem data collection 
     void addRecCgemHit(TRecCgemHit *Hit); 
    
     /// retrieve a RecCgemHit from the collection, using the index into the array 
     const TRecCgemHit* getRecCgemHit(Int_t i) const;
     /// clear the whole array (necessary because of the consts-s) 
     void clearRecCgemHitCol() { m_recCgemHitCol->Clear(); }
 
    /// retrive the whole TObjArray of RecCgemCluster Data
    const TObjArray* getRecCgemClusterCol() const {return m_recCgemClusterCol;};
 
    ///Add a Rec Cgem Cluster into the Cgem data collection
    void addRecCgemCluster(TRecCgemCluster *Cluster);
 
    ///retrieve a RecCgemCluster from the collection,using the index into the array
    const TRecCgemCluster* getRecCgemCluster(Int_t i)const;
    ///clear the whole array(necessary because of the consts-s)
    void clearRecCgemClusterCol() {m_recCgemClusterCol->Clear();}
 
    /// retrieve the whole TObjArray  of TofTrack Data
    const TObjArray* getTofTrackCol() const { return m_recTofTrackCol; };
 
    ///Add a TofTrack into the TOF Data collection
    void addTofTrack(TRecTofTrack * Track);
 
    /// retrieve a TofTrack From the collection, using the index into the array
    const  TRecTofTrack*  getTofTrack(Int_t i) const;
 
    /// clear the whole  array
    void  clearTofTrackCol() { m_recTofTrackCol->Clear();}
   
 
    /// retrieve the whole TObjArray of EmcHit Data 
    const TObjArray* getEmcHitCol() const { return m_recEmcHitCol; }; 
   
    /// Add a TkrTrack into the Emc data collection */
    void addEmcHit(TRecEmcHit *Track); 
    
    /// retrieve a EmcHit from the collection, using the index into the array */
     const TRecEmcHit* getEmcHit(Int_t i) const; 
   
    /// clear the whole array (necessary because of the consts-s) */
     void clearEmcHitCol() { m_recEmcHitCol->Clear(); } 
 
    /// retrieve the whole TObjArray of EmcCluster Data 
    const TObjArray* getEmcClusterCol() const { return m_recEmcClusterCol; }; 
   
    /// Add a TkrTrack into the Emc data collection */
    void addEmcCluster(TRecEmcCluster *Track); 
    
    /// retrieve a EmcCluster from the collection, using the index into the array */
     const TRecEmcCluster* getEmcCluster(Int_t i) const; 
   
    /// clear the whole array (necessary because of the consts-s) */
     void clearEmcClusterCol() { m_recEmcClusterCol->Clear(); } 
 
    /// retrieve the whole TObjArray of EmcShower Data 
    const TObjArray* getEmcShowerCol() const { return m_recEmcShowerCol; }; 
   
    /// Add a TkrTrack into the Emc data collection */
    void addEmcShower(TRecEmcShower *Track); 
    
    /// retrieve a EmcShower from the collection, using the index into the array */
     const TRecEmcShower* getEmcShower(Int_t i) const; 
   
    /// clear the whole array (necessary because of the consts-s) */
     void clearEmcShowerCol() { m_recEmcShowerCol->Clear(); } 
 
 
      /// retrieve the whole TObjArray  of MucTrack Data
   const TObjArray* getMucTrackCol() const { return m_recMucTrackCol; };
 
   ///Add a MucTrack into the TOF Data collection
   void addMucTrack(TRecMucTrack * Track);
 
   /// retrieve a MucTrack From the collection, using the index into the array
   const  TRecMucTrack*  getMucTrack(Int_t i) const;
 
   /// clear the whole  array 
   void  clearMucTrackCol() { m_recMucTrackCol->Clear();}
 
   /// retrieve the whole TObjArray  of Dedx Data 
    const TObjArray* getRecMdcDedxCol() const { return m_recMdcDedxCol; };
 
   ///Add a Dedx into the TOF Data collection 
    void addRecMdcDedx(TRecMdcDedx * Track);
 
   /// retrieve a TofTrack From the collection, using the index into the array 
   const  TRecMdcDedx*  getRecMdcDedx(Int_t i) const; 
 
    /// clear the whole  array  
    void  clearRecMdcDedxCol() { m_recMdcDedxCol->Clear();} 
 
 
    /// retrieve the whole TObjArray  of Dedx Data 
    const TObjArray* getRecMdcDedxHitCol() const { return m_recMdcDedxHitCol; };
 
    ///Add a Dedx into the TOF Data collection 
    void addRecMdcDedxHit(TRecMdcDedxHit * Track);
 
    /// retrieve a TofTrack From the collection, using the index into the array 
    const  TRecMdcDedxHit*  getRecMdcDedxHit(Int_t i) const;
 
    /// clear the whole  array  
    void  clearRecMdcDedxHitCol() { m_recMdcDedxHitCol->Clear();}
                             
    
   /// retrieve the whole TObjArray  of Dedx Data 
    const TObjArray* getRecCgemDedxCol() const { return m_recCgemDedxCol; };
 
   ///Add a Dedx into the TOF Data collection 
    void addRecCgemDedx(TRecCgemDedx * Track);
 
   /// retrieve a TofTrack From the collection, using the index into the array 
   const  TRecCgemDedx*  getRecCgemDedx(Int_t i) const; 
 
    /// clear the whole  array  
    void  clearRecCgemDedxCol() { m_recCgemDedxCol->Clear();} 
 
 
    /// retrieve the whole TObjArray  of Dedx Data 
    const TObjArray* getRecCgemDedxHitCol() const { return m_recCgemDedxHitCol; };
 
    ///Add a Dedx into the TOF Data collection 
    void addRecCgemDedxHit(TRecCgemDedxHit * Track);
 
    /// retrieve a TofTrack From the collection, using the index into the array 
    const  TRecCgemDedxHit*  getRecCgemDedxHit(Int_t i) const;
 
    /// clear the whole  array  
    void  clearRecCgemDedxHitCol() { m_recCgemDedxHitCol->Clear();}
                             
    
/*    /// retrieve the whole TObjArray  of Ext Data */
    const TObjArray* getExtTrackCol() const { return m_recExtTrackCol; };
 
      ///Add a ExtTrack into the Ext Data collection 
    void addExtTrack(TRecExtTrack * Track); 
   
/*       /// retrieve a MucTrack From the collection, using the index into the array */
    const  TRecExtTrack*  getExtTrack(Int_t i) const;
   
/*       /// clear the whole  array  */
    void  clearExtTrackCol() { m_recExtTrackCol->Clear();}
 
    //  TObjArray  of MdcKal Data
   const TObjArray* getRecMdcKalTrackCol() const { return m_recMdcKalTrackCol; }
   void addRecMdcKalTrack(TRecMdcKalTrack * Track);
   const TRecMdcKalTrack*  getRecMdcKalTrack(Int_t i) const;
   void  clearRecMdcKalTrackCol() { m_recMdcKalTrackCol->Clear();}
 
  //  TObjArray  of MdcKalHit Data
   const TObjArray* getRecMdcKalHelixSegCol() const { return m_recMdcKalHelixSegCol; }
   void addRecMdcKalHelixSeg(TRecMdcKalHelixSeg * Track);
   const TRecMdcKalHelixSeg*  getRecMdcKalHelixSeg(Int_t i) const;
   void  clearRecMdcKalHelixSegCol() { m_recMdcKalHelixSegCol->Clear();}
 
    //  TObjArray  of CgemKal Data
   const TObjArray* getRecCgemKalTrackCol() const { return m_recCgemKalTrackCol; }
   void addRecCgemKalTrack(TRecCgemKalTrack * Track);
   const TRecCgemKalTrack*  getRecCgemKalTrack(Int_t i) const;
   void  clearRecCgemKalTrackCol() { m_recCgemKalTrackCol->Clear();}
 
  //  TObjArray  of CgemKalHit Data
   const TObjArray* getRecCgemKalHelixSegCol() const { return m_recCgemKalHelixSegCol; }
   void addRecCgemKalHelixSeg(TRecCgemKalHelixSeg * Track);
   const TRecCgemKalHelixSeg*  getRecCgemKalHelixSeg(Int_t i) const;
   void  clearRecCgemKalHelixSegCol() { m_recCgemKalHelixSegCol->Clear();}
 
 
   //  TObjArray of EsTime Data
   const TObjArray* getEvTimeCol() const { return m_recEvTimeCol; }
   void addEvTime(TRecEvTime * Track);
   const  TRecEvTime*  getEvTime(Int_t i) const;
   void  clearEvTimeCol() { m_recEvTimeCol->Clear();}
 
   // Interfaces of RecZddChannel
   const TObjArray* getRecZddChannelCol() const {return m_recZddChannelCol; }
   void addRecZddChannel(TRecZddChannel* dtag);
   const TRecZddChannel* getRecZddChannel(Int_t i) const;
   void clearRecZddChannelCol() { m_recZddChannelCol->Clear(); }
 
private:
 
     /// data members to store Mdc data 
     static TObjArray *s_staticRecMdcTrackCol;
     TObjArray* m_recMdcTrackCol; //->  
     static TObjArray *s_staticRecMdcHitCol;
     TObjArray* m_recMdcHitCol; //->
    
     /// data members to store Cgem data 
     static TObjArray *s_staticRecCgemSegmentCol;
     TObjArray* m_recCgemSegmentCol; //->  
     static TObjArray *s_staticRecCgemTrackCol;
     TObjArray* m_recCgemTrackCol; //->  
     static TObjArray *s_staticRecCgemHitCol;
     TObjArray* m_recCgemHitCol; //->
     static TObjArray *s_staticRecCgemClusterCol;
     TObjArray* m_recCgemClusterCol;
    
     static TObjArray * s_staticEmcHitCol; 
     TObjArray* m_recEmcHitCol; //-> 
 
     static TObjArray * s_staticEmcClusterCol; 
     TObjArray* m_recEmcClusterCol; //-> 
 
/*     /// data members to store Emc track data */
     static TObjArray * s_staticEmcShowerCol; 
     TObjArray* m_recEmcShowerCol; //-> 
 
     /// data members to store Tof data
     static TObjArray * s_staticTofTrackCol;
     TObjArray* m_recTofTrackCol; //->
 
     /// data members to store Muc data
     static TObjArray *s_staticMucTrackCol;
     TObjArray* m_recMucTrackCol; //->
 
     /// data members to store Dedx data 
    static TObjArray * s_staticRecMdcDedxCol; 
    TObjArray* m_recMdcDedxCol; //-> 
    
    /// data members to store Dedx data
    static TObjArray * s_staticRecMdcDedxHitCol;
    TObjArray* m_recMdcDedxHitCol; //->
    
    static TObjArray * s_staticRecCgemDedxCol; 
    TObjArray* m_recCgemDedxCol; //-> 
    
    /// data members to store Dedx data
    static TObjArray * s_staticRecCgemDedxHitCol;
    TObjArray* m_recCgemDedxHitCol; //->
    
/*     /// data members to store Ext data */
     static TObjArray * s_staticExtTrackCol; 
     TObjArray* m_recExtTrackCol; //-> 
    
/*     /// data members to store MdcKal data */
    static TObjArray * s_staticRecMdcKalTrackCol; 
    TObjArray* m_recMdcKalTrackCol;   //->
 
     /// data members to store MdcKal data 
    static TObjArray * s_staticRecMdcKalHelixSegCol; 
    TObjArray* m_recMdcKalHelixSegCol;   //->
 
/*     /// data members to store CgemKal data */
    static TObjArray * s_staticRecCgemKalTrackCol; 
    TObjArray* m_recCgemKalTrackCol;   //->
 
     /// data members to store CgemKal data 
    static TObjArray * s_staticRecCgemKalHelixSegCol; 
    TObjArray* m_recCgemKalHelixSegCol;   //->
 
    /// data members to store EvTime data
    static TObjArray *s_staticEvTimeCol;
    TObjArray* m_recEvTimeCol;     //->
 
    // data members to store RecZddChannel
    static TObjArray* s_staticRecZddChannelCol;
    TObjArray* m_recZddChannelCol;  //->
 
     ClassDef(TRecTrackEvent,9)
 
};
 
#endif