StEmcFilter.h

#ifndef StEmcFilter_HH
#define StEmcFilter_HH
#include "BetheBloch.h"
#include "tables/St_emcStatus_Table.h"
#include "tables/St_smdStatus_Table.h"
#include <Stiostream.h>

#define NTOWER 4800

class StEvent;
class StTrack;
class StV0Vertex;
class StMcTrack;
class StMcEvent;
class StEmcGeom;
class StEmcPosition;
class StPionPlus;
class StPionMinus;
class StProton;
class StAntiProton;
class StKaonPlus;
class StKaonMinus;
class StElectron;
class StPositron;

enum McCharge   { kNEGATIVE = -1, kNEUTRAL = 0, kPOSITIVE = 1, kCHARGED = 2, kALL = 3 };
enum EmcStatus  { kBAD = 0, kGOOD = 1, kOTHER = 2};

class StEmcFilter: public TObject
{
  private:
    StEmcGeom*      mGeo[4]; 
    StEmcPosition*  mEmcPosition; 
    StPionPlus*     mPion; 
    StProton*       mProton;
    StKaonPlus*     mKaon;
    StElectron*     mElectron;
    BetheBloch      mBB;

    Float_t         mPtTower[NTOWER];
    Float_t         mETower[NTOWER];
    Int_t           mNTracksTower[NTOWER];
    Int_t           mCentralityBin;
    Int_t           mCentrality[10];

    // status tables
    St_emcStatus*   mBemcRunning;
    St_emcStatus*   mBemcRunningOrig;
    St_emcStatus*   mBprsRunning;
    St_smdStatus*   mBsmdeRunning;
    St_smdStatus*   mBsmdpRunning;

    // event cuts (only ZVertex is applied to McEvent for a while)
    Bool_t          mPrintLog;       
    Bool_t          mEmcPresent;     
    Bool_t          mHaveVertex;     
    Bool_t          mHavePrimaries;  
    Float_t         mZVertexCut;     
    Float_t         mEmcETotalMin;   
    Float_t         mEmcETotalMax;   
    Float_t         mMinMult;        
    Float_t         mMaxMult;        
    Float_t         mBField;         
    UInt_t          mTriggerMask[30];
    UInt_t          mNTriggerMask;

    // tracks cuts
    Float_t         mDCACut;         
    Float_t         mPtCut;      
                Float_t         mPtCutMax;    
    Float_t         mEtaMin;         
    Float_t         mEtaMax;         
    Int_t           mFitPointsCut;   
    Bool_t          mMustProjectEmc; 

    // dE/dX cuts
    Float_t         mdEdXScale;      
    Int_t           mPointsdEdX;     
    Float_t         mdEdXPMax;       
    Float_t         mdEdXCut;        
    Float_t         mdEdXNSigma;  

    // V0 Vertex cuts
    Float_t         mV0Pt;
    Bool_t          mV0TrackProjectOnEmc;

    // EMC tower cuts
    Int_t           mMaxTracksPerTower;
    Float_t         mEMin;
    Float_t         mEMax;
    Float_t         mPtMin;
    Float_t         mPtMax;
    Bool_t          mPNeighbor;
    Bool_t          mSNeighbor;
    Bool_t          mTNeighbor;  

    // MC Tracks cuts 
    Bool_t          mOnlyHadrons;        
    McCharge        mMcChargeType;       
    Bool_t          mMcMustProjectEmc;   
    Float_t         mMcPtCut;            
    Float_t         mMcEtaMin;           
    Float_t         mMcEtaMax;           

    void            calcCentrality(StEvent*); 

  public:
                                StEmcFilter(Int_t = 0);               
                                ~StEmcFilter();                       

    void                        initEmcTowers(StEvent*,Int_t=0);      
 
    Bool_t                      accept(StEvent*);                     
    Bool_t                      accept(StTrack*);                     
    Bool_t                      accept(StMcEvent*);                   
    Bool_t                      accept(StMcTrack*);                   
    Bool_t                      accept(StV0Vertex*);                  
    Bool_t                      accept(Int_t);                        
    Bool_t                      accept(Int_t,Int_t,Int_t);            

    Int_t                       getNTracksTower(Int_t);               
    Int_t                       getNTracksTower(Int_t,Int_t,Int_t);   

    Float_t                     getPtTower(Int_t);                    
    Float_t                     getPtTower(Int_t,Int_t,Int_t);        

    EmcStatus                   getEmcStatus(Int_t,Int_t);            

    Int_t           getCentralityBin() { return mCentralityBin; } 
    Int_t           getCentrality(Int_t i) { return mCentrality[i]; } 

    Bool_t                      getTrackId(StTrack*,Float_t&,Int_t&); 
    Bool_t                      getTrackId(StTrack*,Int_t&,Float_t&,Float_t&,Int_t&,Int_t*,Float_t*); 
    Float_t                     getEmcETotal(StEvent*);               

    Float_t                     getFraction(Int_t,Int_t,Int_t=0);     
    Float_t                     getWestFraction(Int_t=1);             
    Float_t                     getEastFraction(Int_t=1);             
    Float_t                     getTotalFraction(Int_t=1);            

    St_emcStatus*   getBemcStatus()          { return mBemcRunning; }   
    St_emcStatus*   getBprsStatus()          { return mBprsRunning; }   
    St_smdStatus*   getBsmdeStatus()         { return mBsmdeRunning; }  
    St_smdStatus*   getBsmdpStatus()         { return mBsmdpRunning; }  

    // get event cuts 
    Bool_t              getEmcPresent()          { return mEmcPresent; }     
    Bool_t              getHaveVertex()          { return mHaveVertex; }     
    Bool_t              getHavePrimaries()       { return mHavePrimaries; }  
    Float_t             getZVertexCut()          { return mZVertexCut; }     
    Float_t             getEmcETotalMin()        { return mEmcETotalMin; }   
    Float_t             getEmcETotalMax()        { return mEmcETotalMax; }   
    Float_t             getMinMult()             { return mMinMult; }        
    Float_t             getMaxMult()             { return mMaxMult; }        
    Float_t             getBField()              { return mBField; }         

    // get tracks cuts
    Float_t             getDCACut()              { return mDCACut; }         
    Float_t             getPtCut()               { return mPtCut; }          
    Float_t             getPtCutMax()            { return mPtCutMax; }       
    Float_t             getEtaMin()              { return mEtaMin; }         
    Float_t             getEtaMax()              { return mEtaMax; }         
    Int_t               getFitPointsCut()        { return mFitPointsCut; }   
    Bool_t              getMustProjectEmc()      { return mMustProjectEmc; } 

    // get dE/dX cuts
    Float_t             getdEdXScale()           { return mdEdXScale; }      
    Int_t                       getPointsdEdX()          { return mPointsdEdX; }     
    Float_t             getdEdXPMax()            { return mdEdXPMax; }       
    Float_t             getdEdXCut()             { return mdEdXCut; }        
    Float_t             getdEdXNSigma()          { return mdEdXNSigma; }     

    // get V0 Vertex cuts
    Float_t             getV0Pt()                { return mV0Pt; }                
    Bool_t                      getV0TrackProjectOnEmc() { return mV0TrackProjectOnEmc; } 

    // get EMC tower cuts
    Int_t                       getMaxTracksPerTower()   { return mMaxTracksPerTower; }   
    Float_t             getEMin()                { return mEMin; }                
    Float_t             getEMax()                { return mEMax; }                
    Float_t             getPtMin()               { return mPtMin; }               
    Float_t             getPtMax()               { return mPtMax; }               
    Bool_t              getPNeighbor()           { return mPNeighbor; }           
    Bool_t              getSNeighbor()           { return mSNeighbor; }           
    Bool_t              getTNeighbor()           { return mTNeighbor; }           

    // get MC Tracks cuts 
    Bool_t              getOnlyHadrons()         { return mOnlyHadrons; }        
    McCharge        getMcChargeType()        { return mMcChargeType; }       
    Bool_t              getMcMustProjectEmc()    { return mMcMustProjectEmc; }   
    Float_t             getMcPtCut()             { return mMcPtCut; }            
    Float_t             getMcEtaMin()            { return mMcEtaMin; }           
    Float_t             getMcEtaMax()            { return mMcEtaMax; }           

    void                        printCuts();                          

    void                        setBemcStatus(St_emcStatus* st)   { mBemcRunning = st; }   
    void                        setBprsStatus(St_emcStatus* st)   { mBprsRunning = st; }   
    void                        setBsmdeStatus(St_smdStatus* st)  { mBsmdeRunning = st; }  
    void                        setBsmdpStatus(St_smdStatus* st)  { mBsmdpRunning = st; }  

    // set event cuts (only ZVertex is applied to McEvent for a while)
    void                        setPrintLog(Bool_t a)             { mPrintLog = a; }       
    void                        setEmcPresent(Bool_t a)           { mEmcPresent = a; }     
    void                        setHaveVertex(Bool_t a)           { mHaveVertex = a; }     
    void                        setHavePrimaries(Bool_t a)        { mHavePrimaries = a; }  
    void                        setZVertexCut(Float_t a)          { mZVertexCut = a; }     
    void                        setEmcETotalMin(Float_t a)        { mEmcETotalMin = a; }   
    void                        setEmcETotalMax(Float_t a)        { mEmcETotalMax = a; }   
    void                        setMinMult(Float_t a)             { mMinMult = a; }        
    void                        setMaxMult(Float_t a)             { mMaxMult = a; }        
    void                        setBField(Float_t a)              { mBField = a; }         
    void                        addTriggerMask(UInt_t mask)       { mTriggerMask[mNTriggerMask++] = mask; } 
    void                        clearTriggerMask()                { mNTriggerMask = 0; }   

    // set tracks cuts
    void                        setDCACut(Float_t a)              { mDCACut = a; }         
    void                        setPtCut(Float_t a)               { mPtCut = a; }          
    void                        setPtCutMax(Float_t a)            { mPtCutMax = a; }       
    void                        setEtaMin(Float_t a)              { mEtaMin = a; }         
    void                        setEtaMax(Float_t a)              { mEtaMax = a; }         
    void                        setFitPointsCut(Int_t a)          { mFitPointsCut = a; }   
    void                        setMustProjectEmc(Bool_t a)       { mMustProjectEmc = a; } 

    // set dE/dX cuts
    void                        setdEdXScale(Float_t a)           { mdEdXScale = a; }      
    void                        setPointsdEdX(Int_t a)            { mPointsdEdX = a; }     
    void                        setdEdXPMax(Float_t a)            { mdEdXPMax = a; }       
    void                        setdEdXCut(Float_t a)             { mdEdXCut = a; }        
    void                        setdEdXNSigma(Float_t a)          { mdEdXNSigma = a; }     

    // set V0 Vertex cuts
    void                        setV0Pt(Float_t a)                { mV0Pt = a; }                
    void                        setV0TrackProjectOnEmc(Bool_t a)  { mV0TrackProjectOnEmc = a; } 

    // set EMC tower cuts
    void                        setMaxTracksPerTower(Int_t a)     { mMaxTracksPerTower = a; }   
    void                        setEMin(Float_t a)                { mEMin = a; }                
    void                        setEMax(Float_t a)                { mEMax = a; }                
    void                        setPtMin(Float_t a)               { mPtMin = a; }               
    void                        setPtMax(Float_t a)               { mPtMax = a; }               
    void                        setPNeighbor(Bool_t a)            { mPNeighbor = a; }           
    void                        setSNeighbor(Bool_t a)            { mSNeighbor = a; }           
    void                        setTNeighbor(Bool_t a)            { mTNeighbor = a; }           

    // set MC Tracks cuts 
    void                        setOnlyHadrons(Bool_t a)          { mOnlyHadrons = a; }        
    void                        setMcChargeType(McCharge a)       { mMcChargeType = a; }       
    void                        setMcMustProjectEmc(Bool_t a)     { mMcMustProjectEmc = a; }   
    void                        setMcPtCut(Float_t a)             { mMcPtCut = a; }            
    void                        setMcEtaMin(Float_t a)            { mMcEtaMin = a; }           
    void                        setMcEtaMax(Float_t a)            { mMcEtaMax = a; }           


    ClassDef(StEmcFilter,0)

};
#endif