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