[u/mrichter/AliRoot.git] / PWGHF / hfe / AliHFEcuts.h

/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/
//
// Cut container class for the ALICE HFE group
// Serves also as interface to the correction Framework
// Provides a set of standard cuts
//
#ifndef ALIHFECUTS_H
#define ALIHFECUTS_H

#ifndef ROOT_TNamed
#include <TNamed.h>
#endif

#ifndef ALIHFEEXTRACUTS_H
#include "AliHFEextraCuts.h"
#endif

class AliCFManager;
class AliESDtrack;
class AliMCEvent;
class AliMCParticle;
class AliVEvent;

class TObjArray;
class TList;

class AliHFEcuts : public TNamed{
  public:
    typedef enum{
      kStepRecNoCut = 0,
      kStepRecKineITSTPC = 1,
      kStepRecPrim = 2,
      kStepHFEcutsITS = 3,
      kStepHFEcutsTOF = 4,
      kStepHFEcutsTPC = 5,
      kStepHFEcutsTRD = 6,
      kNcutStepsRecTrack = 7
    } RecoCutStep_t;
    typedef enum{
      kStepHFEcutsDca = 0, 
      kNcutStepsDETrack = 1
    } DECutStep_t;
    typedef enum{
      kStepHFEcutsSecvtx = 0, 
      kNcutStepsSecvtxTrack = 1
    } SecvtxCutStep_t;
    typedef enum{
      kStepMCGenerated = 0,
      kStepMCGeneratedZOutNoPileUpCentralityFine = 1,
      kStepMCGeneratedEventCut = 2,
      kStepMCInAcceptance = 3,
      kNcutStepsMCTrack =  4
    } MCCutStep_t;
    typedef enum{
      kEventStepGenerated = 0,
      kEventStepRecNoCut = 1,
      kEventStepRecNoPileUp = 2,
      kEventStepRecCentralityOk = 3,
      kEventStepZRange = 4,
      kEventStepReconstructed = 5,
      kNcutStepsEvent = 6
    } EventCutStep_t;

    AliHFEcuts();
    AliHFEcuts(const Char_t *name, const Char_t *title);
    AliHFEcuts(const AliHFEcuts &c);
    AliHFEcuts &operator=(const AliHFEcuts &c);
    void Copy(TObject &o) const;
    Long64_t Merge(const TCollection *list);
    ~AliHFEcuts();
    
    void Initialize(AliCFManager *cfm);
    void Initialize();

    Bool_t CheckParticleCuts(UInt_t step, TObject *o);
    Bool_t CheckEventCuts(const char*namestep, TObject *o);
    void SetRecEvent(const AliVEvent *ev);
    void SetMCEvent(const AliVEvent *ev);
  
    TList *GetQAhistograms() const { return fHistQA; }
    
    void SetQAOn() {SetBit(kDebugMode, kTRUE); };
    void UnsetQA() {SetBit(kDebugMode, kFALSE); };
    Bool_t IsQAOn() const { return TestBit(kDebugMode); };
    void SetAOD() { SetBit(kAOD, kTRUE); }
    void SetESD() { SetBit(kAOD, kFALSE); }
    Bool_t IsAOD() const { return TestBit(kAOD); }
    Bool_t IsESD() const { return !TestBit(kAOD); }

    // Cut Names
    static const Char_t *MCCutName(UInt_t step){
      if(step >= kNcutStepsMCTrack) return fgkUndefined;
      return fgkMCCutName[step];
    };
    static const Char_t *RecoCutName(UInt_t step){
      if(step >= kNcutStepsRecTrack) return fgkUndefined;
      return fgkRecoCutName[step];
    }
    static const Char_t *DECutName(UInt_t step){
      if(step >= kNcutStepsDETrack) return fgkUndefined;
      return fgkDECutName[step];
    }
    static const Char_t *SecvtxCutName(UInt_t step){
      if(step >= kNcutStepsSecvtxTrack) return fgkUndefined;
      return fgkSecvtxCutName[step];
    }
    static const Char_t *EventCutName(UInt_t step){
      if(step >= kNcutStepsEvent) return fgkUndefined;
      return fgkEventCutName[step];
    }
   
    // Getters
    Bool_t IsRequireITSpixel() const { return TESTBIT(fRequirements, kITSPixel); };
    Bool_t IsRequireITSdrift() const { return TESTBIT(fRequirements, kITSDrift); };
    Bool_t IsRequireMaxImpactParam() const { return TESTBIT(fRequirements, kMaxImpactParam); };
    Bool_t IsRequirePrimary() const { return TESTBIT(fRequirements, kPrimary); };
    Bool_t IsRequireProdVertex() const { return TESTBIT(fRequirements, kProductionVertex); };
    Bool_t IsRequireSigmaToVertex() const { return TESTBIT(fRequirements, kSigmaToVertex); };
    Bool_t IsRequireDCAToVertex() const {return TESTBIT(fRequirements, kDCAToVertex); };
    Bool_t IsRequireKineMCCuts() const {return TESTBIT(fRequirements, kKineMCCuts); };
    Double_t GetVertexRange() const {return fVertexRangeZ; };
    Int_t GetMinTrackletsTRD() const { return fMinTrackletsTRD; }
    Bool_t GetUseMixedVertex() const { return fUseMixedVertex;};   
    
    // Setters
    inline void SetCutITSpixel(UChar_t cut);
    inline void SetCutITSdrift(UChar_t cut);
    void SetCheckITSLayerStatus(Bool_t checkITSLayerStatus) { fCheckITSLayerStatus = checkITSLayerStatus; }
    void SetMinNClustersTPC(UChar_t minClustersTPC) { fMinClustersTPC = minClustersTPC; }
    void SetMinNClustersTPCPID(UChar_t minClustersTPC) { fMinClustersTPCPID = minClustersTPC; }
    void SetMinNClustersITS(UChar_t minClustersITS) { fMinClustersITS = minClustersITS; }
    void SetMinNTrackletsTRD(UChar_t minNtrackletsTRD, Bool_t exact = kFALSE) { fMinTrackletsTRD = minNtrackletsTRD; fTRDtrackletsExact = exact; }
    void SetMaxChi2perTrackletTRD(Float_t maxchi2trackletTRD) { fMaxChi2TRD = maxchi2trackletTRD; }
    void SetMaxChi2perClusterITS(Double_t chi2) { fMaxChi2clusterITS = chi2; };
    void SetMaxChi2perClusterTPC(Double_t chi2) { fMaxChi2clusterTPC = chi2; };
    inline void SetMaxImpactParam(Double_t radial, Double_t z);
    inline void SetIPcutParam(Float_t p0, Float_t p1, Float_t p2, Float_t p3, Bool_t isIPcharge, Bool_t isipsigma, Bool_t isopp);
    void SetMinRatioTPCclusters(Double_t minRatioTPC) { fMinClusterRatioTPC = minRatioTPC; };
    void SetPtRange(Double_t ptmin, Double_t ptmax){fPtRange[0] = ptmin; fPtRange[1] = ptmax;};
    void SetTOFsignaldxz(Double_t tofsignaldx, Double_t tofsignaldz){fTOFsignaldx = tofsignaldx; fTOFsignaldz = tofsignaldz;};
    void SetAODFilterBit(Int_t bit) { fAODFilterBit = bit; };
    inline void SetProductionVertex(Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax);
    inline void SetSigmaToVertex(Double_t sig);
    inline void SetSigmaToVertexXY(Double_t sig);
    inline void SetSigmaToVertexZ(Double_t sig);
    void SetTPCmodes(UChar_t clusterDef, UChar_t ratioDef) {
      fTPCclusterDef= clusterDef;
      fTPCratioDef = ratioDef;
    }
    void SetEtaRange(Double_t etaRange){fEtaRange = etaRange;};
    void SetVertexRange(Double_t zrange){fVertexRangeZ = zrange;};
    void SetTOFPIDStep(Bool_t tofPidStep) {fTOFPIDStep = tofPidStep;};
    void SetTOFMISMATCHStep(Bool_t tofMismatchStep) {fTOFMISMATCHStep = tofMismatchStep;};
    void SetTPCPIDCleanUpStep(Bool_t tpcPIDCleanUpStep) {fTPCPIDCLEANUPStep = tpcPIDCleanUpStep;};
    void SetITSpatternCut() { fITSpatternCut = kTRUE; }
    inline void SetUseMixedVertex(Bool_t useMixedVertex);    
    inline void SetUseSPDVertex(Bool_t useSPDVertex);
    void SetUseCorrelationVertex() { fUseCorrelationVertex = kTRUE;};
    void SetSPDVtxResolutionCut() {fSPDVtxResolution = kTRUE;}
    void SetFractionOfSharedTPCClusters(Double_t fractionOfSharedTPCClusters) {fFractionOfSharedTPCClusters = fractionOfSharedTPCClusters;};
    void SetMaxImpactParameterRpar(Bool_t maxImpactParameterRpar) { fMaxImpactParameterRpar = maxImpactParameterRpar; };
    
    inline void CreateStandardCuts();
    
    // Requirements
    void SetAdditionalStatusRequirement(Long_t requirement) {fAdditionalStatusRequirement = requirement;}
    void SetRequireDCAToVertex() { SETBIT(fRequirements, kDCAToVertex); CLRBIT(fRequirements, kSigmaToVertex); };
    void SetRequireIsPrimary() { SETBIT(fRequirements, kPrimary); };
    void SetRequireITSPixel() { SETBIT(fRequirements, kITSPixel); }
    void SetRequireITSDrift() { SETBIT(fRequirements, kITSDrift); }
    void UnsetRequireITSPixel() { CLRBIT(fRequirements, kITSPixel); }
    void SetRequireProdVertex() { SETBIT(fRequirements, kProductionVertex); };
    void SetRequireSigmaToVertex() { SETBIT(fRequirements, kSigmaToVertex); CLRBIT(fRequirements, kDCAToVertex); };
    void UnsetVertexRequirement() { CLRBIT(fRequirements, kDCAToVertex); CLRBIT(fRequirements, kSigmaToVertex); }
    void SetRequireKineMCCuts() { SETBIT(fRequirements, kKineMCCuts); };

    void SetDebugLevel(Int_t level) { fDebugLevel = level; };
    Int_t GetDebugLevel() const { return fDebugLevel; };

  private:
    enum{
      kDebugMode = BIT(14),
      kAOD = BIT(15)
    };
    typedef enum{
      kPrimary = 0,
      kProductionVertex = 1,
      kSigmaToVertex = 2,
      kDCAToVertex = 3,
      kITSPixel = 4,
      kMaxImpactParam = 5,
      kKineMCCuts = 6,
      kITSDrift = 7
    } Require_t;
    void SetParticleGenCutList();
    void SetAcceptanceCutList();
    void SetRecKineITSTPCCutList();
    void SetRecPrimaryCutList();
    void SetHFElectronITSCuts();
    void SetHFElectronTOFCuts();
    void SetHFElectronTPCCuts();
    void SetHFElectronTRDCuts();
    void SetHFElectronDcaCuts();
    void SetEventCutList(Int_t istep);

    static const Char_t* fgkMCCutName[kNcutStepsMCTrack];     // Cut step names for MC single Track cuts
    static const Char_t* fgkRecoCutName[kNcutStepsRecTrack];  // Cut step names for Rec single Track cuts
    static const Char_t* fgkDECutName[kNcutStepsDETrack];     // Cut step names for impact parameter cuts
    static const Char_t* fgkSecvtxCutName[kNcutStepsSecvtxTrack];     // Cut step names for secondary vertexing cuts
    static const Char_t* fgkEventCutName[kNcutStepsEvent];    // Cut step names for Event cuts
    static const Char_t* fgkUndefined;                        // Name for undefined (overflow)
  
    ULong64_t fRequirements;  	  // Bitmap for requirements
    UChar_t   fTPCclusterDef;       // TPC cluster definition
    UChar_t   fTPCratioDef;             // TPC cluster ratio Definition
    Double_t fEtaRange;               // Eta range
    Double_t fDCAtoVtx[2];	      // DCA to Vertex
    Double_t fProdVtx[4];	        // Production Vertex
    Double_t fPtRange[2];	        // pt range
    UChar_t fMinClustersTPC;	    // Min.Number of TPC clusters
    UChar_t fMinClustersTPCPID;	  // Min.Number of TPC clusters
    UChar_t fMinClustersITS;	    // Min.Number of TPC clusters
    UChar_t fMinTrackletsTRD;	    // Min. Number of TRD tracklets
    Float_t fMaxChi2TRD;                // Max. Chi2 per TRD tracklet
    UChar_t fCutITSPixel;	        // Cut on ITS pixel
    Bool_t  fCheckITSLayerStatus;       // Check ITS layer status
    UChar_t fCutITSDrift;	        // Cut on ITS drift
    Double_t fMaxChi2clusterITS;	// Max Chi2 per ITS cluster
    Double_t fMaxChi2clusterTPC;	// Max Chi2 per TPC cluster
    Double_t fMinClusterRatioTPC;	// Min. Ratio findable / found TPC clusters
    Double_t fSigmaToVtx[3];	    // Sigma To Vertex
    Double_t fVertexRangeZ;             // Vertex Range reconstructed
    Bool_t   fTRDtrackletsExact;        // Require exact number of tracklets
    Bool_t   fTOFPIDStep;               // TOF matching step efficiency
    Bool_t   fTOFMISMATCHStep;        // TOF mismatch step
    Bool_t   fTPCPIDCLEANUPStep;      // TPC PIC cleanup step
    Bool_t   fITSpatternCut;          // Cut on ITS pattern
    Bool_t   fUseMixedVertex;         // Use primary vertex from track if there otherwise SPD vertex
    Bool_t   fUseSPDVertex;           // Use primary SPD vertex 
    Bool_t   fUseCorrelationVertex;   // Use the correlation of the vertex in z
    Bool_t   fSPDVtxResolution;       // Check resolution of the SPD vertex
    Float_t  fIPCutParams[4];         // Parameters of impact parameter cut parametrization
    Bool_t   fIsIPSigmacut;           // if IP cut or IP sigma cut 
    Bool_t   fIsIPcharge;             // if cut on IP * charge (cut using only positive side of distribution, to eliminate conversions)
    Bool_t   fIsIPOpp;                // if IP*charge cut on side of the photon peak
    Double_t fFractionOfSharedTPCClusters; // Fraction of shared TPC clusters
    Bool_t   fMaxImpactParameterRpar;      // Max impact parameter
    Long_t   fAdditionalStatusRequirement; // Additional status bit requirement 
    Double_t fTOFsignaldx;                 // TOF signal Dx
    Double_t fTOFsignaldz;                 // TOF signal Dz
    Int_t    fAODFilterBit;                // AOD Filter Bit Number
    
    TList *fHistQA;		            //! QA Histograms
    TObjArray *fCutList;	        //! List of cut objects(Correction Framework Manager)

    Int_t fDebugLevel;            // Debug Level
    
  ClassDef(AliHFEcuts, 5)         // Container for HFE cuts
};

//__________________________________________________________________
void AliHFEcuts::SetProductionVertex(Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax){
  // Set the production vertex constraint
  SetRequireProdVertex();
  fProdVtx[0] = xmin;
  fProdVtx[1] = xmax;
  fProdVtx[2] = ymin;
  fProdVtx[3] = ymax;
}

//__________________________________________________________________
void AliHFEcuts::SetSigmaToVertex(Double_t sig){
  SetRequireSigmaToVertex();
  fSigmaToVtx[0] = sig;
}

//__________________________________________________________________
void AliHFEcuts::SetSigmaToVertexXY(Double_t sig){
  SetRequireSigmaToVertex();
  fSigmaToVtx[1] = sig;
}

//__________________________________________________________________
void AliHFEcuts::SetSigmaToVertexZ(Double_t sig){
  SetRequireSigmaToVertex();
  fSigmaToVtx[2] = sig;
}

//__________________________________________________________________
void AliHFEcuts::SetMaxImpactParam(Double_t radial, Double_t z){
  SetRequireDCAToVertex();
  fDCAtoVtx[0] = radial;
  fDCAtoVtx[1] = z;
}

//__________________________________________________________________
void AliHFEcuts::SetIPcutParam(Float_t p0, Float_t p1, Float_t p2, Float_t p3, Bool_t isipsigma, Bool_t isIPcharge, Bool_t isopp){
  // Set parameters for impact parameter cut parametrization
  fIPCutParams[0] = p0;
  fIPCutParams[1] = p1;
  fIPCutParams[2] = p2;
  fIPCutParams[3] = p3;
  fIsIPSigmacut = isipsigma;
  fIsIPcharge = isIPcharge;
  fIsIPOpp = isopp;
}

//__________________________________________________________________
void AliHFEcuts::SetCutITSpixel(UChar_t cut){
  SetRequireITSPixel();
  fCutITSPixel = cut;
}

//__________________________________________________________________
void AliHFEcuts::SetCutITSdrift(UChar_t cut){
  SetRequireITSDrift();
  fCutITSDrift = cut;
}
//__________________________________________________________________
void AliHFEcuts::SetUseMixedVertex(Bool_t useMixedVertex){
  //
  // Choice of a vertex
  //
  fUseMixedVertex = useMixedVertex;
  if(useMixedVertex) fUseSPDVertex = kFALSE;
}
//__________________________________________________________________
void AliHFEcuts::SetUseSPDVertex(Bool_t useSPDVertex){
  //
  // Choice of a vertex
  //
  fUseSPDVertex = useSPDVertex;
  if(useSPDVertex) fUseMixedVertex = kFALSE;
}

//__________________________________________________________________
void AliHFEcuts::CreateStandardCuts(){
  //
  // Standard Cuts defined by the HFE Group
  //
  SetRequireProdVertex();
  fProdVtx[0] = 0;
  fProdVtx[1] = 3;
  fProdVtx[2] = 0;
  fProdVtx[3] = 3;
  //SetRequireDCAToVertex();
  //fDCAtoVtx[0] = 0.5;
  //fDCAtoVtx[1] = 1.5;
  fMinClustersTPC = 80;
  fMinClustersITS = 4;
  fMinTrackletsTRD = 0;
  SetRequireITSPixel();
  fCutITSPixel = AliHFEextraCuts::kFirst;
  fMaxChi2clusterITS = -1.;
  fMaxChi2clusterTPC = 4.;
  fMinClusterRatioTPC = 0.6;
  fPtRange[0] = 0.1;
  fPtRange[1] = 20.;
  SetRequireKineMCCuts();
}
#endif
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15	//
	16	// Cut container class for the ALICE HFE group
	17	// Serves also as interface to the correction Framework
	18	// Provides a set of standard cuts
	19	//
	20	#ifndef ALIHFECUTS_H
	21	#define ALIHFECUTS_H
	22
	23	#ifndef ROOT_TNamed
	24	#include <TNamed.h>
	25	#endif
	26
	27	#ifndef ALIHFEEXTRACUTS_H
	28	#include "AliHFEextraCuts.h"
	29	#endif
	30
	31	class AliCFManager;
	32	class AliESDtrack;
	33	class AliMCEvent;
	34	class AliMCParticle;
	35	class AliVEvent;
	36
	37	class TObjArray;
	38	class TList;
	39
	40	class AliHFEcuts : public TNamed{
	41	public:
	42	typedef enum{
	43	kStepRecNoCut = 0,
	44	kStepRecKineITSTPC = 1,
	45	kStepRecPrim = 2,
	46	kStepHFEcutsITS = 3,
	47	kStepHFEcutsTOF = 4,
	48	kStepHFEcutsTPC = 5,
	49	kStepHFEcutsTRD = 6,
	50	kNcutStepsRecTrack = 7
	51	} RecoCutStep_t;
	52	typedef enum{
	53	kStepHFEcutsDca = 0,
	54	kNcutStepsDETrack = 1
	55	} DECutStep_t;
	56	typedef enum{
	57	kStepHFEcutsSecvtx = 0,
	58	kNcutStepsSecvtxTrack = 1
	59	} SecvtxCutStep_t;
	60	typedef enum{
	61	kStepMCGenerated = 0,
	62	kStepMCGeneratedZOutNoPileUpCentralityFine = 1,
	63	kStepMCGeneratedEventCut = 2,
	64	kStepMCInAcceptance = 3,
	65	kNcutStepsMCTrack = 4
	66	} MCCutStep_t;
	67	typedef enum{
	68	kEventStepGenerated = 0,
	69	kEventStepRecNoCut = 1,
	70	kEventStepRecNoPileUp = 2,
	71	kEventStepRecCentralityOk = 3,
	72	kEventStepZRange = 4,
	73	kEventStepReconstructed = 5,
	74	kNcutStepsEvent = 6
	75	} EventCutStep_t;
	76
	77	AliHFEcuts();
	78	AliHFEcuts(const Char_t name, const Char_t title);
	79	AliHFEcuts(const AliHFEcuts &c);
	80	AliHFEcuts &operator=(const AliHFEcuts &c);
	81	void Copy(TObject &o) const;
	82	Long64_t Merge(const TCollection *list);
	83	~AliHFEcuts();
	84
	85	void Initialize(AliCFManager *cfm);
	86	void Initialize();
	87
	88	Bool_t CheckParticleCuts(UInt_t step, TObject *o);
	89	Bool_t CheckEventCuts(const charnamestep, TObject o);
	90	void SetRecEvent(const AliVEvent *ev);
	91	void SetMCEvent(const AliVEvent *ev);
	92
	93	TList *GetQAhistograms() const { return fHistQA; }
	94
	95	void SetQAOn() {SetBit(kDebugMode, kTRUE); };
	96	void UnsetQA() {SetBit(kDebugMode, kFALSE); };
	97	Bool_t IsQAOn() const { return TestBit(kDebugMode); };
	98	void SetAOD() { SetBit(kAOD, kTRUE); }
	99	void SetESD() { SetBit(kAOD, kFALSE); }
	100	Bool_t IsAOD() const { return TestBit(kAOD); }
	101	Bool_t IsESD() const { return !TestBit(kAOD); }
	102
	103	// Cut Names
	104	static const Char_t *MCCutName(UInt_t step){
	105	if(step >= kNcutStepsMCTrack) return fgkUndefined;
	106	return fgkMCCutName[step];
	107	};
	108	static const Char_t *RecoCutName(UInt_t step){
	109	if(step >= kNcutStepsRecTrack) return fgkUndefined;
	110	return fgkRecoCutName[step];
	111	}
	112	static const Char_t *DECutName(UInt_t step){
	113	if(step >= kNcutStepsDETrack) return fgkUndefined;
	114	return fgkDECutName[step];
	115	}
	116	static const Char_t *SecvtxCutName(UInt_t step){
	117	if(step >= kNcutStepsSecvtxTrack) return fgkUndefined;
	118	return fgkSecvtxCutName[step];
	119	}
	120	static const Char_t *EventCutName(UInt_t step){
	121	if(step >= kNcutStepsEvent) return fgkUndefined;
	122	return fgkEventCutName[step];
	123	}
	124
	125	// Getters
	126	Bool_t IsRequireITSpixel() const { return TESTBIT(fRequirements, kITSPixel); };
	127	Bool_t IsRequireITSdrift() const { return TESTBIT(fRequirements, kITSDrift); };
	128	Bool_t IsRequireMaxImpactParam() const { return TESTBIT(fRequirements, kMaxImpactParam); };
	129	Bool_t IsRequirePrimary() const { return TESTBIT(fRequirements, kPrimary); };
	130	Bool_t IsRequireProdVertex() const { return TESTBIT(fRequirements, kProductionVertex); };
	131	Bool_t IsRequireSigmaToVertex() const { return TESTBIT(fRequirements, kSigmaToVertex); };
	132	Bool_t IsRequireDCAToVertex() const {return TESTBIT(fRequirements, kDCAToVertex); };
	133	Bool_t IsRequireKineMCCuts() const {return TESTBIT(fRequirements, kKineMCCuts); };
	134	Double_t GetVertexRange() const {return fVertexRangeZ; };
	135	Int_t GetMinTrackletsTRD() const { return fMinTrackletsTRD; }
	136	Bool_t GetUseMixedVertex() const { return fUseMixedVertex;};
	137
	138	// Setters
	139	inline void SetCutITSpixel(UChar_t cut);
	140	inline void SetCutITSdrift(UChar_t cut);
	141	void SetCheckITSLayerStatus(Bool_t checkITSLayerStatus) { fCheckITSLayerStatus = checkITSLayerStatus; }
	142	void SetMinNClustersTPC(UChar_t minClustersTPC) { fMinClustersTPC = minClustersTPC; }
	143	void SetMinNClustersTPCPID(UChar_t minClustersTPC) { fMinClustersTPCPID = minClustersTPC; }
	144	void SetMinNClustersITS(UChar_t minClustersITS) { fMinClustersITS = minClustersITS; }
	145	void SetMinNTrackletsTRD(UChar_t minNtrackletsTRD, Bool_t exact = kFALSE) { fMinTrackletsTRD = minNtrackletsTRD; fTRDtrackletsExact = exact; }
	146	void SetMaxChi2perTrackletTRD(Float_t maxchi2trackletTRD) { fMaxChi2TRD = maxchi2trackletTRD; }
	147	void SetMaxChi2perClusterITS(Double_t chi2) { fMaxChi2clusterITS = chi2; };
	148	void SetMaxChi2perClusterTPC(Double_t chi2) { fMaxChi2clusterTPC = chi2; };
	149	inline void SetMaxImpactParam(Double_t radial, Double_t z);
	150	inline void SetIPcutParam(Float_t p0, Float_t p1, Float_t p2, Float_t p3, Bool_t isIPcharge, Bool_t isipsigma, Bool_t isopp);
	151	void SetMinRatioTPCclusters(Double_t minRatioTPC) { fMinClusterRatioTPC = minRatioTPC; };
	152	void SetPtRange(Double_t ptmin, Double_t ptmax){fPtRange[0] = ptmin; fPtRange[1] = ptmax;};
	153	void SetTOFsignaldxz(Double_t tofsignaldx, Double_t tofsignaldz){fTOFsignaldx = tofsignaldx; fTOFsignaldz = tofsignaldz;};
	154	void SetAODFilterBit(Int_t bit) { fAODFilterBit = bit; };
	155	inline void SetProductionVertex(Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax);
	156	inline void SetSigmaToVertex(Double_t sig);
	157	inline void SetSigmaToVertexXY(Double_t sig);
	158	inline void SetSigmaToVertexZ(Double_t sig);
	159	void SetTPCmodes(UChar_t clusterDef, UChar_t ratioDef) {
	160	fTPCclusterDef= clusterDef;
	161	fTPCratioDef = ratioDef;
	162	}
	163	void SetEtaRange(Double_t etaRange){fEtaRange = etaRange;};
	164	void SetVertexRange(Double_t zrange){fVertexRangeZ = zrange;};
	165	void SetTOFPIDStep(Bool_t tofPidStep) {fTOFPIDStep = tofPidStep;};
	166	void SetTOFMISMATCHStep(Bool_t tofMismatchStep) {fTOFMISMATCHStep = tofMismatchStep;};
	167	void SetTPCPIDCleanUpStep(Bool_t tpcPIDCleanUpStep) {fTPCPIDCLEANUPStep = tpcPIDCleanUpStep;};
	168	void SetITSpatternCut() { fITSpatternCut = kTRUE; }
	169	inline void SetUseMixedVertex(Bool_t useMixedVertex);
	170	inline void SetUseSPDVertex(Bool_t useSPDVertex);
	171	void SetUseCorrelationVertex() { fUseCorrelationVertex = kTRUE;};
	172	void SetSPDVtxResolutionCut() {fSPDVtxResolution = kTRUE;}
	173	void SetFractionOfSharedTPCClusters(Double_t fractionOfSharedTPCClusters) {fFractionOfSharedTPCClusters = fractionOfSharedTPCClusters;};
	174	void SetMaxImpactParameterRpar(Bool_t maxImpactParameterRpar) { fMaxImpactParameterRpar = maxImpactParameterRpar; };
	175
	176	inline void CreateStandardCuts();
	177
	178	// Requirements
	179	void SetAdditionalStatusRequirement(Long_t requirement) {fAdditionalStatusRequirement = requirement;}
	180	void SetRequireDCAToVertex() { SETBIT(fRequirements, kDCAToVertex); CLRBIT(fRequirements, kSigmaToVertex); };
	181	void SetRequireIsPrimary() { SETBIT(fRequirements, kPrimary); };
	182	void SetRequireITSPixel() { SETBIT(fRequirements, kITSPixel); }
	183	void SetRequireITSDrift() { SETBIT(fRequirements, kITSDrift); }
	184	void UnsetRequireITSPixel() { CLRBIT(fRequirements, kITSPixel); }
	185	void SetRequireProdVertex() { SETBIT(fRequirements, kProductionVertex); };
	186	void SetRequireSigmaToVertex() { SETBIT(fRequirements, kSigmaToVertex); CLRBIT(fRequirements, kDCAToVertex); };
	187	void UnsetVertexRequirement() { CLRBIT(fRequirements, kDCAToVertex); CLRBIT(fRequirements, kSigmaToVertex); }
	188	void SetRequireKineMCCuts() { SETBIT(fRequirements, kKineMCCuts); };
	189
	190	void SetDebugLevel(Int_t level) { fDebugLevel = level; };
	191	Int_t GetDebugLevel() const { return fDebugLevel; };
	192
	193	private:
	194	enum{
	195	kDebugMode = BIT(14),
	196	kAOD = BIT(15)
	197	};
	198	typedef enum{
	199	kPrimary = 0,
	200	kProductionVertex = 1,
	201	kSigmaToVertex = 2,
	202	kDCAToVertex = 3,
	203	kITSPixel = 4,
	204	kMaxImpactParam = 5,
	205	kKineMCCuts = 6,
	206	kITSDrift = 7
	207	} Require_t;
	208	void SetParticleGenCutList();
	209	void SetAcceptanceCutList();
	210	void SetRecKineITSTPCCutList();
	211	void SetRecPrimaryCutList();
	212	void SetHFElectronITSCuts();
	213	void SetHFElectronTOFCuts();
	214	void SetHFElectronTPCCuts();
	215	void SetHFElectronTRDCuts();
	216	void SetHFElectronDcaCuts();
	217	void SetEventCutList(Int_t istep);
	218
	219	static const Char_t* fgkMCCutName[kNcutStepsMCTrack]; // Cut step names for MC single Track cuts
	220	static const Char_t* fgkRecoCutName[kNcutStepsRecTrack]; // Cut step names for Rec single Track cuts
	221	static const Char_t* fgkDECutName[kNcutStepsDETrack]; // Cut step names for impact parameter cuts
	222	static const Char_t* fgkSecvtxCutName[kNcutStepsSecvtxTrack]; // Cut step names for secondary vertexing cuts
	223	static const Char_t* fgkEventCutName[kNcutStepsEvent]; // Cut step names for Event cuts
	224	static const Char_t* fgkUndefined; // Name for undefined (overflow)
	225
	226	ULong64_t fRequirements; // Bitmap for requirements
	227	UChar_t fTPCclusterDef; // TPC cluster definition
	228	UChar_t fTPCratioDef; // TPC cluster ratio Definition
	229	Double_t fEtaRange; // Eta range
	230	Double_t fDCAtoVtx[2]; // DCA to Vertex
	231	Double_t fProdVtx[4]; // Production Vertex
	232	Double_t fPtRange[2]; // pt range
	233	UChar_t fMinClustersTPC; // Min.Number of TPC clusters
	234	UChar_t fMinClustersTPCPID; // Min.Number of TPC clusters
	235	UChar_t fMinClustersITS; // Min.Number of TPC clusters
	236	UChar_t fMinTrackletsTRD; // Min. Number of TRD tracklets
	237	Float_t fMaxChi2TRD; // Max. Chi2 per TRD tracklet
	238	UChar_t fCutITSPixel; // Cut on ITS pixel
	239	Bool_t fCheckITSLayerStatus; // Check ITS layer status
	240	UChar_t fCutITSDrift; // Cut on ITS drift
	241	Double_t fMaxChi2clusterITS; // Max Chi2 per ITS cluster
	242	Double_t fMaxChi2clusterTPC; // Max Chi2 per TPC cluster
	243	Double_t fMinClusterRatioTPC; // Min. Ratio findable / found TPC clusters
	244	Double_t fSigmaToVtx[3]; // Sigma To Vertex
	245	Double_t fVertexRangeZ; // Vertex Range reconstructed
	246	Bool_t fTRDtrackletsExact; // Require exact number of tracklets
	247	Bool_t fTOFPIDStep; // TOF matching step efficiency
	248	Bool_t fTOFMISMATCHStep; // TOF mismatch step
	249	Bool_t fTPCPIDCLEANUPStep; // TPC PIC cleanup step
	250	Bool_t fITSpatternCut; // Cut on ITS pattern
	251	Bool_t fUseMixedVertex; // Use primary vertex from track if there otherwise SPD vertex
	252	Bool_t fUseSPDVertex; // Use primary SPD vertex
	253	Bool_t fUseCorrelationVertex; // Use the correlation of the vertex in z
	254	Bool_t fSPDVtxResolution; // Check resolution of the SPD vertex
	255	Float_t fIPCutParams[4]; // Parameters of impact parameter cut parametrization
	256	Bool_t fIsIPSigmacut; // if IP cut or IP sigma cut
	257	Bool_t fIsIPcharge; // if cut on IP * charge (cut using only positive side of distribution, to eliminate conversions)
	258	Bool_t fIsIPOpp; // if IP*charge cut on side of the photon peak
	259	Double_t fFractionOfSharedTPCClusters; // Fraction of shared TPC clusters
	260	Bool_t fMaxImpactParameterRpar; // Max impact parameter
	261	Long_t fAdditionalStatusRequirement; // Additional status bit requirement
	262	Double_t fTOFsignaldx; // TOF signal Dx
	263	Double_t fTOFsignaldz; // TOF signal Dz
	264	Int_t fAODFilterBit; // AOD Filter Bit Number
	265
	266	TList *fHistQA; //! QA Histograms
	267	TObjArray *fCutList; //! List of cut objects(Correction Framework Manager)
	268
	269	Int_t fDebugLevel; // Debug Level
	270
	271	ClassDef(AliHFEcuts, 5) // Container for HFE cuts
	272	};
	273
	274	//__________________________________________________________________
	275	void AliHFEcuts::SetProductionVertex(Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax){
	276	// Set the production vertex constraint
	277	SetRequireProdVertex();
	278	fProdVtx[0] = xmin;
	279	fProdVtx[1] = xmax;
	280	fProdVtx[2] = ymin;
	281	fProdVtx[3] = ymax;
	282	}
	283
	284	//__________________________________________________________________
	285	void AliHFEcuts::SetSigmaToVertex(Double_t sig){
	286	SetRequireSigmaToVertex();
	287	fSigmaToVtx[0] = sig;
	288	}
	289
	290	//__________________________________________________________________
	291	void AliHFEcuts::SetSigmaToVertexXY(Double_t sig){
	292	SetRequireSigmaToVertex();
	293	fSigmaToVtx[1] = sig;
	294	}
	295
	296	//__________________________________________________________________
	297	void AliHFEcuts::SetSigmaToVertexZ(Double_t sig){
	298	SetRequireSigmaToVertex();
	299	fSigmaToVtx[2] = sig;
	300	}
	301
	302	//__________________________________________________________________
	303	void AliHFEcuts::SetMaxImpactParam(Double_t radial, Double_t z){
	304	SetRequireDCAToVertex();
	305	fDCAtoVtx[0] = radial;
	306	fDCAtoVtx[1] = z;
	307	}
	308
	309	//__________________________________________________________________
	310	void AliHFEcuts::SetIPcutParam(Float_t p0, Float_t p1, Float_t p2, Float_t p3, Bool_t isipsigma, Bool_t isIPcharge, Bool_t isopp){
	311	// Set parameters for impact parameter cut parametrization
	312	fIPCutParams[0] = p0;
	313	fIPCutParams[1] = p1;
	314	fIPCutParams[2] = p2;
	315	fIPCutParams[3] = p3;
	316	fIsIPSigmacut = isipsigma;
	317	fIsIPcharge = isIPcharge;
	318	fIsIPOpp = isopp;
	319	}
	320
	321	//__________________________________________________________________
	322	void AliHFEcuts::SetCutITSpixel(UChar_t cut){
	323	SetRequireITSPixel();
	324	fCutITSPixel = cut;
	325	}
	326
	327	//__________________________________________________________________
	328	void AliHFEcuts::SetCutITSdrift(UChar_t cut){
	329	SetRequireITSDrift();
	330	fCutITSDrift = cut;
	331	}
	332	//__________________________________________________________________
	333	void AliHFEcuts::SetUseMixedVertex(Bool_t useMixedVertex){
	334	//
	335	// Choice of a vertex
	336	//
	337	fUseMixedVertex = useMixedVertex;
	338	if(useMixedVertex) fUseSPDVertex = kFALSE;
	339	}
	340	//__________________________________________________________________
	341	void AliHFEcuts::SetUseSPDVertex(Bool_t useSPDVertex){
	342	//
	343	// Choice of a vertex
	344	//
	345	fUseSPDVertex = useSPDVertex;
	346	if(useSPDVertex) fUseMixedVertex = kFALSE;
	347	}
	348
	349	//__________________________________________________________________
	350	void AliHFEcuts::CreateStandardCuts(){
	351	//
	352	// Standard Cuts defined by the HFE Group
	353	//
	354	SetRequireProdVertex();
	355	fProdVtx[0] = 0;
	356	fProdVtx[1] = 3;
	357	fProdVtx[2] = 0;
	358	fProdVtx[3] = 3;
	359	//SetRequireDCAToVertex();
	360	//fDCAtoVtx[0] = 0.5;
	361	//fDCAtoVtx[1] = 1.5;
	362	fMinClustersTPC = 80;
	363	fMinClustersITS = 4;
	364	fMinTrackletsTRD = 0;
	365	SetRequireITSPixel();
	366	fCutITSPixel = AliHFEextraCuts::kFirst;
	367	fMaxChi2clusterITS = -1.;
	368	fMaxChi2clusterTPC = 4.;
	369	fMinClusterRatioTPC = 0.6;
	370	fPtRange[0] = 0.1;
	371	fPtRange[1] = 20.;
	372	SetRequireKineMCCuts();
	373	}
	374	#endif