[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliDalitzElectronCuts.h

#ifndef ALIDALITZELECTRONCUTS_H
#define ALIDALITZELECTRONCUTS_H

// Class handling all kinds of selection cuts for electrons

// Authors: Svein Lindal, Daniel Lohner												*


#include "AliAODpidUtil.h"
//#include "AliConversionPhotonBase.h"
//#include "AliAODConversionMother.h"
#include "AliAODTrack.h"
#include "AliESDtrack.h"
#include "AliVTrack.h"
#include "AliAODTrack.h"
#include "AliStack.h"
#include "AliAnalysisCuts.h"
#include "AliESDtrackCuts.h"
#include "TH1F.h"

class AliESDEvent;
class AliAODEvent;
class AliConversionPhotonBase;
class AliKFVertex;
class AliKFParticle;
class TH1F;
class TH2F;
class AliPIDResponse;
class AliAnalysisCuts;
class iostream;
class TList;
class AliAnalysisManager;


using namespace std;

class AliDalitzElectronCuts : public AliAnalysisCuts {
	
 public: 


  enum cutIds {
	kgoodId=0, 
        kededxSigmaITSCut,
        kededxSigmaTPCCut,
        kpidedxSigmaTPCCut,
        kpiMinMomdedxSigmaTPCCut,
        kpiMaxMomdedxSigmaTPCCut,
        kLowPRejectionSigmaCut,
        kTOFelectronPID,
        kclsITSCut,
        kclsTPCCut,
	ketaCut,
        kPsiPair,
        kRejectSharedElecGamma,
        kBackgroundScheme,
        kNumberOfRotations,
        kptCut,
        kDCACut,
        kmassCut,
        kWeights,
	kNCuts
  };


 enum electronCuts {
      kElectronIn=0,
      kNoTracks,
      kTrackCuts,
      kdEdxCuts,
      kElectronOut
 };


  Bool_t SetCutIds(TString cutString); 
  Int_t fCuts[kNCuts];
  Bool_t SetCut(cutIds cutID, Int_t cut);
  Bool_t UpdateCutString(cutIds cutID, Int_t value);
  static const char * fgkCutNames[kNCuts];


  Bool_t InitializeCutsFromCutString(const TString analysisCutSelection); 
  

  AliDalitzElectronCuts(const char *name="ElectronCuts", const char * title="Electron Cuts");
  virtual ~AliDalitzElectronCuts();                            //virtual destructor

  virtual Bool_t IsSelected(TObject* /*obj*/){return kTRUE;}
  virtual Bool_t IsSelected(TList* /*list*/) {return kTRUE;}

  TString GetCutNumber();

    // Cut Selection
  Bool_t ElectronIsSelectedMC(Int_t labelParticle,AliStack *fMCStack);
  Bool_t TrackIsSelected(AliESDtrack* lTrack);
  Bool_t ElectronIsSelected(AliESDtrack* lTrack);
  void InitAODpidUtil(Int_t type);
  static AliDalitzElectronCuts * GetStandardCuts2010PbPb();
  static AliDalitzElectronCuts * GetStandardCuts2010pp();
  Bool_t InitPIDResponse();
  
  void SetPIDResponse(AliPIDResponse * pidResponse) {fPIDResponse = pidResponse;}
  AliPIDResponse * GetPIDResponse() { return fPIDResponse;}
  
  void PrintCuts();

  void InitCutHistograms(TString name="",Bool_t preCut = kTRUE,TString cutName="");
  void SetFillCutHistograms(TString name="",Bool_t preCut = kTRUE,TString cutName=""){if(!fHistograms){InitCutHistograms(name,preCut,cutName);};}
  TList *GetCutHistograms(){return fHistograms;}

  static AliVTrack * GetTrack(AliVEvent * event, Int_t label);

  
  ///Cut functions
  Bool_t dEdxCuts(AliVTrack * track);
  Bool_t PIDProbabilityCut(AliConversionPhotonBase *photon, AliVEvent * event);
  Bool_t RejectSharedElecGamma(TList *photons, Int_t indexEle);
  Bool_t IsFromGammaConversion( Double_t psiPair, Double_t deltaPhi );
  Bool_t MassCut(Double_t pi0CandidatePt,Double_t vphotonCandidateMass);

  // Event Cuts

  //Double_t GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg );

  Bool_t SetTPCdEdxCutPionLine(Int_t pidedxSigmaCut);
  Bool_t SetTPCdEdxCutElectronLine(Int_t ededxSigmaCut);
  Bool_t SetITSdEdxCutElectronLine(Int_t ededxSigmaCut);
  Bool_t SetMinMomPiondEdxTPCCut(Int_t piMomdedxSigmaCut);
  Bool_t SetMaxMomPiondEdxTPCCut(Int_t piMomdedxSigmaCut);
  Bool_t SetITSClusterCut(Int_t clsITSCut);
  Bool_t SetTPCClusterCut(Int_t clsTPCCut);
  Bool_t SetEtaCut(Int_t etaCut);
  Bool_t SetPtCut(Int_t ptCut);
  Bool_t SetDCACut(Int_t dcaCut);
  void SetEtaShift(Double_t etaShift){fEtaShift = etaShift;}
  Bool_t SetMinMomPiondEdxCut(Int_t piMinMomdedxSigmaCut);
  Bool_t SetMaxMomPiondEdxCut(Int_t piMaxMomdedxSigmaCut);
  Bool_t SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut);
  Bool_t SetTOFElectronPIDCut(Int_t TOFelectronPID);
  Bool_t SetPsiPairCut(Int_t psiCut);
  Bool_t SetRejectSharedElecGamma(Int_t RCut);
  Bool_t SetBackgroundScheme(Int_t BackgroundScheme);
  Bool_t SetNumberOfRotations(Int_t NumberOfRotations);
  Bool_t SetMassCut(Int_t massCut);
  Bool_t SetDoWeights(Int_t opc);
  
  // Request Flags

  Double_t GetEtaCut(){ return  fEtaCut;}
  Double_t GetPsiPairCut(){ return fPsiPairCut; }
  Double_t DoRejectSharedElecGamma(){ return fDoRejectSharedElecGamma;}
  Double_t DoPsiPairCut(){return fDoPsiPairCut;}
  Double_t GetNFindableClustersTPC(AliESDtrack* lTrack);
  Bool_t   UseTrackMultiplicity(){ return fUseTrackMultiplicityForBG;}
  Int_t    GetBKGMethod(){ return fBKGMethod; }
  Int_t    NumberOfRotationEvents(){return fnumberOfRotationEventsForBG;}
  Bool_t   DoMassCut(){return  fDoMassCut;}
  Bool_t   DoMassMinCut(){return fDoMassMinCut;}
  Double_t GetMassCutLowPt(){return fMassCutLowPt;}
  Double_t GetMassCutHighPt(){return fMassCutHighPt;}
  Double_t GetPtMinMassCut(){return fMassCutPtMin;}
  Double_t GetMassMinCut(){return fMassMinCut;}
  Bool_t   DoWeights(){return fDoWeights;}
  

  protected:

  TList *fHistograms;
  AliPIDResponse *fPIDResponse;
  AliESDtrackCuts *fesdTrackCuts;

  Double_t fEtaCut; //eta cutç
  Double_t fEtaShift;
  Bool_t   fDoEtaCut;
  Double_t fPtMinCut;
  Double_t fPtMaxCut;
  Double_t fRadiusCut; // radius cut
  Double_t fPsiPairCut;
  Double_t fDeltaPhiCutMin;
  Double_t fDeltaPhiCutMax;
  Double_t fMinClsTPC; // minimum clusters in the TPC
  Double_t fMinClsTPCToF; // minimum clusters to findable clusters
  Bool_t   fDodEdxSigmaITSCut; // flag to use the dEdxCut ITS based on sigmas
  Bool_t   fDodEdxSigmaTPCCut; // flag to use the dEdxCut TPC based on sigmas
  Bool_t   fDoTOFsigmaCut; // flag to use TOF pid cut RRnewTOF
  Bool_t   fDoRejectSharedElecGamma; //Reject electrons from the gammas with Radius < RadiusCut
  Bool_t   fDoPsiPairCut; // PsiPair Cut
  Double_t fPIDnSigmaAboveElectronLineITS; // sigma cut
  Double_t fPIDnSigmaBelowElectronLineITS; // sigma cut
  Double_t fPIDnSigmaAboveElectronLineTPC; // sigma cut
  Double_t fPIDnSigmaBelowElectronLineTPC; // sigma cut
  Double_t fPIDnSigmaAbovePionLineTPC;
  Double_t fPIDnSigmaAbovePionLineTPCHighPt;
  Double_t fTofPIDnSigmaAboveElectronLine; // sigma cut RRnewTOF
  Double_t fTofPIDnSigmaBelowElectronLine; // sigma cut RRnewTOF 
  Double_t fPIDMinPnSigmaAbovePionLineTPC; // sigma cut
  Double_t fPIDMaxPnSigmaAbovePionLineTPC; // sigma cut
  Double_t fDoKaonRejectionLowP;   // Kaon rejection at low p
  Double_t fDoProtonRejectionLowP; // Proton rejection at low p
  Double_t fDoPionRejectionLowP;   // Pion rejection at low p
  Double_t fPIDnSigmaAtLowPAroundKaonLine; // sigma cut
  Double_t fPIDnSigmaAtLowPAroundProtonLine; // sigma cut
  Double_t fPIDnSigmaAtLowPAroundPionLine; // sigma cut
  Double_t fPIDMinPKaonRejectionLowP; // Momentum limit to apply kaon rejection
  Double_t fPIDMinPProtonRejectionLowP; // Momentum limit to apply proton rejection
  Double_t fPIDMinPPionRejectionLowP; // Momentum limit to apply proton rejection

  Bool_t   fUseCorrectedTPCClsInfo; // flag to use corrected tpc cl info
  Bool_t   fUseCrossedRows;  //UseCrossedRows 2011
  Bool_t   fUseTOFpid; // flag to use tof pid
  Bool_t   fRequireTOF; //flg to analyze only tracks with TOF signal
  Bool_t   fUseTrackMultiplicityForBG; // use multiplicity
  Int_t    fBKGMethod;
  Int_t    fnumberOfRotationEventsForBG;
  Bool_t   fDoMassCut;
  Bool_t   fDoMassMinCut;
  Double_t fMassCutLowPt;
  Double_t fMassCutHighPt;
  Double_t fMassCutPtMin;
  Double_t fMassMinCut;
  Bool_t   fDoWeights;


  // Histograms
  TObjString *fCutString; // cut number used for analysis
  TH1F *hCutIndex; // bookkeeping for cuts
  TH1F *hdEdxCuts;  // bookkeeping for dEdx cuts
  TH2F *hITSdEdxbefore; // ITS dEdx before cuts
  TH2F *hITSdEdxafter;
  TH2F *hTPCdEdxbefore; // TPC dEdx before cuts
  TH2F *hTPCdEdxafter; // TPC dEdx after cuts
  TH2F *hTPCdEdxSignalbefore; //TPC dEdx signal before
  TH2F *hTPCdEdxSignalafter; //TPC dEdx signal  after
  TH2F *hTOFbefore; // TOF after cuts
  TH2F *hTOFafter; // TOF after cuts
  TH2F *hTrackDCAxyPtbefore;
  TH2F *hTrackDCAxyPtafter;
  TH2F *hTrackDCAzPtbefore;
  TH2F *hTrackDCAzPtafter;
  TH2F *hTrackNFindClsPtTPCbefore;
  TH2F *hTrackNFindClsPtTPCafter;
  
  
private:

  AliDalitzElectronCuts(const AliDalitzElectronCuts&); // not implemented
  AliDalitzElectronCuts& operator=(const AliDalitzElectronCuts&); // not implemented


  ClassDef(AliDalitzElectronCuts,2)
};


inline void AliDalitzElectronCuts::InitAODpidUtil(Int_t type) {
  if (!fPIDResponse) fPIDResponse = new AliAODpidUtil();
  Double_t alephParameters[5];
  // simulation
  alephParameters[0] = 2.15898e+00/50.;
  alephParameters[1] = 1.75295e+01;
  alephParameters[2] = 3.40030e-09;
  alephParameters[3] = 1.96178e+00;
  alephParameters[4] = 3.91720e+00;
  fPIDResponse->GetTOFResponse().SetTimeResolution(80.);
  
  // data
  if (type==1){
    alephParameters[0] = 0.0283086/0.97;
    alephParameters[1] = 2.63394e+01;
    alephParameters[2] = 5.04114e-11;
    alephParameters[3] = 2.12543e+00;
    alephParameters[4] = 4.88663e+00;
    fPIDResponse->GetTOFResponse().SetTimeResolution(130.);
    fPIDResponse->GetTPCResponse().SetMip(50.);
  }
  
  fPIDResponse->GetTPCResponse().SetBetheBlochParameters(
    alephParameters[0],alephParameters[1],alephParameters[2],
    alephParameters[3],alephParameters[4]);
  
  fPIDResponse->GetTPCResponse().SetSigma(3.79301e-03, 2.21280e+04);
}


#endif
Commit	Line	Data
2bb2434e	1	#ifndef ALIDALITZELECTRONCUTS_H
	2	#define ALIDALITZELECTRONCUTS_H
	3
	4	// Class handling all kinds of selection cuts for electrons
	5
	6	// Authors: Svein Lindal, Daniel Lohner *
	7
	8
	9	#include "AliAODpidUtil.h"
	10	//#include "AliConversionPhotonBase.h"
	11	//#include "AliAODConversionMother.h"
	12	#include "AliAODTrack.h"
	13	#include "AliESDtrack.h"
	14	#include "AliVTrack.h"
	15	#include "AliAODTrack.h"
	16	#include "AliStack.h"
	17	#include "AliAnalysisCuts.h"
	18	#include "AliESDtrackCuts.h"
	19	#include "TH1F.h"
	20
	21	class AliESDEvent;
	22	class AliAODEvent;
	23	class AliConversionPhotonBase;
	24	class AliKFVertex;
	25	class AliKFParticle;
	26	class TH1F;
	27	class TH2F;
	28	class AliPIDResponse;
	29	class AliAnalysisCuts;
	30	class iostream;
	31	class TList;
	32	class AliAnalysisManager;
	33
	34
	35	using namespace std;
	36
	37	class AliDalitzElectronCuts : public AliAnalysisCuts {
	38
	39	public:
	40
	41
	42	enum cutIds {
	43	kgoodId=0,
	44	kededxSigmaITSCut,
	45	kededxSigmaTPCCut,
	46	kpidedxSigmaTPCCut,
	47	kpiMinMomdedxSigmaTPCCut,
	48	kpiMaxMomdedxSigmaTPCCut,
	49	kLowPRejectionSigmaCut,
	50	kTOFelectronPID,
0a2b2b4b	51	kclsITSCut,
2bb2434e	52	kclsTPCCut,
	53	ketaCut,
	54	kPsiPair,
	55	kRejectSharedElecGamma,
	56	kBackgroundScheme,
a280ac15	57	kNumberOfRotations,
ae947965	58	kptCut,
	59	kDCACut,
	60	kmassCut,
86eaf9ae	61	kWeights,
2bb2434e	62	kNCuts
	63	};
	64
	65
	66	enum electronCuts {
	67	kElectronIn=0,
	68	kNoTracks,
	69	kTrackCuts,
	70	kdEdxCuts,
	71	kElectronOut
	72	};
	73
	74
	75	Bool_t SetCutIds(TString cutString);
	76	Int_t fCuts[kNCuts];
	77	Bool_t SetCut(cutIds cutID, Int_t cut);
ae4f2cfb	78	Bool_t UpdateCutString(cutIds cutID, Int_t value);
2bb2434e	79	static const char * fgkCutNames[kNCuts];
	80
	81
	82	Bool_t InitializeCutsFromCutString(const TString analysisCutSelection);
	83
	84
	85	AliDalitzElectronCuts(const char name="ElectronCuts", const char title="Electron Cuts");
	86	virtual ~AliDalitzElectronCuts(); //virtual destructor
	87
	88	virtual Bool_t IsSelected(TObject* /obj/){return kTRUE;}
	89	virtual Bool_t IsSelected(TList* /list/) {return kTRUE;}
	90
	91	TString GetCutNumber();
	92
	93	// Cut Selection
ccfa8c0d	94	Bool_t ElectronIsSelectedMC(Int_t labelParticle,AliStack *fMCStack);
2bb2434e	95	Bool_t TrackIsSelected(AliESDtrack* lTrack);
	96	Bool_t ElectronIsSelected(AliESDtrack* lTrack);
	97	void InitAODpidUtil(Int_t type);
	98	static AliDalitzElectronCuts * GetStandardCuts2010PbPb();
	99	static AliDalitzElectronCuts * GetStandardCuts2010pp();
	100	Bool_t InitPIDResponse();
	101
	102	void SetPIDResponse(AliPIDResponse * pidResponse) {fPIDResponse = pidResponse;}
	103	AliPIDResponse * GetPIDResponse() { return fPIDResponse;}
	104
	105	void PrintCuts();
	106
a280ac15	107	void InitCutHistograms(TString name="",Bool_t preCut = kTRUE,TString cutName="");
a280ac15	108	void SetFillCutHistograms(TString name="",Bool_t preCut = kTRUE,TString cutName=""){if(!fHistograms){InitCutHistograms(name,preCut,cutName);};}
2bb2434e	109	TList *GetCutHistograms(){return fHistograms;}
	110
	111	static AliVTrack * GetTrack(AliVEvent * event, Int_t label);
	112
	113
	114
	115	///Cut functions
	116	Bool_t dEdxCuts(AliVTrack * track);
	117	Bool_t PIDProbabilityCut(AliConversionPhotonBase photon, AliVEvent event);
	118	Bool_t RejectSharedElecGamma(TList *photons, Int_t indexEle);
a280ac15	119	Bool_t IsFromGammaConversion( Double_t psiPair, Double_t deltaPhi );
4803eb1f	120	Bool_t MassCut(Double_t pi0CandidatePt,Double_t vphotonCandidateMass);
2bb2434e	121
	122	// Event Cuts
	123
a280ac15	124	//Double_t GetPsiPair( const AliESDtrack trackPos, const AliESDtrack trackNeg );
2bb2434e	125
	126	Bool_t SetTPCdEdxCutPionLine(Int_t pidedxSigmaCut);
	127	Bool_t SetTPCdEdxCutElectronLine(Int_t ededxSigmaCut);
	128	Bool_t SetITSdEdxCutElectronLine(Int_t ededxSigmaCut);
	129	Bool_t SetMinMomPiondEdxTPCCut(Int_t piMomdedxSigmaCut);
	130	Bool_t SetMaxMomPiondEdxTPCCut(Int_t piMomdedxSigmaCut);
0a2b2b4b	131	Bool_t SetITSClusterCut(Int_t clsITSCut);
2bb2434e	132	Bool_t SetTPCClusterCut(Int_t clsTPCCut);
2bb2434e	133	Bool_t SetEtaCut(Int_t etaCut);
ae947965	134	Bool_t SetPtCut(Int_t ptCut);
	135	Bool_t SetDCACut(Int_t dcaCut);
	136	void SetEtaShift(Double_t etaShift){fEtaShift = etaShift;}
2bb2434e	137	Bool_t SetMinMomPiondEdxCut(Int_t piMinMomdedxSigmaCut);
	138	Bool_t SetMaxMomPiondEdxCut(Int_t piMaxMomdedxSigmaCut);
	139	Bool_t SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut);
	140	Bool_t SetTOFElectronPIDCut(Int_t TOFelectronPID);
	141	Bool_t SetPsiPairCut(Int_t psiCut);
	142	Bool_t SetRejectSharedElecGamma(Int_t RCut);
	143	Bool_t SetBackgroundScheme(Int_t BackgroundScheme);
a280ac15	144	Bool_t SetNumberOfRotations(Int_t NumberOfRotations);
ae947965	145	Bool_t SetMassCut(Int_t massCut);
86eaf9ae	146	Bool_t SetDoWeights(Int_t opc);
2bb2434e	147
	148	// Request Flags
	149
	150	Double_t GetEtaCut(){ return fEtaCut;}
	151	Double_t GetPsiPairCut(){ return fPsiPairCut; }
	152	Double_t DoRejectSharedElecGamma(){ return fDoRejectSharedElecGamma;}
	153	Double_t DoPsiPairCut(){return fDoPsiPairCut;}
4803eb1f	154	Double_t GetNFindableClustersTPC(AliESDtrack* lTrack);
2bb2434e	155	Bool_t UseTrackMultiplicity(){ return fUseTrackMultiplicityForBG;}
2bb2434e	156	Int_t GetBKGMethod(){ return fBKGMethod; }
a280ac15	157	Int_t NumberOfRotationEvents(){return fnumberOfRotationEventsForBG;}
ae947965	158	Bool_t DoMassCut(){return fDoMassCut;}
258b4572	159	Bool_t DoMassMinCut(){return fDoMassMinCut;}
4803eb1f	160	Double_t GetMassCutLowPt(){return fMassCutLowPt;}
	161	Double_t GetMassCutHighPt(){return fMassCutHighPt;}
	162	Double_t GetPtMinMassCut(){return fMassCutPtMin;}
258b4572	163	Double_t GetMassMinCut(){return fMassMinCut;}
86eaf9ae	164	Bool_t DoWeights(){return fDoWeights;}
2bb2434e	165
	166
	167
	168	protected:
	169
	170	TList *fHistograms;
	171	AliPIDResponse *fPIDResponse;
	172	AliESDtrackCuts *fesdTrackCuts;
	173
	174	Double_t fEtaCut; //eta cutç
ae947965	175	Double_t fEtaShift;
ae947965	176	Bool_t fDoEtaCut;
78cea1d2	177	Double_t fPtMinCut;
78cea1d2	178	Double_t fPtMaxCut;
2bb2434e	179	Double_t fRadiusCut; // radius cut
	180	Double_t fPsiPairCut;
	181	Double_t fDeltaPhiCutMin;
	182	Double_t fDeltaPhiCutMax;
ae4f2cfb	183	Double_t fMinClsTPC; // minimum clusters in the TPC
2bb2434e	184	Double_t fMinClsTPCToF; // minimum clusters to findable clusters
	185	Bool_t fDodEdxSigmaITSCut; // flag to use the dEdxCut ITS based on sigmas
	186	Bool_t fDodEdxSigmaTPCCut; // flag to use the dEdxCut TPC based on sigmas
	187	Bool_t fDoTOFsigmaCut; // flag to use TOF pid cut RRnewTOF
	188	Bool_t fDoRejectSharedElecGamma; //Reject electrons from the gammas with Radius < RadiusCut
	189	Bool_t fDoPsiPairCut; // PsiPair Cut
	190	Double_t fPIDnSigmaAboveElectronLineITS; // sigma cut
	191	Double_t fPIDnSigmaBelowElectronLineITS; // sigma cut
	192	Double_t fPIDnSigmaAboveElectronLineTPC; // sigma cut
	193	Double_t fPIDnSigmaBelowElectronLineTPC; // sigma cut
	194	Double_t fPIDnSigmaAbovePionLineTPC;
	195	Double_t fPIDnSigmaAbovePionLineTPCHighPt;
	196	Double_t fTofPIDnSigmaAboveElectronLine; // sigma cut RRnewTOF
	197	Double_t fTofPIDnSigmaBelowElectronLine; // sigma cut RRnewTOF
	198	Double_t fPIDMinPnSigmaAbovePionLineTPC; // sigma cut
	199	Double_t fPIDMaxPnSigmaAbovePionLineTPC; // sigma cut
	200	Double_t fDoKaonRejectionLowP; // Kaon rejection at low p
	201	Double_t fDoProtonRejectionLowP; // Proton rejection at low p
	202	Double_t fDoPionRejectionLowP; // Pion rejection at low p
	203	Double_t fPIDnSigmaAtLowPAroundKaonLine; // sigma cut
	204	Double_t fPIDnSigmaAtLowPAroundProtonLine; // sigma cut
	205	Double_t fPIDnSigmaAtLowPAroundPionLine; // sigma cut
	206	Double_t fPIDMinPKaonRejectionLowP; // Momentum limit to apply kaon rejection
	207	Double_t fPIDMinPProtonRejectionLowP; // Momentum limit to apply proton rejection
	208	Double_t fPIDMinPPionRejectionLowP; // Momentum limit to apply proton rejection
	209
	210	Bool_t fUseCorrectedTPCClsInfo; // flag to use corrected tpc cl info
209b710e	211	Bool_t fUseCrossedRows; //UseCrossedRows 2011
2bb2434e	212	Bool_t fUseTOFpid; // flag to use tof pid
0a2b2b4b	213	Bool_t fRequireTOF; //flg to analyze only tracks with TOF signal
2bb2434e	214	Bool_t fUseTrackMultiplicityForBG; // use multiplicity
2bb2434e	215	Int_t fBKGMethod;
a280ac15	216	Int_t fnumberOfRotationEventsForBG;
ae947965	217	Bool_t fDoMassCut;
258b4572	218	Bool_t fDoMassMinCut;
4803eb1f	219	Double_t fMassCutLowPt;
	220	Double_t fMassCutHighPt;
	221	Double_t fMassCutPtMin;
258b4572	222	Double_t fMassMinCut;
86eaf9ae	223	Bool_t fDoWeights;
2bb2434e	224
	225
	226	// Histograms
	227	TObjString *fCutString; // cut number used for analysis
	228	TH1F *hCutIndex; // bookkeeping for cuts
	229	TH1F *hdEdxCuts; // bookkeeping for dEdx cuts
	230	TH2F *hITSdEdxbefore; // ITS dEdx before cuts
	231	TH2F *hITSdEdxafter;
	232	TH2F *hTPCdEdxbefore; // TPC dEdx before cuts
	233	TH2F *hTPCdEdxafter; // TPC dEdx after cuts
ccfa8c0d	234	TH2F *hTPCdEdxSignalbefore; //TPC dEdx signal before
ccfa8c0d	235	TH2F *hTPCdEdxSignalafter; //TPC dEdx signal after
2bb2434e	236	TH2F *hTOFbefore; // TOF after cuts
2bb2434e	237	TH2F *hTOFafter; // TOF after cuts
4803eb1f	238	TH2F *hTrackDCAxyPtbefore;
	239	TH2F *hTrackDCAxyPtafter;
	240	TH2F *hTrackDCAzPtbefore;
	241	TH2F *hTrackDCAzPtafter;
	242	TH2F *hTrackNFindClsPtTPCbefore;
	243	TH2F *hTrackNFindClsPtTPCafter;
ae947965	244
2bb2434e	245
	246
	247	private:
	248
	249	AliDalitzElectronCuts(const AliDalitzElectronCuts&); // not implemented
	250	AliDalitzElectronCuts& operator=(const AliDalitzElectronCuts&); // not implemented
	251
	252
a280ac15	253	ClassDef(AliDalitzElectronCuts,2)
2bb2434e	254	};
	255
	256
	257	inline void AliDalitzElectronCuts::InitAODpidUtil(Int_t type) {
	258	if (!fPIDResponse) fPIDResponse = new AliAODpidUtil();
	259	Double_t alephParameters[5];
	260	// simulation
	261	alephParameters[0] = 2.15898e+00/50.;
	262	alephParameters[1] = 1.75295e+01;
	263	alephParameters[2] = 3.40030e-09;
	264	alephParameters[3] = 1.96178e+00;
	265	alephParameters[4] = 3.91720e+00;
	266	fPIDResponse->GetTOFResponse().SetTimeResolution(80.);
	267
	268	// data
	269	if (type==1){
	270	alephParameters[0] = 0.0283086/0.97;
	271	alephParameters[1] = 2.63394e+01;
	272	alephParameters[2] = 5.04114e-11;
	273	alephParameters[3] = 2.12543e+00;
	274	alephParameters[4] = 4.88663e+00;
	275	fPIDResponse->GetTOFResponse().SetTimeResolution(130.);
	276	fPIDResponse->GetTPCResponse().SetMip(50.);
	277	}
	278
	279	fPIDResponse->GetTPCResponse().SetBetheBlochParameters(
	280	alephParameters[0],alephParameters[1],alephParameters[2],
	281	alephParameters[3],alephParameters[4]);
	282
	283	fPIDResponse->GetTPCResponse().SetSigma(3.79301e-03, 2.21280e+04);
	284	}
	285
	286
	287	#endif