StEmcMicroEvent.h

#ifndef StEmcMicroEvent__h
#define StEmcMicroEvent__h
 
#include "TObject.h"
#include "StEmcMicroCollection.h"
#include "StFpdMicroCollection.h"
#include "StEmcMicroTrack.h"
#include "StEmcMicroV0.h"
#include "TObjArray.h" 
 
class StEmcMicroEvent : public TObject 
{
 
 public:
 
                StEmcMicroEvent();
  virtual       ~StEmcMicroEvent();
     
  Int_t         getVersion()                 const { return mVersion; }                            

  StEmcMicroCollection* getEmc()             const { return fEmc; }                                
  StFpdMicroCollection* getFpd()             const { return fFpd; }                                
  
  StEmcMicroTrack* getPrimaryTrack(Int_t i)  const { return (StEmcMicroTrack*)fpTracks->At(i); }   
  Int_t            getNPrimaryTrack()        const { return fpTracks->GetEntries(); }              
  StEmcMicroTrack* getGlobalTrack(Int_t i)   const { return (StEmcMicroTrack*)fgTracks->At(i); }   
  Int_t            getNGlobalTrack()         const { return fgTracks->GetEntries(); }              
   
  StEmcMicroV0*    getV0(Int_t i)            const { return (StEmcMicroV0*)fV0->At(i); }           
  Int_t            getNV0()                  const { return fV0->GetEntries(); }                   
  
  UInt_t        getOrigMult()                const { return mOrigMult; }                           
  UInt_t        getCentrality()              const { return mCentrality; }                         
  Float_t       getVertexX()                 const { return mVertexX; }                            
  Float_t       getVertexY()                 const { return mVertexY; }                            
  Float_t       getVertexZ()                 const { return mVertexZ; }                            
  
  UInt_t        getL0TriggerWord()           const { return mL0TriggerWord; }                      

  Int_t         getEventID()                 const { return mEventID; }                            
  Int_t         getRunID()                   const { return mRunID; }                              
  Int_t         getEventTime()               const { return mEventTime; }                          
  Int_t         getToken()                   const { return mToken; }                              

  Int_t         getCTB()                     const { return mCTB; }                                

  Int_t         getZDCe()                    const { return mZDCe; }                               
  Int_t         getZDCw()                    const { return mZDCw; }                               
  Float_t       getZVertexZDC()              const { return mZVertexZDC; }                         

  Int_t         getBBCe()                    const { return mBBCe; }                               
  Int_t         getBBCw()                    const { return mBBCw; }                               
  Int_t         getBBCSum()                  const { return mBBCe+mBBCw; }                         
  Int_t         getBBCNHits()                const { return mBBCNHits; }                           
  Float_t       getZVertexBBC()              const { return mZVertexBBC; }                         

  Int_t         getHighTower(Int_t i)        const { return (Int_t)mHT[i]; }                       
  Int_t         getPatch(Int_t i)            const { return (Int_t)mPATCH[i]; }                    
  
  UInt_t        getBunchCrossing7bit()       const { return mBX7bit; }                             
  UInt_t        getBunchCrossing()           const { return mBX; }                                 
  Int_t         getSpinBits()                const { return mSpinBits; }                           
  Int_t         getSpinBitYellowUp()         const { return (mSpinBits >> 0) & 0x1; }              
  Int_t         getSpinBitYellowDown()       const { return (mSpinBits >> 1) & 0x1; }              
  Int_t         getSpinBitBlueUp()           const { return (mSpinBits >> 2) & 0x1; }              
  Int_t         getSpinBitBlueDown()         const { return (mSpinBits >> 3) & 0x1; }              
    
  Float_t       getBField()                  const { return mBField; }                             
      
  void setEmc(StEmcMicroCollection* emc)            { fEmc = emc; }  
  void setFpd(StFpdMicroCollection* fpd)            { fFpd = fpd; }
  void addPrimaryTrack(StEmcMicroTrack *t)          { fpTracks->AddLast(t); }
  void addGlobalTrack(StEmcMicroTrack *t)           { fgTracks->AddLast(t); }
  void addV0(StEmcMicroV0 *v)                       { fV0->AddLast(v); }
   
  void setVersion(const Int_t ver)                  { mVersion = ver; }
    
  void setOrigMult(const UInt_t mult)               { mOrigMult = mult; }
  void setCentrality(const UInt_t cent)             { mCentrality = cent; }
  void setVertexPos(const Float_t x, const Float_t y, const Float_t z) { mVertexX=x; mVertexY=y; mVertexZ=z; }

  void setL0TriggerWord(const UInt_t trigger)       { mL0TriggerWord = trigger; }
  void setEventID(const Int_t id)                   { mEventID = id; }
  void setRunID(const Int_t id)                     { mRunID = id; }
  void setEventTime(const Int_t time)               { mEventTime = time; }
  void setToken(const Int_t token)                  { mToken = token; }

  void setCTB(const Int_t ctb)                      { mCTB  = ctb; }

  void setZDCe(const Int_t zdce)                    { mZDCe = zdce; }
  void setZDCw(const Int_t zdcw)                    { mZDCw = zdcw; }
  void setZVertexZDC(const Float_t ZVZDC)           { mZVertexZDC = ZVZDC; }

  void setBBCe(const Int_t bbce)                    { mBBCe = bbce; }
  void setBBCw(const Int_t bbcw)                    { mBBCw = bbcw; }
  void setBBCNHits(const Int_t BBCNH)               { mBBCNHits = BBCNH; }
  void setZVertexBBC(const Float_t ZVBBC)           { mZVertexBBC = ZVBBC; }
  
  void setHighTower(const Int_t i, const Int_t HT)  { mHT[i] = (Char_t)HT; }
  void setPatch(const Int_t i, const Int_t PATCH)   { mPATCH[i] = (Char_t)PATCH; }
  
  void setBunchCrossing7bit(const UInt_t BX7)       { mBX7bit = BX7; }
  void setBunchCrossing(const UInt_t BX)            { mBX = BX; }
  void setSpinBits(const Int_t Spin)                { mSpinBits = Spin; }
   
  void setBField(const Float_t bf)                  { mBField = bf; }
 
 private:

  void clear(Option_t *option="");
 
  Int_t          mVersion;              

  UInt_t         mOrigMult;             
  UInt_t         mCentrality;           
  Float_t        mVertexX;              
  Float_t        mVertexY;              
  Float_t        mVertexZ;              
    
  UInt_t         mL0TriggerWord;        
  Int_t          mEventID;              
  Int_t          mRunID;                
  Int_t          mEventTime;            
  Int_t          mToken;                
  Int_t          mCTB;                  
  Int_t          mZDCe;                 
  Int_t          mZDCw;                 
  Float_t        mZVertexZDC;           
  Int_t          mBBCe;                 
  Int_t          mBBCw;                 
  Int_t          mBBCNHits;             
  Float_t        mZVertexBBC;           
  
  Char_t         mHT[300];              
  Char_t         mPATCH[300];           
    
  UInt_t         mBX7bit;               
  UInt_t         mBX;                   
  Int_t          mSpinBits;             

  Float_t        mBField;               
 
  StEmcMicroCollection* fEmc;
  StFpdMicroCollection* fFpd;
  TObjArray*            fpTracks;
  TObjArray*            fgTracks;
  TObjArray*            fV0;
                   
  ClassDef(StEmcMicroEvent,1)
};
 
#endif