]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/GammaConv/AliDalitzElectronCuts.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
changes in AddTask pPb
[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliDalitzElectronCuts.cxx
CommitLineData
ccfa8c0d 1\r
2/**************************************************************************\r
3 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
4 * *\r
5 * Authors: Svein Lindal, Daniel Lohner *\r
6 * Version 1.0 *\r
7 * *\r
8 * Permission to use, copy, modify and distribute this software and its *\r
9 * documentation strictly for non-commercial purposes is hereby granted *\r
10 * without fee, provided that the above copyright notice appears in all *\r
11 * copies and that both the copyright notice and this permission notice *\r
12 * appear in the supporting documentation. The authors make no claims *\r
13 * about the suitability of this software for any purpose. It is *\r
14 * provided "as is" without express or implied warranty. *\r
15 **************************************************************************/\r
16\r
17////////////////////////////////////////////////\r
18//--------------------------------------------- \r
19// Class handling all kinds of selection cuts for\r
20// Gamma Conversion analysis\r
21//---------------------------------------------\r
22////////////////////////////////////////////////\r
23\r
24\r
25#include "AliDalitzElectronCuts.h"\r
26#include "AliAODConversionPhoton.h"\r
27#include "AliKFVertex.h"\r
28#include "AliAODTrack.h"\r
29#include "AliESDtrack.h"\r
30#include "AliAnalysisManager.h"\r
31#include "AliInputEventHandler.h"\r
32#include "AliMCEventHandler.h"\r
33#include "AliAODHandler.h"\r
34#include "AliPIDResponse.h"\r
35#include "TH1.h"\r
36#include "TH2.h"\r
37#include "AliStack.h"\r
38#include "TObjString.h"\r
39#include "AliAODEvent.h"\r
40#include "AliESDEvent.h"\r
41#include "TList.h"\r
42class iostream;\r
43\r
44using namespace std;\r
45\r
46ClassImp(AliDalitzElectronCuts)\r
47\r
48\r
49const char* AliDalitzElectronCuts::fgkCutNames[AliDalitzElectronCuts::kNCuts] = {\r
50"GoodId",\r
51"ededxSigmaITSCut",\r
52"ededxSigmaTPCCut",\r
53"pidedxSigmaTPCCut",\r
54"piMinMomdedxSigmaTPCCut",\r
55"piMaxMomdedxSigmaTPCCut",\r
56"LowPRejectionSigmaCut",\r
57"kTOFelectronPID",\r
58"clsITSCut",\r
59"clsTPCCut",\r
60"EtaCut",\r
61"PsiPair",\r
62"RejectSharedElecGamma",\r
63"BackgroundScheme",\r
64"NumberOfRotations",\r
ae947965 65"PtCut",\r
66"DCAcut",\r
67"MassCut",\r
ccfa8c0d 68};\r
69\r
70//________________________________________________________________________\r
71AliDalitzElectronCuts::AliDalitzElectronCuts(const char *name,const char *title) : AliAnalysisCuts(name,title),\r
72 fHistograms(NULL),\r
73 fPIDResponse(NULL),\r
74 fesdTrackCuts(NULL),\r
75 fEtaCut(0.9),\r
ae947965 76 fEtaShift(0.0),\r
77 fDoEtaCut(kFALSE),\r
78 fPtCut(0.0),\r
ccfa8c0d 79 fRadiusCut(1000.0),\r
80 fPsiPairCut(0.45),\r
81 fDeltaPhiCutMin(0.),\r
82 fDeltaPhiCutMax(0.12),\r
83 fMinClsTPC(0), // minimum clusters in the TPC\r
84 fMinClsTPCToF(0), // minimum clusters to findable clusters\r
85 fDodEdxSigmaITSCut(kFALSE),\r
86 fDodEdxSigmaTPCCut(kTRUE),\r
87 fDoTOFsigmaCut(kFALSE), // RRnewTOF\r
88 fDoRejectSharedElecGamma(kFALSE),\r
89 fDoPsiPairCut(kFALSE),\r
90 fPIDnSigmaAboveElectronLineITS(100),\r
91 fPIDnSigmaBelowElectronLineITS(-100),\r
92 fPIDnSigmaAboveElectronLineTPC(100),\r
93 fPIDnSigmaBelowElectronLineTPC(-100),\r
94 fPIDnSigmaAbovePionLineTPC(0),\r
95 fPIDnSigmaAbovePionLineTPCHighPt(-100),\r
96 fTofPIDnSigmaAboveElectronLine(100), // RRnewTOF\r
97 fTofPIDnSigmaBelowElectronLine(-100), // RRnewTOF\r
98 fPIDMinPnSigmaAbovePionLineTPC(0),\r
99 fPIDMaxPnSigmaAbovePionLineTPC(0),\r
100 fDoKaonRejectionLowP(kFALSE),\r
101 fDoProtonRejectionLowP(kFALSE),\r
102 fDoPionRejectionLowP(kFALSE),\r
103 fPIDnSigmaAtLowPAroundKaonLine(0),\r
104 fPIDnSigmaAtLowPAroundProtonLine(0),\r
105 fPIDnSigmaAtLowPAroundPionLine(0),\r
106 fPIDMinPKaonRejectionLowP(1.5),\r
107 fPIDMinPProtonRejectionLowP(2.0),\r
108 fPIDMinPPionRejectionLowP(0.5),\r
109 fUseCorrectedTPCClsInfo(kFALSE),\r
110 fUseTOFpid(kFALSE),\r
111 fRequireTOF(kFALSE),\r
112 fUseTrackMultiplicityForBG(kFALSE),\r
113 fBKGMethod(0),\r
114 fnumberOfRotationEventsForBG(0),\r
ae947965 115 fDoMassCut(kFALSE),\r
116 fMassCut(999.),\r
ccfa8c0d 117 fCutString(NULL),\r
118 hCutIndex(NULL),\r
119 hdEdxCuts(NULL),\r
120 hITSdEdxbefore(NULL),\r
121 hITSdEdxafter(NULL),\r
122 hTPCdEdxbefore(NULL),\r
123 hTPCdEdxafter(NULL),\r
124 hTPCdEdxSignalbefore(NULL),\r
125 hTPCdEdxSignalafter(NULL),\r
126 hTOFbefore(NULL),\r
ae947965 127 hTOFafter(NULL),\r
128 hTrackDCAxybefore(NULL),\r
129 hTrackDCAxyafter(NULL),\r
130 hTrackDCAzbefore(NULL),\r
131 hTrackDCAzafter(NULL)\r
ccfa8c0d 132 {\r
133 InitPIDResponse();\r
134 for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=0;}\r
135 fCutString=new TObjString((GetCutNumber()).Data());\r
136\r
137 //fesdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");\r
138 // Using standard function for setting Cuts\r
ae947965 139 Bool_t selectPrimaries=kFALSE;\r
ccfa8c0d 140 fesdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);\r
141}\r
142\r
143//________________________________________________________________________\r
144AliDalitzElectronCuts::~AliDalitzElectronCuts() {\r
145 // Destructor\r
146 //Deleting fHistograms leads to seg fault it it's added to output collection of a task\r
147 // if(fHistograms)\r
148 // delete fHistograms;\r
149 // fHistograms = NULL;\r
150\r
151 if(fCutString != NULL){\r
152 delete fCutString;\r
153 fCutString = NULL;\r
154 }\r
155\r
156\r
157}\r
158\r
159//________________________________________________________________________\r
160void AliDalitzElectronCuts::InitCutHistograms(TString name, Bool_t preCut,TString cutNumber){\r
161\r
162 // Initialize Cut Histograms for QA (only initialized and filled if function is called)\r
163\r
164 TString cutName = "";\r
165 \r
166 if( cutNumber==""){\r
167 cutName = GetCutNumber().Data();\r
168 }\r
169 else {\r
170 cutName = cutNumber.Data();\r
171 } \r
172\r
173 if(fHistograms != NULL){\r
174 delete fHistograms;\r
175 fHistograms=NULL;\r
176 }\r
177 if(fHistograms==NULL){\r
178 fHistograms=new TList();\r
179 if(name=="")fHistograms->SetName(Form("ElectronCuts_%s",cutName.Data()));\r
180 else fHistograms->SetName(Form("%s_%s",name.Data(),cutName.Data()));\r
181 }\r
182\r
183\r
184 hCutIndex=new TH1F(Form("IsElectronSelected %s",cutName.Data()),"IsElectronSelected",10,-0.5,9.5);\r
185 hCutIndex->GetXaxis()->SetBinLabel(kElectronIn+1,"in");\r
186 hCutIndex->GetXaxis()->SetBinLabel(kNoTracks+1,"no tracks");\r
187 hCutIndex->GetXaxis()->SetBinLabel(kTrackCuts+1,"Track cuts");\r
188 hCutIndex->GetXaxis()->SetBinLabel(kdEdxCuts+1,"dEdx");\r
189 hCutIndex->GetXaxis()->SetBinLabel(kElectronOut+1,"out");\r
190 fHistograms->Add(hCutIndex);\r
191\r
192\r
193\r
194 // dEdx Cuts\r
195 hdEdxCuts=new TH1F(Form("dEdxCuts %s",cutName.Data()),"dEdxCuts",10,-0.5,9.5);\r
196 hdEdxCuts->GetXaxis()->SetBinLabel(1,"in");\r
197 hdEdxCuts->GetXaxis()->SetBinLabel(2,"ITSelectron");\r
198 hdEdxCuts->GetXaxis()->SetBinLabel(3,"TPCelectron");\r
199 hdEdxCuts->GetXaxis()->SetBinLabel(4,"TPCpion");\r
200 hdEdxCuts->GetXaxis()->SetBinLabel(5,"TPCpionhighp");\r
201 hdEdxCuts->GetXaxis()->SetBinLabel(6,"TPCkaonlowprej");\r
202 hdEdxCuts->GetXaxis()->SetBinLabel(7,"TPCprotonlowprej");\r
203 hdEdxCuts->GetXaxis()->SetBinLabel(8,"TPCpionlowprej");\r
204 hdEdxCuts->GetXaxis()->SetBinLabel(9,"TOFelectron");\r
205 hdEdxCuts->GetXaxis()->SetBinLabel(10,"out");\r
206 fHistograms->Add(hdEdxCuts);\r
207 \r
208\r
209\r
210 TAxis *AxisBeforeITS = NULL;\r
211 TAxis *AxisBeforedEdx = NULL;\r
212 TAxis *AxisBeforeTOF = NULL;\r
213 TAxis *AxisBeforedEdxSignal = NULL;\r
214\r
215 if(preCut){\r
216\r
217\r
218 hITSdEdxbefore=new TH2F(Form("Electron_ITS_before %s",cutName.Data()),"ITS dEdx electron before" ,150,0.05,20,400,-10,10);\r
219 fHistograms->Add(hITSdEdxbefore);\r
220 AxisBeforeITS = hITSdEdxbefore->GetXaxis();\r
221\r
222 hTPCdEdxbefore=new TH2F(Form("Electron_dEdx_before %s",cutName.Data()),"dEdx electron before" ,150,0.05,20,400,-10,10);\r
223 fHistograms->Add(hTPCdEdxbefore);\r
224 AxisBeforedEdx = hTPCdEdxbefore->GetXaxis();\r
225\r
226 hTPCdEdxSignalbefore=new TH2F(Form("Electron_dEdxSignal_before %s",cutName.Data()),"dEdx electron signal before" ,150,0.05,20.0,800,0.0,200);\r
227 fHistograms->Add(hTPCdEdxSignalbefore);\r
228 AxisBeforedEdxSignal = hTPCdEdxSignalbefore->GetXaxis();\r
229\r
ccfa8c0d 230 hTOFbefore=new TH2F(Form("Electron_TOF_before %s",cutName.Data()),"TOF electron before" ,150,0.05,20,400,-6,10);\r
231 fHistograms->Add(hTOFbefore);\r
232 AxisBeforeTOF = hTOFbefore->GetXaxis();\r
ae947965 233 \r
234 hTrackDCAxybefore = new TH1F(Form("hTrackDCAxy_before %s",cutName.Data()),"DCAxy of tracks before",2000,-10.0,10.0);\r
235 fHistograms->Add(hTrackDCAxybefore); \r
236 \r
237 hTrackDCAzbefore = new TH1F(Form("hTrackDCAz_before %s",cutName.Data()), "DCAz of tracks before",2000,-10.0,10.0);\r
238 fHistograms->Add(hTrackDCAzbefore); \r
ccfa8c0d 239\r
240 }\r
241\r
242\r
243 hITSdEdxafter=new TH2F(Form("Electron_ITS_after %s",cutName.Data()),"ITS dEdx electron after" ,150,0.05,20,400, -10,10);\r
244 fHistograms->Add(hITSdEdxafter);\r
245\r
246 hTPCdEdxafter=new TH2F(Form("Electron_dEdx_after %s",cutName.Data()),"dEdx electron after" ,150,0.05,20,400, -10,10);\r
247 fHistograms->Add(hTPCdEdxafter);\r
248\r
249 hTPCdEdxSignalafter=new TH2F(Form("Electron_dEdxSignal_after %s",cutName.Data()),"dEdx electron signal after" ,150,0.05,20.0,800,0.0,200);\r
250 fHistograms->Add(hTPCdEdxSignalafter);\r
251\r
252 hTOFafter=new TH2F(Form("Electron_TOF_after %s",cutName.Data()),"TOF electron after" ,150,0.05,20,400,-6,10);\r
253 fHistograms->Add(hTOFafter);\r
ae947965 254 \r
255 hTrackDCAxyafter = new TH1F(Form("hTrackDCAxy_after %s",cutName.Data()),"DCAxy of tracks after",2000,-10.0,10.0);\r
256 fHistograms->Add(hTrackDCAxyafter); \r
257 \r
258 hTrackDCAzafter = new TH1F(Form("hTrackDCAz_after %s",cutName.Data()), "DCAz of tracks after",2000,-10.0,10.0);\r
259 fHistograms->Add(hTrackDCAzafter); \r
260 \r
261 \r
ccfa8c0d 262\r
263 TAxis *AxisAfter = hTPCdEdxafter->GetXaxis(); \r
264 Int_t bins = AxisAfter->GetNbins();\r
265 Double_t from = AxisAfter->GetXmin();\r
266 Double_t to = AxisAfter->GetXmax();\r
267 Double_t *newBins = new Double_t[bins+1];\r
268 newBins[0] = from;\r
269 Double_t factor = TMath::Power(to/from, 1./bins);\r
270 for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];\r
271 AxisAfter->Set(bins, newBins);\r
272 AxisAfter = hTOFafter->GetXaxis(); \r
273 AxisAfter->Set(bins, newBins);\r
274 AxisAfter = hITSdEdxafter->GetXaxis();\r
275 AxisAfter->Set(bins,newBins); \r
276 AxisAfter = hTPCdEdxSignalafter->GetXaxis();\r
277 AxisAfter->Set(bins,newBins);\r
278 \r
279 if(preCut){\r
280 AxisBeforeITS->Set(bins, newBins);\r
281 AxisBeforedEdx->Set(bins, newBins);\r
282 AxisBeforedEdxSignal->Set(bins,newBins);\r
283 AxisBeforeTOF->Set(bins, newBins);\r
284 \r
285 }\r
286 delete [] newBins;\r
287\r
288 \r
289 // Event Cuts and Info\r
290}\r
291\r
292\r
293//________________________________________________________________________\r
294Bool_t AliDalitzElectronCuts::InitPIDResponse(){\r
295\r
296// Set Pointer to AliPIDResponse\r
297\r
298 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();\r
299\r
300 if(man) {\r
301\r
302 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());\r
303 fPIDResponse = (AliPIDResponse*)inputHandler->GetPIDResponse();\r
304 if(fPIDResponse)return kTRUE;\r
305\r
306 }\r
307\r
308 return kFALSE;\r
309}\r
310///________________________________________________________________________\r
311Bool_t AliDalitzElectronCuts::ElectronIsSelectedMC(Int_t labelParticle,AliStack *fMCStack)\r
312{ \r
ae947965 313 if( labelParticle < 0 || labelParticle >= fMCStack->GetNtrack() ) return kFALSE;\r
314 if( fMCStack->IsPhysicalPrimary(labelParticle) == kFALSE ) return kFALSE; //Ask Ana\r
ccfa8c0d 315\r
316 TParticle* particle = fMCStack->Particle(labelParticle);\r
317\r
ae947965 318 if( TMath::Abs( particle->GetPdgCode() ) != 11 ) return kFALSE;\r
319 \r
320 if( fDoEtaCut ){\r
321 if( particle->Eta() > (fEtaCut + fEtaShift) || particle->Eta() < (-fEtaCut + fEtaShift) )\r
322 return kFALSE;\r
323 }\r
324 \r
ccfa8c0d 325\r
326return kTRUE;\r
327}\r
328\r
329\r
330///________________________________________________________________________\r
331Bool_t AliDalitzElectronCuts::ElectronIsSelected(AliESDtrack* lTrack)\r
332{\r
333 //Selection of Reconstructed electrons\r
334\r
335 if(hCutIndex)hCutIndex->Fill(kElectronIn);\r
336\r
337 if (lTrack == NULL){\r
338 if(hCutIndex)hCutIndex->Fill(kNoTracks);\r
339 return kFALSE; \r
340 } \r
341 \r
342 if ( ! lTrack->GetConstrainedParam() ){\r
343 return kFALSE;\r
344 }\r
345 AliVTrack * track = dynamic_cast<AliVTrack*>(lTrack);\r
346\r
347\r
348 // Track Cuts\r
349 if( !TrackIsSelected(lTrack) ){\r
350 if(hCutIndex)hCutIndex->Fill(kTrackCuts);\r
351 return kFALSE;\r
352 }\r
353\r
354\r
355 // dEdx Cuts\r
356 if( ! dEdxCuts( track ) ) {\r
357 if(hCutIndex)hCutIndex->Fill(kdEdxCuts);\r
358 return kFALSE;\r
359\r
360 }\r
361\r
362 //Electron passed the cuts\r
363 if(hCutIndex)hCutIndex->Fill(kElectronOut);\r
364\r
365\r
366 return kTRUE;\r
367}\r
368\r
369///________________________________________________________________________\r
370Bool_t AliDalitzElectronCuts::TrackIsSelected(AliESDtrack* lTrack) {\r
371 // Track Selection for Photon Reconstruction\r
ae947965 372 \r
373 \r
374 Float_t b[2];\r
375 Float_t bCov[3];\r
376 lTrack->GetImpactParameters(b,bCov);\r
377 if (bCov[0]<=0 || bCov[2]<=0) {\r
378 AliDebug(1, "Estimated b resolution lower or equal zero!");\r
379 bCov[0]=0; bCov[2]=0;\r
380 }\r
ccfa8c0d 381\r
382\r
ae947965 383 Float_t dcaToVertexXY = b[0];\r
384 Float_t dcaToVertexZ = b[1];\r
385 \r
386 \r
ccfa8c0d 387\r
ae947965 388 if( hTrackDCAxybefore) hTrackDCAxybefore->Fill(dcaToVertexXY);\r
389 if( hTrackDCAzbefore ) hTrackDCAzbefore->Fill(dcaToVertexZ);\r
390 \r
ccfa8c0d 391\r
ccfa8c0d 392\r
ae947965 393 if( ! fesdTrackCuts->AcceptTrack(lTrack) ){\r
ccfa8c0d 394\r
395 return kFALSE;\r
396 }\r
ae947965 397 \r
398 if( fDoEtaCut ) {\r
399 if( lTrack->Eta() > (fEtaCut + fEtaShift) || lTrack->Eta() < (-fEtaCut + fEtaShift) ) {\r
400 return kFALSE;\r
401 }\r
402 }\r
403 \r
404 \r
405 if( lTrack->Pt() < fPtCut ) {\r
406 \r
407 return kFALSE;\r
408 \r
409 }\r
ccfa8c0d 410\r
411 if( lTrack->GetNcls(1) < fMinClsTPC ) {\r
412\r
413 return kFALSE;\r
414 }\r
415\r
416 //Findable clusters\r
417\r
418 Double_t clsToF=0;\r
419\r
420\r
421 if (!fUseCorrectedTPCClsInfo ){\r
422 if(lTrack->GetTPCNclsF()!=0){\r
423\r
424 clsToF = (Double_t)lTrack->GetNcls(1)/(Double_t)lTrack->GetTPCNclsF();\r
425 }// Ncluster/Nfindablecluster\r
426 }\r
427 else {\r
428\r
429 //clsToF = lTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));\r
430 clsToF = lTrack->GetTPCClusterInfo(2,1); //NOTE ask friederike\r
431 \r
432 }\r
433\r
434\r
435 if( clsToF < fMinClsTPCToF){\r
436 return kFALSE;\r
437 }\r
438\r
ae947965 439 if( hTrackDCAxyafter) hTrackDCAxyafter->Fill(dcaToVertexXY);\r
440 if( hTrackDCAzafter ) hTrackDCAzafter->Fill(dcaToVertexZ);\r
ccfa8c0d 441\r
442\r
443 return kTRUE;\r
444}\r
445///________________________________________________________________________\r
446Bool_t AliDalitzElectronCuts::dEdxCuts(AliVTrack *fCurrentTrack){\r
447\r
448 // Electron Identification Cuts for Photon reconstruction\r
449\r
450 if(!fPIDResponse){ InitPIDResponse(); }// Try to reinitialize PID Response\r
451 if(!fPIDResponse){ AliError("No PID Response"); return kFALSE;}// if still missing fatal error\r
452\r
453\r
454\r
455 //cout<<"dEdxCuts: //////////////////////////////////////////////////////////////////////////"<<endl;\r
456\r
457\r
458\r
459 Int_t cutIndex=0;\r
460\r
461 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
462 if(hITSdEdxbefore)hITSdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));\r
463 if(hTPCdEdxbefore)hTPCdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));\r
464 if(hTPCdEdxSignalbefore)hTPCdEdxSignalbefore->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));\r
465\r
466\r
467 cutIndex++;\r
468\r
469\r
0f8c33c1 470 if( fDodEdxSigmaITSCut == kTRUE ){\r
ccfa8c0d 471\r
472\r
0f8c33c1 473 if( fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineITS ||\r
474 fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)> fPIDnSigmaAboveElectronLineITS ){\r
475 \r
476 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
477 return kFALSE;\r
ccfa8c0d 478 }\r
0f8c33c1 479 \r
480 }\r
481 \r
482 if(hITSdEdxafter)hITSdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));\r
483 \r
484 \r
485 cutIndex++;\r
486 \r
487 \r
488 if(fDodEdxSigmaTPCCut == kTRUE){\r
489 \r
490 \r
ccfa8c0d 491 // TPC Electron Line\r
492 if( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineTPC ||\r
0f8c33c1 493 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaAboveElectronLineTPC){\r
494 \r
495 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
496 return kFALSE;\r
ccfa8c0d 497 }\r
498 cutIndex++;\r
0f8c33c1 499 \r
ccfa8c0d 500 // TPC Pion Line\r
0f8c33c1 501 if( fCurrentTrack->P()>fPIDMinPnSigmaAbovePionLineTPC && fCurrentTrack->P()<fPIDMaxPnSigmaAbovePionLineTPC ){\r
502 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC &&\r
503 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC &&\r
504 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPC){\r
505 \r
506 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
507 return kFALSE;\r
508 }\r
509 }\r
510 cutIndex++;\r
511 \r
512 // High Pt Pion rej\r
513 if( fCurrentTrack->P()>fPIDMaxPnSigmaAbovePionLineTPC ){\r
514 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC &&\r
515 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC&&\r
516 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPCHighPt){\r
517 \r
518 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
519 return kFALSE;\r
520 }\r
521 }\r
522 \r
523 cutIndex++;\r
524 }\r
ccfa8c0d 525\r
0f8c33c1 526 else{ cutIndex+=3; }\r
ccfa8c0d 527\r
ccfa8c0d 528\r
0f8c33c1 529 if( fDoKaonRejectionLowP == kTRUE ){\r
ccfa8c0d 530\r
0f8c33c1 531 if( fCurrentTrack->P() < fPIDMinPKaonRejectionLowP ){\r
532 \r
533 if( TMath::Abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kKaon))<fPIDnSigmaAtLowPAroundKaonLine){\r
534 \r
535 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
536 \r
537 return kFALSE;\r
538 }\r
539 }\r
540 }\r
541 cutIndex++;\r
542 \r
543 if( fDoProtonRejectionLowP == kTRUE ){\r
544 \r
545 if( fCurrentTrack->P() < fPIDMinPProtonRejectionLowP ){\r
546 if( TMath::Abs( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kProton))<fPIDnSigmaAtLowPAroundProtonLine){\r
547 \r
548 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
549 return kFALSE;\r
550 }\r
551 }\r
552 }\r
553 cutIndex++;\r
554 \r
555 if(fDoPionRejectionLowP == kTRUE){\r
556 if( fCurrentTrack->P() < fPIDMinPPionRejectionLowP ){\r
557 if( TMath::Abs( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)) < fPIDnSigmaAtLowPAroundPionLine ){\r
558 \r
559 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
560 return kFALSE;\r
561 }\r
562 }\r
563 }\r
564 cutIndex++;\r
565 \r
566 \r
567 if( ( fCurrentTrack->GetStatus() & AliESDtrack::kTOFpid ) && ( !( fCurrentTrack->GetStatus() & AliESDtrack::kTOFmismatch) ) ){\r
568 if(hTOFbefore) hTOFbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));\r
569 if(fUseTOFpid){\r
ccfa8c0d 570 if(fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)>fTofPIDnSigmaAboveElectronLine ||\r
571 fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)<fTofPIDnSigmaBelowElectronLine ){\r
0f8c33c1 572 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
573 return kFALSE;\r
ccfa8c0d 574 }\r
0f8c33c1 575 }\r
576 if(hTOFafter)hTOFafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));\r
577 }\r
578 else if ( fRequireTOF == kTRUE ) {\r
579 \r
580 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
581 return kFALSE;\r
582 }\r
583 cutIndex++;\r
584 \r
585 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
586 if(hTPCdEdxafter)hTPCdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));\r
587 if(hTPCdEdxSignalafter)hTPCdEdxSignalafter->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));\r
588 \r
589 return kTRUE;\r
ccfa8c0d 590}\r
591///________________________________________________________________________\r
592\r
593\r
594AliVTrack *AliDalitzElectronCuts::GetTrack(AliVEvent * event, Int_t label){\r
595 //Returns pointer to the track with given ESD label\r
596 //(Important for AOD implementation, since Track array in AOD data is different\r
597 //from ESD array, but ESD tracklabels are stored in AOD Tracks)\r
598\r
599 AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(event);\r
600 if(esdEvent) {\r
601 if(label > event->GetNumberOfTracks() ) return NULL;\r
602 AliESDtrack * track = esdEvent->GetTrack(label);\r
603 return track;\r
604 \r
605 } else { \r
606 for(Int_t ii=0; ii<event->GetNumberOfTracks(); ii++) {\r
607 AliVTrack * track = dynamic_cast<AliVTrack*>(event->GetTrack(ii));\r
608 \r
609 if(track) { \r
610 if(track->GetID() == label) {\r
611 return track;\r
612 }\r
613 }\r
614 }\r
615 }\r
616 \r
617 cout << "track not found " << label << " " << event->GetNumberOfTracks() << endl;\r
618 return NULL;\r
619}\r
620///________________________________________________________________________\r
621Bool_t AliDalitzElectronCuts::RejectSharedElecGamma(TList *photons, Int_t indexEle){\r
622\r
623\r
624 for(Int_t i = 0;i<photons->GetEntries();i++){\r
625\r
626 AliAODConversionPhoton *photonComp = (AliAODConversionPhoton*) photons->At(i);\r
627\r
628 Int_t posLabel = photonComp->GetTrackLabelPositive();\r
629 Int_t negLabel = photonComp->GetTrackLabelNegative();\r
630\r
631 if( (photonComp->GetConversionRadius() < fRadiusCut) && (posLabel == indexEle || negLabel == indexEle) ){\r
632 return kFALSE;\r
633 }\r
634 }\r
635\r
636 return kTRUE;\r
637}\r
638/*\r
639Double_t AliDalitzElectronCuts::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg )\r
640{\r
641//\r
642// This angle is a measure for the contribution of the opening in polar\r
643// direction ??0 to the opening angle ?? Pair\r
644//\r
645// Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC\r
646// Master Thesis. Thorsten Dahms. 2005\r
647// https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf\r
648//\r
649 Double_t momPos[3];\r
650 Double_t momNeg[3];\r
651 if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );\r
652 if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );\r
653\r
654 TVector3 posDaughter;\r
655 TVector3 negDaughter;\r
656\r
657 posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );\r
658 negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );\r
659\r
660 Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();\r
661 Double_t openingAngle = posDaughter.Angle( negDaughter ); //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );\r
662\r
663 if( openingAngle < 1e-20 ) return 0.;\r
664\r
665 Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );\r
666\r
667 return psiAngle;\r
668}*/\r
669\r
670Bool_t AliDalitzElectronCuts::IsFromGammaConversion( Double_t psiPair, Double_t deltaPhi )\r
671{\r
672//\r
673// Returns true if it is a gamma conversion according to psi pair value\r
674//\r
675 return ( (deltaPhi > fDeltaPhiCutMin && deltaPhi < fDeltaPhiCutMax) &&\r
676 TMath::Abs(psiPair) < ( fPsiPairCut - fPsiPairCut/fDeltaPhiCutMax * deltaPhi ) );\r
677}\r
678\r
679///________________________________________________________________________\r
680Bool_t AliDalitzElectronCuts::UpdateCutString(cutIds cutID, Int_t value) {\r
681///Update the cut string (if it has been created yet)\r
682\r
683 if(fCutString && fCutString->GetString().Length() == kNCuts) {\r
684// cout << "Updating cut id in spot number " << cutID << " to " << value << endl;\r
685 fCutString->SetString(GetCutNumber());\r
686 } else {\r
687// cout << "fCutString not yet initialized, will not be updated" << endl;\r
688 return kFALSE;\r
689 }\r
690 // cout << fCutString->GetString().Data() << endl;\r
691 return kTRUE;\r
692}\r
693\r
694///________________________________________________________________________\r
695Bool_t AliDalitzElectronCuts::InitializeCutsFromCutString(const TString analysisCutSelection ) {\r
696 // Initialize Cuts from a given Cut string\r
697\r
698// out<<"Set Cut Number: "<<analysisCutSelection.Data()<<endl;\r
ae947965 699 AliInfo(Form("Set ElectronCuts Number: %s",analysisCutSelection.Data()));\r
700 \r
ccfa8c0d 701 if(analysisCutSelection.Length()!=kNCuts) {\r
702 AliError(Form("Cut selection has the wrong length! size is %d, number of cuts is %d", analysisCutSelection.Length(), kNCuts));\r
703 return kFALSE;\r
704 }\r
705 if(!analysisCutSelection.IsDigit()){\r
706 AliError("Cut selection contains characters");\r
707 return kFALSE;\r
708 }\r
709 \r
710 const char *cutSelection = analysisCutSelection.Data();\r
711 #define ASSIGNARRAY(i) fCuts[i] = cutSelection[i] - '0'\r
712 for(Int_t ii=0;ii<kNCuts;ii++){\r
713 ASSIGNARRAY(ii);\r
714 }\r
715\r
716 // TestFlag\r
717 if(fCuts[0] !=9){\r
718 AliError("Analysis Cut Selection does not start with 9");\r
719 PrintCuts();\r
720 return kFALSE;\r
721 }\r
722\r
723 // Set Individual Cuts\r
724 for(Int_t ii=0;ii<kNCuts;ii++){\r
725 if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;\r
726 }\r
727\r
728 //PrintCuts();\r
729\r
730 return kTRUE;\r
731}\r
732///________________________________________________________________________\r
733Bool_t AliDalitzElectronCuts::SetCut(cutIds cutID, const Int_t value) {\r
734 ///Set individual cut ID\r
735\r
736 //cout << "Updating cut " << fgkCutNames[cutID] << " (" << cutID << ") to " << value << endl;\r
737\r
738 switch (cutID) {\r
739 case kgoodId:\r
740 fCuts[kgoodId] = value;\r
741 if(value != 9) {\r
742 cout << "Error:: First value of cut string is wrong, aborting!!" << endl;\r
743 return kFALSE;\r
744 } else {\r
745 return kTRUE;\r
746 }\r
747\r
748 case kededxSigmaITSCut:\r
749 if( SetITSdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented \r
750 fCuts[kededxSigmaITSCut] = value;\r
751 UpdateCutString(cutID, value);\r
752 return kTRUE;\r
753 } else return kFALSE;\r
754\r
0f8c33c1 755 case kededxSigmaTPCCut:\r
756 if( SetTPCdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented \r
757 fCuts[kededxSigmaTPCCut] = value;\r
758 UpdateCutString(cutID, value);\r
759 return kTRUE;\r
760 } else return kFALSE;\r
761 \r
ccfa8c0d 762 case kpidedxSigmaTPCCut:\r
0f8c33c1 763 if( SetTPCdEdxCutPionLine(value)) { //NOTE SetITSdEdxCutPionLine: To be implemented\r
764 fCuts[kpidedxSigmaTPCCut] = value;\r
765 UpdateCutString(cutID, value);\r
766 return kTRUE;\r
767 } else return kFALSE;\r
768 \r
ccfa8c0d 769 case kpiMinMomdedxSigmaTPCCut:\r
0f8c33c1 770 if( SetMinMomPiondEdxTPCCut(value)) {\r
771 fCuts[kpiMinMomdedxSigmaTPCCut] = value;\r
772 UpdateCutString(cutID, value);\r
773 return kTRUE;\r
774 } else return kFALSE;\r
775 \r
ccfa8c0d 776 case kpiMaxMomdedxSigmaTPCCut:\r
0f8c33c1 777 if( SetMaxMomPiondEdxTPCCut(value)) {\r
778 fCuts[kpiMaxMomdedxSigmaTPCCut] = value;\r
779 UpdateCutString(cutID, value);\r
780 return kTRUE;\r
781 } else return kFALSE;\r
782 \r
ccfa8c0d 783 case kLowPRejectionSigmaCut:\r
0f8c33c1 784 if( SetLowPRejectionCuts(value) ) {\r
785 fCuts[kLowPRejectionSigmaCut] = value;\r
786 UpdateCutString(cutID, value);\r
787 return kTRUE;\r
788 } else return kFALSE;\r
789 \r
790 \r
ccfa8c0d 791 case kTOFelectronPID:\r
0f8c33c1 792 if( SetTOFElectronPIDCut(value)) {\r
793 fCuts[kTOFelectronPID] = value;\r
794 UpdateCutString(cutID, value);\r
795 return kTRUE;\r
796 } else return kFALSE;\r
ccfa8c0d 797 case kclsITSCut:\r
0f8c33c1 798 if( SetITSClusterCut(value) ) {\r
799 fCuts[kclsITSCut] = value;\r
800 UpdateCutString(cutID, value);\r
801 return kTRUE; \r
802 } else return kFALSE;\r
ccfa8c0d 803 case kclsTPCCut:\r
0f8c33c1 804 if( SetTPCClusterCut(value)) {\r
805 fCuts[kclsTPCCut] = value;\r
806 UpdateCutString(cutID, value);\r
807 return kTRUE;\r
808 } else return kFALSE;\r
809 \r
ccfa8c0d 810 case ketaCut:\r
0f8c33c1 811 if( SetEtaCut(value)) {\r
812 fCuts[ketaCut] = value;\r
813 UpdateCutString(cutID, value);\r
814 return kTRUE;\r
815 } else return kFALSE;\r
ae947965 816 case kptCut: \r
817 if( SetPtCut(value)) {\r
818 fCuts[kptCut] = value;\r
819 UpdateCutString(cutID, value);\r
820 return kTRUE;\r
821 } else return kFALSE;\r
822 \r
823 case kDCACut:\r
824 if( SetDCACut(value)) {\r
825 fCuts[kDCACut] = value;\r
826 UpdateCutString(cutID, value);\r
827 return kTRUE;\r
828 } else return kFALSE;\r
829 \r
830 \r
0f8c33c1 831 case kPsiPair:\r
832 if( SetPsiPairCut(value)) {\r
833 fCuts[kPsiPair] = value;\r
834 UpdateCutString(cutID, value);\r
835 return kTRUE;\r
836 } else return kFALSE;\r
837 \r
ccfa8c0d 838 case kRejectSharedElecGamma:\r
0f8c33c1 839 if( SetRejectSharedElecGamma(value)) {\r
840 fCuts[kRejectSharedElecGamma] = value;\r
841 UpdateCutString(cutID, value);\r
ccfa8c0d 842 return kTRUE;\r
0f8c33c1 843 } else return kFALSE;\r
844 \r
ccfa8c0d 845 case kBackgroundScheme:\r
0f8c33c1 846 if( SetBackgroundScheme(value)) {\r
847 fCuts[kBackgroundScheme] = value;\r
848 UpdateCutString(cutID, value);\r
849 return kTRUE;\r
850 } else return kFALSE;\r
ccfa8c0d 851\r
852 case kNumberOfRotations:\r
0f8c33c1 853 if( SetNumberOfRotations(value)) {\r
854 fCuts[kNumberOfRotations] = value;\r
855 UpdateCutString(cutID, value);\r
856 return kTRUE;\r
857 } else return kFALSE;\r
858 \r
ae947965 859 case kmassCut:\r
860 if( SetMassCut(value)) {\r
861 fCuts[kmassCut] = value;\r
862 UpdateCutString(cutID, value);\r
863 return kTRUE;\r
864 } else return kFALSE;\r
865 \r
ccfa8c0d 866 case kNCuts:\r
0f8c33c1 867 cout << "Error:: Cut id out of range"<< endl;\r
868 return kFALSE;\r
ccfa8c0d 869 }\r
0f8c33c1 870 \r
ccfa8c0d 871 cout << "Error:: Cut id " << cutID << " not recognized "<< endl;\r
872 return kFALSE;\r
873\r
874 //PrintCuts();\r
875 \r
876}\r
877\r
878///________________________________________________________________________\r
879\r
880void AliDalitzElectronCuts::PrintCuts() {\r
881 // Print out current Cut Selection\r
882 for(Int_t ic = 0; ic < kNCuts; ic++) {\r
883 printf("%-30s : %d \n", fgkCutNames[ic], fCuts[ic]);\r
884 }\r
885\r
886}\r
887\r
888///________________________________________________________________________\r
889Bool_t AliDalitzElectronCuts::SetITSdEdxCutElectronLine(Int_t ededxSigmaCut)\r
890{ // Set Cut\r
891\r
892 switch(ededxSigmaCut){\r
893\r
894 case 0: \r
895 fDodEdxSigmaITSCut = kFALSE;\r
896 fPIDnSigmaBelowElectronLineITS=-100;\r
897 fPIDnSigmaAboveElectronLineITS= 100;\r
898 break;\r
899 case 1: // -10,10\r
900 fDodEdxSigmaITSCut = kTRUE;\r
901 fPIDnSigmaBelowElectronLineITS=-10;\r
902 fPIDnSigmaAboveElectronLineITS=10;\r
903 break;\r
904 case 2: // -6,7\r
905 fDodEdxSigmaITSCut = kTRUE;\r
906 fPIDnSigmaBelowElectronLineITS=-6;\r
907 fPIDnSigmaAboveElectronLineITS=7;\r
908 break;\r
909 case 3: // -5,5\r
910 fDodEdxSigmaITSCut = kTRUE;\r
911 fPIDnSigmaBelowElectronLineITS=-5;\r
912 fPIDnSigmaAboveElectronLineITS=5;\r
913 break;\r
914 case 4: // -4,5\r
915 fDodEdxSigmaITSCut = kTRUE;\r
916 fPIDnSigmaBelowElectronLineITS=-4;\r
917 fPIDnSigmaAboveElectronLineITS=5;\r
918 break;\r
919 case 5: // -3,5\r
920 fDodEdxSigmaITSCut = kTRUE;\r
921 fPIDnSigmaBelowElectronLineITS=-3;\r
922 fPIDnSigmaAboveElectronLineITS=5;\r
923 break;\r
924 case 6: // -4,4\r
925 fDodEdxSigmaITSCut = kTRUE;\r
926 fPIDnSigmaBelowElectronLineITS=-4;\r
927 fPIDnSigmaAboveElectronLineITS=4;\r
928 break;\r
929 case 7: // -2.5,4\r
930 fDodEdxSigmaITSCut = kTRUE;\r
931 fPIDnSigmaBelowElectronLineITS=-2.5;\r
932 fPIDnSigmaAboveElectronLineITS=4;\r
933 break;\r
934 case 8: // -2,3.5\r
935 fDodEdxSigmaITSCut = kTRUE;\r
936 fPIDnSigmaBelowElectronLineITS=-2;\r
937 fPIDnSigmaAboveElectronLineITS=3.5;\r
938 break;\r
939 default:\r
940 cout<<"Warning: ITSdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;\r
941 return kFALSE;\r
942 \r
943 }\r
944 return kTRUE;\r
945}\r
946\r
947///________________________________________________________________________\r
948Bool_t AliDalitzElectronCuts::SetTPCdEdxCutElectronLine(Int_t ededxSigmaCut)\r
949{ // Set Cut\r
950 switch(ededxSigmaCut){\r
951\r
952 case 0: fDodEdxSigmaTPCCut = kFALSE;\r
953 fPIDnSigmaBelowElectronLineTPC=-10;\r
954 fPIDnSigmaAboveElectronLineTPC=10;\r
955 break;\r
956 case 1: // -10,10\r
957 fDodEdxSigmaTPCCut = kTRUE;\r
958 fPIDnSigmaBelowElectronLineTPC=-10;\r
959 fPIDnSigmaAboveElectronLineTPC=10;\r
960 break;\r
961 case 2: // -6,7\r
962 fDodEdxSigmaTPCCut = kTRUE;\r
963 fPIDnSigmaBelowElectronLineTPC=-6;\r
964 fPIDnSigmaAboveElectronLineTPC=7;\r
965 break;\r
966 case 3: // -5,5\r
967 fDodEdxSigmaTPCCut = kTRUE;\r
968 fPIDnSigmaBelowElectronLineTPC=-5;\r
969 fPIDnSigmaAboveElectronLineTPC=5;\r
970 break;\r
971 case 4: // -4,5\r
972 fDodEdxSigmaTPCCut = kTRUE;\r
973 fPIDnSigmaBelowElectronLineTPC=-4;\r
974 fPIDnSigmaAboveElectronLineTPC=5;\r
975 break; \r
976 case 5: // -3,5\r
977 fDodEdxSigmaTPCCut = kTRUE;\r
978 fPIDnSigmaBelowElectronLineTPC=-3;\r
979 fPIDnSigmaAboveElectronLineTPC=5;\r
980 break;\r
981 case 6: // -4,4\r
982 fDodEdxSigmaTPCCut = kTRUE;\r
983 fPIDnSigmaBelowElectronLineTPC=-4;\r
984 fPIDnSigmaAboveElectronLineTPC=4;\r
985 break;\r
986 case 7: // -2.5,4\r
987 fDodEdxSigmaTPCCut = kTRUE;\r
988 fPIDnSigmaBelowElectronLineTPC=-2.5;\r
989 fPIDnSigmaAboveElectronLineTPC=4;\r
990 break;\r
991 case 8: // -2,3.5\r
992 fDodEdxSigmaTPCCut = kTRUE;\r
993 fPIDnSigmaBelowElectronLineTPC=-2;\r
994 fPIDnSigmaAboveElectronLineTPC=3.5;\r
995 break;\r
996 default:\r
997 cout<<"Warning: TPCdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;\r
998 return kFALSE;\r
999 \r
1000 }\r
1001 return kTRUE;\r
1002}\r
1003\r
1004///________________________________________________________________________\r
1005Bool_t AliDalitzElectronCuts::SetTPCdEdxCutPionLine(Int_t pidedxSigmaCut)\r
1006{ // Set Cut\r
1007\r
1008 switch(pidedxSigmaCut){\r
1009 \r
1010 case 0: fPIDnSigmaAbovePionLineTPC= 0;\r
1011 fPIDnSigmaAbovePionLineTPCHighPt=-100;\r
1012 break;\r
1013 case 1: // -10\r
1014 fPIDnSigmaAbovePionLineTPC=-10;\r
1015 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1016 break;\r
1017 case 2: // 1\r
1018 fPIDnSigmaAbovePionLineTPC=-1;\r
1019 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1020 break;\r
1021 case 3: // 0\r
1022 fPIDnSigmaAbovePionLineTPC=0;\r
1023 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1024 break;\r
1025 case 4: // 1\r
1026 fPIDnSigmaAbovePionLineTPC=1;\r
1027 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1028 break;\r
1029 case 5: // 1\r
1030 fPIDnSigmaAbovePionLineTPC=2.;\r
1031 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1032 break;\r
1033 case 6: // 1\r
1034 fPIDnSigmaAbovePionLineTPC=2.5;\r
1035 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1036 break;\r
1037 case 7:\r
ae947965 1038 fPIDnSigmaAbovePionLineTPC = 2.0; // We need a bit less tight cut on dE/dx //Updated from 3.0 and -10 to +2.0 , +2.0 \r
1039 fPIDnSigmaAbovePionLineTPCHighPt = 2.0;\r
ccfa8c0d 1040 break;\r
1041 case 8: // 1\r
ae947965 1042 fPIDnSigmaAbovePionLineTPC = 1.5; // Updated May-16-2013 from 3.5 and -10 to +1.5, +1\r
1043 fPIDnSigmaAbovePionLineTPCHighPt = 1.0;\r
ccfa8c0d 1044 break;\r
1045 case 9: // 1\r
1046 fPIDnSigmaAbovePionLineTPC=1.5;\r
1047 fPIDnSigmaAbovePionLineTPCHighPt=-1.0;\r
1048 break;\r
1049 default:\r
1050 cout<<"Warning: pidedxSigmaCut not defined "<<pidedxSigmaCut<<endl;\r
1051 return kFALSE;\r
1052 }\r
1053 return kTRUE;\r
1054}\r
1055\r
1056///________________________________________________________________________\r
1057Bool_t AliDalitzElectronCuts::SetMinMomPiondEdxTPCCut(Int_t piMomdedxSigmaCut)\r
1058{ // Set Cut\r
1059 switch(piMomdedxSigmaCut){\r
1060 \r
1061 case 0: fPIDMinPnSigmaAbovePionLineTPC=0.;\r
1062 break;\r
1063 case 1: // 50.0 GeV\r
1064 fPIDMinPnSigmaAbovePionLineTPC=50.;\r
1065 break;\r
1066 case 2: // 20.0 GeV\r
1067 fPIDMinPnSigmaAbovePionLineTPC=20.;\r
1068 break;\r
1069 case 3: // 1.5 GeV\r
1070 fPIDMinPnSigmaAbovePionLineTPC=1.5;\r
1071 break;\r
1072 case 4: // 1. GeV\r
1073 fPIDMinPnSigmaAbovePionLineTPC=1.;\r
1074 break; \r
1075 case 5: // 0.5 GeV\r
1076 fPIDMinPnSigmaAbovePionLineTPC=0.5;\r
1077 break;\r
1078 case 6: // 0.4 GeV\r
1079 fPIDMinPnSigmaAbovePionLineTPC=0.4;\r
1080 break; \r
1081 case 7: // 0.3 GeV\r
1082 fPIDMinPnSigmaAbovePionLineTPC=0.3;\r
1083 break;\r
1084 case 8: // 0.25 GeV\r
1085 fPIDMinPnSigmaAbovePionLineTPC=0.25;\r
1086 break;\r
1087 default:\r
1088 cout<<"Warning: piMomdedxSigmaCut not defined "<<piMomdedxSigmaCut<<endl;\r
1089 return kFALSE;\r
1090 }\r
1091 return kTRUE;\r
1092}\r
1093///________________________________________________________________________\r
1094Bool_t AliDalitzElectronCuts::SetITSClusterCut(Int_t clsITSCut){\r
1095\r
1096 \r
1097 if( !fesdTrackCuts ) {\r
1098\r
1099 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;\r
1100 return kFALSE;\r
1101 }\r
1102\r
1103 switch(clsITSCut){\r
1104\r
1105 case 0: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);\r
1106 break;\r
1107 case 1: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);\r
1108 break; //1 hit first layer of SPD\r
1109 case 2: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1110 break; //1 hit in any layer of SPD\r
1111 case 3: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);\r
1112 fesdTrackCuts->SetMinNClustersITS(4);\r
1113 // 4 hits in total in the ITS. At least 1 hit in the first layer of SPD \r
1114 break;\r
1115 case 4: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1116 fesdTrackCuts->SetMinNClustersITS(3);\r
1117 // 3 hits in total in the ITS. At least 1 hit in any layer of SPD\r
1118 break;\r
1119 default:\r
1120 cout<<"Warning: clsITSCut not defined "<<clsITSCut<<endl;\r
1121 return kFALSE;\r
1122 }\r
1123 \r
1124return kTRUE;\r
1125}\r
1126\r
1127///________________________________________________________________________\r
1128Bool_t AliDalitzElectronCuts::SetTPCClusterCut(Int_t clsTPCCut)\r
1129{ // Set Cut\r
1130 switch(clsTPCCut){\r
1131 case 0: // 0\r
1132 fMinClsTPC= 0.;\r
1133 break;\r
1134 case 1: // 70\r
1135 fMinClsTPC= 70.;\r
1136 break;\r
1137 case 2: // 80\r
1138 fMinClsTPC= 80.;\r
1139 break;\r
1140 case 3: // 100\r
1141 fMinClsTPC= 100.;\r
1142 break;\r
1143 case 4: // 0% of findable clusters\r
1144 fMinClsTPCToF= 0.0;\r
1145 fUseCorrectedTPCClsInfo=0;\r
1146 break;\r
1147 case 5: // 35% of findable clusters\r
1148 fMinClsTPCToF= 0.35;\r
1149 fUseCorrectedTPCClsInfo=0;\r
1150 break;\r
1151 case 6: // 60% of findable clusters\r
1152 fMinClsTPCToF= 0.6;\r
1153 fUseCorrectedTPCClsInfo=0;\r
1154 break;\r
1155 case 7: // 70% of findable clusters\r
1156 fMinClsTPCToF= 0.7;\r
1157 fUseCorrectedTPCClsInfo=0;\r
1158 break;\r
1159 default:\r
1160 cout<<"Warning: clsTPCCut not defined "<<clsTPCCut<<endl;\r
1161 return kFALSE;\r
1162 }\r
1163 return kTRUE;\r
1164}\r
1165\r
1166///________________________________________________________________________\r
1167Bool_t AliDalitzElectronCuts::SetEtaCut(Int_t etaCut)\r
1168{ \r
1169 // Set eta Cut\r
1170 switch(etaCut){\r
0f8c33c1 1171 case 0: \r
1172 fEtaCut = 100.;\r
ae947965 1173 fDoEtaCut = kFALSE;\r
0f8c33c1 1174 break;\r
1175 case 1: // 1.4\r
1176 fEtaCut = 1.4;\r
ae947965 1177 fDoEtaCut = kTRUE;\r
0f8c33c1 1178 break;\r
1179 case 2: // 1.2\r
1180 fEtaCut = 1.2;\r
ae947965 1181 fDoEtaCut = kTRUE;\r
0f8c33c1 1182 break;\r
1183 case 3: // 0.9\r
1184 fEtaCut = 0.9;\r
ae947965 1185 fDoEtaCut = kTRUE;\r
0f8c33c1 1186 break;\r
1187 case 4: // 0.8\r
1188 fEtaCut = 0.8;\r
ae947965 1189 fDoEtaCut = kTRUE;\r
0f8c33c1 1190 break;\r
1191 case 5: // 0.75\r
1192 fEtaCut = 0.75;\r
ae947965 1193 fDoEtaCut = kTRUE;\r
1194 break;\r
1195 case 6: //0.6\r
1196 fEtaCut = 0.6; //changed from 0.4 to 0.6 2013.06.10\r
1197 fDoEtaCut = kTRUE;\r
1198 break;\r
1199 case 7: //0.5\r
1200 fEtaCut = 0.5; //changed from 0.3 to 0.5 2013.06.10\r
1201 fDoEtaCut = kTRUE;\r
0f8c33c1 1202 break;\r
1203 default:\r
1204 cout<<"Warning: EtaCut not defined "<<etaCut<<endl;\r
1205 return kFALSE;\r
1206 }\r
1207 return kTRUE;\r
ccfa8c0d 1208}\r
1209\r
ae947965 1210///________________________________________________________________________\r
1211Bool_t AliDalitzElectronCuts::SetPtCut(Int_t ptCut)\r
1212{ \r
1213 // Set Pt Cut\r
1214 //0.1GeV, 0.125 GeV, 0.15 GeV\r
1215 \r
1216 switch(ptCut){\r
1217 \r
1218 case 0: fPtCut = 0.075; \r
1219 break;\r
1220 case 1: // 0.1\r
1221 fPtCut = 0.1; \r
1222 break;\r
1223 case 2: // 0.125 GeV\r
1224 fPtCut = 0.125; \r
1225 break;\r
1226 case 3: // 0.15 GeV\r
1227 fPtCut = 0.15;\r
1228 break;\r
1229 default:\r
1230 cout<<"Warning: PtCut not defined "<<ptCut<<endl;\r
1231 return kFALSE;\r
1232 }\r
1233 return kTRUE;\r
1234}\r
1235\r
1236\r
1237///________________________________________________________________________\r
1238Bool_t AliDalitzElectronCuts::SetDCACut(Int_t dcaCut)\r
1239{ \r
1240 // Set DCA Cut\r
1241 \r
1242 if( !fesdTrackCuts ) {\r
1243\r
1244 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;\r
1245 return kFALSE;\r
1246 }\r
1247 \r
1248 switch(dcaCut){\r
1249 \r
1250 case 0: \r
1251 //Open cuts//\r
1252 fesdTrackCuts->SetMaxDCAToVertexZ(1000);\r
1253 fesdTrackCuts->SetMaxDCAToVertexXY(1000);\r
1254 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);\r
1255 break;\r
1256 \r
1257 case 1: \r
1258 fesdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");\r
1259 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);\r
1260 \r
1261 break;\r
1262 case 2: fesdTrackCuts->SetMaxDCAToVertexZ(2);\r
1263 fesdTrackCuts->SetMaxDCAToVertexXY(1);\r
1264 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);\r
1265 break; \r
1266 \r
1267 default:\r
1268 cout<<"Warning: dcaCut not defined "<<dcaCut<<endl;\r
1269 return kFALSE;\r
1270 }\r
1271 return kTRUE;\r
1272}\r
1273\r
1274\r
1275\r
1276\r
ccfa8c0d 1277///________________________________________________________________________\r
1278Bool_t AliDalitzElectronCuts::SetMaxMomPiondEdxTPCCut(Int_t piMaxMomdedxSigmaCut)\r
1279{ // Set Cut\r
1280 switch(piMaxMomdedxSigmaCut){\r
1281\r
1282 case 0: \r
1283 fPIDMaxPnSigmaAbovePionLineTPC=0.;\r
1284 break;\r
1285 case 1: // 100. GeV\r
1286 fPIDMaxPnSigmaAbovePionLineTPC=100.;\r
1287 break;\r
1288 case 2: // 5. GeV\r
1289 fPIDMaxPnSigmaAbovePionLineTPC=5.;\r
1290 break;\r
1291 case 3: // 4. GeV\r
1292 fPIDMaxPnSigmaAbovePionLineTPC=4.;\r
1293 break;\r
1294 case 4: // 3.5 GeV\r
1295 fPIDMaxPnSigmaAbovePionLineTPC=3.5;\r
1296 break;\r
1297 case 5: // 3. GeV\r
1298 fPIDMaxPnSigmaAbovePionLineTPC=3.;\r
1299 break;\r
1300 default:\r
1301 cout<<"Warning: piMaxMomdedxSigmaCut not defined "<<piMaxMomdedxSigmaCut<<endl;\r
1302 return kFALSE;\r
1303 }\r
1304 return kTRUE;\r
1305}\r
1306\r
1307///________________________________________________________________________\r
1308Bool_t AliDalitzElectronCuts::SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut)\r
1309{ // Set Cut\r
1310 switch(LowPRejectionSigmaCut){\r
1311 case 0: //\r
1312 fDoKaonRejectionLowP=kFALSE;\r
1313 fDoProtonRejectionLowP=kFALSE;\r
1314 fDoPionRejectionLowP=kFALSE;\r
1315 fPIDnSigmaAtLowPAroundKaonLine=0;\r
1316 fPIDnSigmaAtLowPAroundProtonLine=0;\r
1317 fPIDnSigmaAtLowPAroundPionLine=0;\r
ae947965 1318 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
ccfa8c0d 1319 break;\r
1320 case 1: //\r
1321 fDoKaonRejectionLowP=kTRUE;\r
1322 fDoProtonRejectionLowP=kTRUE;\r
1323 fDoPionRejectionLowP=kTRUE;\r
1324 fPIDnSigmaAtLowPAroundKaonLine=0.5;\r
1325 fPIDnSigmaAtLowPAroundProtonLine=0.5;\r
1326 fPIDnSigmaAtLowPAroundPionLine=0.5;\r
ae947965 1327 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
ccfa8c0d 1328 break;\r
1329 case 2: //\r
1330 fDoKaonRejectionLowP=kTRUE;\r
1331 fDoProtonRejectionLowP=kTRUE;\r
1332 fDoPionRejectionLowP=kTRUE;\r
ae947965 1333 fPIDnSigmaAtLowPAroundKaonLine=1.0;\r
1334 fPIDnSigmaAtLowPAroundProtonLine=1.0;\r
1335 fPIDnSigmaAtLowPAroundPionLine=1.0;\r
1336 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
ccfa8c0d 1337 break;\r
1338 case 3: //\r
1339 fDoKaonRejectionLowP=kTRUE;\r
1340 fDoProtonRejectionLowP=kTRUE;\r
1341 fDoPionRejectionLowP=kTRUE;\r
1342 fPIDnSigmaAtLowPAroundKaonLine=1.5;\r
1343 fPIDnSigmaAtLowPAroundProtonLine=1.5;\r
1344 fPIDnSigmaAtLowPAroundPionLine=1.5;\r
ae947965 1345 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
ccfa8c0d 1346 break;\r
1347 case 4: //\r
1348 fDoKaonRejectionLowP=kTRUE;\r
1349 fDoProtonRejectionLowP=kTRUE;\r
1350 fDoPionRejectionLowP=kTRUE;\r
1351 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1352 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1353 fPIDnSigmaAtLowPAroundPionLine=2.0;\r
ae947965 1354 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
ccfa8c0d 1355 break;\r
1356 case 5: //\r
1357 fDoKaonRejectionLowP=kTRUE;\r
1358 fDoProtonRejectionLowP=kTRUE;\r
1359 fDoPionRejectionLowP=kTRUE;\r
1360 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1361 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1362 fPIDnSigmaAtLowPAroundPionLine=2.5;\r
ae947965 1363 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
ccfa8c0d 1364 break;\r
1365 case 6: //\r
1366 fDoKaonRejectionLowP=kTRUE;\r
1367 fDoProtonRejectionLowP=kTRUE;\r
1368 fDoPionRejectionLowP=kTRUE;\r
1369 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1370 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1371 fPIDnSigmaAtLowPAroundPionLine=2.;\r
ae947965 1372 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
ccfa8c0d 1373 break;\r
1374 case 7: //\r
1375 fDoKaonRejectionLowP=kFALSE;\r
1376 fDoProtonRejectionLowP=kFALSE;\r
1377 fDoPionRejectionLowP=kTRUE;\r
1378 fPIDnSigmaAtLowPAroundKaonLine=0.0;\r
1379 fPIDnSigmaAtLowPAroundProtonLine=0.0;\r
1380 fPIDnSigmaAtLowPAroundPionLine=1.0;\r
ae947965 1381 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
ccfa8c0d 1382 break;\r
1383 case 8:\r
1384 fDoKaonRejectionLowP=kFALSE;\r
1385 fDoProtonRejectionLowP=kFALSE;\r
1386 fDoPionRejectionLowP=kTRUE;\r
1387 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1388 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1389 fPIDnSigmaAtLowPAroundPionLine=0.5; \r
ae947965 1390 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
ccfa8c0d 1391 break; \r
1392 default:\r
1393 cout<<"Warning: LowPRejectionSigmaCut not defined "<<LowPRejectionSigmaCut<<endl;\r
1394 return kFALSE;\r
1395 }\r
1396 return kTRUE;\r
1397}\r
1398\r
1399///________________________________________________________________________\r
1400Bool_t AliDalitzElectronCuts::SetTOFElectronPIDCut(Int_t TOFelectronPID){\r
1401 // Set Cut\r
1402 switch(TOFelectronPID){ // RRnewTOF start //////////////////////////////////////////////////////////////////////////\r
1403 case 0: // no cut\r
1404 fRequireTOF = kFALSE;\r
1405 fUseTOFpid = kFALSE;\r
1406 fTofPIDnSigmaBelowElectronLine=-100;\r
1407 fTofPIDnSigmaAboveElectronLine=100;\r
1408 break;\r
1409 case 1: // -7,7\r
1410 fRequireTOF = kFALSE;\r
1411 fUseTOFpid = kTRUE;\r
1412 fTofPIDnSigmaBelowElectronLine=-7;\r
1413 fTofPIDnSigmaAboveElectronLine=7;\r
1414 break;\r
1415 case 2: // -5,5\r
1416 fRequireTOF = kFALSE;\r
1417 fUseTOFpid = kTRUE;\r
1418 fTofPIDnSigmaBelowElectronLine=-5;\r
1419 fTofPIDnSigmaAboveElectronLine=5;\r
1420 break;\r
1421 case 3: // -3,5\r
1422 fRequireTOF = kFALSE;\r
1423 fUseTOFpid = kTRUE;\r
1424 fTofPIDnSigmaBelowElectronLine=-3;\r
1425 fTofPIDnSigmaAboveElectronLine=5;\r
1426 break;\r
1427 case 4: // -2,3\r
1428 fRequireTOF = kFALSE;\r
1429 fUseTOFpid = kTRUE;\r
1430 fTofPIDnSigmaBelowElectronLine=-2;\r
1431 fTofPIDnSigmaAboveElectronLine=3;\r
1432 break;\r
1433 case 5: // -3, 3 TOF mandatory\r
1434 fRequireTOF = kTRUE;\r
1435 fUseTOFpid = kTRUE;\r
1436 fTofPIDnSigmaBelowElectronLine= -3;\r
1437 fTofPIDnSigmaAboveElectronLine= 3;\r
1438 break;\r
1439 default:\r
1440 cout<<"Warning: TOFElectronCut not defined "<<TOFelectronPID<<endl;\r
1441 return kFALSE;\r
1442 } //////////////////////// RRnewTOF end //////////////////////////////////////////////////////////////////////////\r
1443 return kTRUE;\r
1444}\r
1445///_______________________________________________________________________________\r
1446\r
1447Bool_t AliDalitzElectronCuts::SetPsiPairCut(Int_t psiCut) {\r
1448 \r
1449\r
1450 switch(psiCut) {\r
1451 case 0:\r
1452 fDoPsiPairCut = kFALSE;\r
1453 fPsiPairCut = 10000.; //\r
1454 fDeltaPhiCutMin = -1000.;\r
1455 fDeltaPhiCutMax = 1000.;\r
1456 \r
1457 break;\r
1458 case 1:\r
1459 fDoPsiPairCut = kTRUE;\r
1460 fPsiPairCut = 0.45; // Standard\r
1461 fDeltaPhiCutMin = 0.;\r
1462 fDeltaPhiCutMax = 0.12;\r
1463 break;\r
1464 default:\r
1465 cout<<"Warning: PsiPairCut not defined "<<fPsiPairCut<<endl;\r
1466 return kFALSE;\r
1467 }\r
1468\r
1469 return kTRUE;\r
1470}\r
1471\r
1472///_______________________________________________________________________________\r
1473Bool_t AliDalitzElectronCuts::SetRejectSharedElecGamma(Int_t RCut) {\r
1474 \r
1475\r
1476 switch(RCut) {\r
1477 case 0:\r
1478 fDoRejectSharedElecGamma = kFALSE;\r
1479 fRadiusCut = 10000; // \r
1480 break;\r
1481 case 1:\r
1482 fDoRejectSharedElecGamma = kTRUE;\r
1483 fRadiusCut = 2.0; // cm \r
1484 break;\r
1485 case 2:\r
1486 fDoRejectSharedElecGamma = kTRUE;\r
1487 fRadiusCut = 3.0; // Standard\r
1488 break;\r
1489 case 3:\r
1490 fDoRejectSharedElecGamma = kTRUE;\r
1491 fRadiusCut = 4.0; // \r
1492 break;\r
1493 case 4:\r
1494 fDoRejectSharedElecGamma = kTRUE;\r
1495 fRadiusCut = 5.0; // \r
1496 break;\r
1497 case 5:\r
1498 fDoRejectSharedElecGamma = kTRUE;\r
1499 fRadiusCut = 10.0; // \r
1500 break;\r
1501 case 6:\r
1502 fDoRejectSharedElecGamma = kTRUE;\r
1503 fRadiusCut = 15.0; // \r
1504 break;\r
1505 default:\r
1506 cout<<"Warning: PsiPairCut not defined "<<fDoRejectSharedElecGamma<<endl;\r
1507 return kFALSE;\r
1508 }\r
1509\r
1510 return kTRUE;\r
1511}\r
1512///__________________________________________________________________________\r
1513Bool_t AliDalitzElectronCuts::SetBackgroundScheme(Int_t BackgroundScheme){\r
1514\r
1515 // Set Cut\r
1516 switch(BackgroundScheme){\r
1517\r
1518 case 0: //Rotation\r
1519 fBKGMethod = 0;\r
1520 fUseTrackMultiplicityForBG = kFALSE;\r
1521 break;\r
1522 case 1: // mixed event with V0 multiplicity\r
1523 fBKGMethod = 1;\r
1524 fUseTrackMultiplicityForBG = kFALSE;\r
1525 break;\r
1526 case 2: // mixed event with track multiplicity\r
1527 fUseTrackMultiplicityForBG = kTRUE;\r
1528 fBKGMethod = 1;\r
1529 break;\r
1530 case 3: //Rotation\r
1531 fUseTrackMultiplicityForBG = kFALSE;\r
1532 fBKGMethod = 2;\r
1533 break;\r
1534 case 4: //Rotation\r
1535 fUseTrackMultiplicityForBG = kTRUE;\r
1536 fBKGMethod = 2;\r
1537 break;\r
1538 case 5: fUseTrackMultiplicityForBG = kTRUE;\r
1539 fBKGMethod = 3;\r
1540 break;\r
1541\r
1542 default:\r
1543 cout<<"Warning: BackgroundScheme not defined "<<BackgroundScheme<<endl;\r
1544 return kFALSE;\r
1545 }\r
1546 return kTRUE;\r
1547}\r
1548\r
1549///________________________________________________________________________\r
1550Bool_t AliDalitzElectronCuts::SetNumberOfRotations(Int_t NumberOfRotations)\r
1551{ // Set Cut\r
1552 switch(NumberOfRotations){\r
1553 case 0:\r
1554 fnumberOfRotationEventsForBG = 5;\r
1555 break;\r
1556 case 1:\r
1557 fnumberOfRotationEventsForBG = 10;\r
1558 break;\r
1559 case 2:\r
1560 fnumberOfRotationEventsForBG = 15;\r
1561 break;\r
1562 case 3:\r
1563 fnumberOfRotationEventsForBG = 20;\r
1564 break;\r
1565 case 4:\r
1566 fnumberOfRotationEventsForBG = 2;\r
1567 break;\r
1568 case 5:\r
1569 fnumberOfRotationEventsForBG = 50;\r
1570 break;\r
1571 case 6:\r
1572 fnumberOfRotationEventsForBG = 80;\r
1573 break;\r
1574 case 7:\r
1575 fnumberOfRotationEventsForBG = 100;\r
1576 break;\r
1577 default:\r
1578 cout<<"Warning: NumberOfRotations not defined "<<NumberOfRotations<<endl;\r
1579 return kFALSE;\r
1580 }\r
1581 return kTRUE;\r
1582}\r
ae947965 1583\r
1584\r
1585\r
1586///________________________________________________________________________\r
1587Bool_t AliDalitzElectronCuts::SetMassCut(Int_t massCut)\r
1588{ // Set Cut\r
1589 switch(massCut){\r
1590 \r
1591 case 0:\r
1592 fMassCut = 999.;\r
1593 fDoMassCut = kFALSE; \r
1594 break;\r
1595 case 1:\r
1596 fMassCut = 0.135; //GeV/c^2\r
1597 fDoMassCut = kTRUE;\r
1598 break; \r
1599 case 2:\r
1600 fMassCut = 0.100; //GeV/c^2\r
1601 fDoMassCut = kTRUE;\r
1602 break;\r
1603 case 3:\r
1604 fMassCut = 0.075; //GeV/c^2\r
1605 fDoMassCut = kTRUE;\r
1606 break;\r
1186afd2 1607 case 4:\r
1608 fMassCut = 0.050; //GeV/c^2\r
1609 fDoMassCut = kTRUE;\r
1610 break;\r
1611 case 5:\r
1612 fMassCut = 0.035; //GeV/c^2\r
1613 fDoMassCut = kTRUE;\r
1614 break;\r
ae947965 1615 default:\r
1616 cout<<"Warning: MassCut not defined "<<massCut<<endl;\r
1617 return kFALSE;\r
1618 }\r
1619 return kTRUE;\r
1620}\r
1621\r
ccfa8c0d 1622///________________________________________________________________________\r
1623TString AliDalitzElectronCuts::GetCutNumber(){\r
1624 // returns TString with current cut number\r
1625 TString a(kNCuts);\r
1626 for(Int_t ii=0;ii<kNCuts;ii++){\r
1627 a.Append(Form("%d",fCuts[ii]));\r
1628 }\r
1629 return a;\r
1630}\r
1631\r
1632\r
1633///________________________________________________________________________\r
1634AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010PbPb(){\r
1635 //Create and return standard 2010 PbPb cuts\r
1636 AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010PbPb","StandardCuts2010PbPb");\r
1637 if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1638 cout<<"Warning: Initialization of Standardcuts2010PbPb failed"<<endl;}\r
1639 return cuts;\r
1640}\r
1641\r
1642///________________________________________________________________________\r
1643AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010pp(){\r
1644 //Create and return standard 2010 PbPb cuts\r
1645 AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010pp","StandardCuts2010pp");\r
1646 \r
1647 if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1648 cout<<"Warning: Initialization of Standardcuts2010pp failed"<<endl;}\r
1649 return cuts;\r
1650}\r
1651\r