[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,
	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);
  
  // 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;}
  Double_t GetMassCutLowPt(){return fMassCutLowPt;}
  Double_t GetMassCutHighPt(){return fMassCutHighPt;}
  Double_t GetPtMinMassCut(){return fMassCutPtMin;}
  

  protected:

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

  Double_t fEtaCut; //eta cutç
  Double_t fEtaShift;
  Bool_t   fDoEtaCut;
  Double_t fPtCut;
  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   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;
  Double_t fMassCutLowPt;
  Double_t fMassCutHighPt;
  Double_t fMassCutPtMin;


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