]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGUD/multVScentPbPb/AliTaskGlobVar.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ATO-98 AddCorrectionCompact with full test OK
[u/mrichter/AliRoot.git] / PWGUD / multVScentPbPb / AliTaskGlobVar.cxx
CommitLineData
a9a39f46 1/*************************************************************************
2* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
3* *
4* Author: The ALICE Off-line Project. *
5* Contributors are mentioned in the code where appropriate. *
6* *
7* Permission to use, copy, modify and distribute this software and its *
8* documentation strictly for non-commercial purposes is hereby granted *
9* without fee, provided that the above copyright notice appears in all *
10* copies and that both the copyright notice and this permission notice *
11* appear in the supporting documentation. The authors make no claims *
12* about the suitability of this software for any purpose. It is *
13* provided "as is" without express or implied warranty. *
14**************************************************************************/
15
16///////////////////////////////////////////////////////////////////////////
17// Analysis task to extract global variables to the tree //
18///////////////////////////////////////////////////////////////////////////
19
20#include <TChain.h>
21#include <TFile.h>
22#include <TString.h>
23#include <TTree.h>
24#include <TList.h>
25#include <TObjArray.h>
26#include "AliAnalysisManager.h"
27#include "AliMultiplicity.h"
28#include "AliESDEvent.h"
29#include "AliESDInputHandler.h"
30#include "AliESDVZERO.h"
31#include "AliESDZDC.h"
32#include "AliMCEventHandler.h"
33#include "AliMCEvent.h"
34#include "AliMCParticle.h"
35#include "AliStack.h"
36#include "AliGenEventHeader.h"
37#include "AliLog.h"
38#include "AliPhysicsSelection.h"
96a38ef0 39#include "AliCentrality.h"
a9a39f46 40#include "AliESDtrackCuts.h"
41#include "AliTaskGlobVar.h"
42#include "AliGenEventHeader.h"
43#include "AliGenHijingEventHeader.h"
44#include "AliGenDPMjetEventHeader.h"
c79a7c1c 45#include "AliTriggerAnalysis.h"
a9a39f46 46
47
48ClassImp(AliTaskGlobVar)
49
50
a9a39f46 51//________________________________________________________________________
52AliTaskGlobVar::AliTaskGlobVar(const char *name)
53 : AliAnalysisTaskSE(name),
54 //
55 fUseMC(kFALSE),
56 fOutput(0),
57 fOutTree(0),
58 fTrackCuts(0),
c79a7c1c 59 fTrackCuts1(0),
60 fGlobVars()
a9a39f46 61{
62 // Constructor
63 DefineOutput(1, TList::Class());
64 //
65}
66
67//________________________________________________________________________
68AliTaskGlobVar::~AliTaskGlobVar()
69{
70 // Destructor
71 // histograms are in the output list and deleted when the output
72 // list is deleted by the TSelector dtor
73 if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { //RRR
74 printf("Deleteing output\n");
75 delete fOutput;
a9a39f46 76 }
77 //
78}
79
80//________________________________________________________________________
81void AliTaskGlobVar::UserCreateOutputObjects()
82{
c79a7c1c 83 // create ouptut
a9a39f46 84 fOutput = new TList();
85 fOutput->SetOwner();
86 //
87 fOutTree = new TTree("globTree","globTree");
96a38ef0 88 fOutTree->Branch("g",&fGlobVars,"runID/I:timeStamp/i:zdcNA/F:zdcPA/F:zdcNC/F:zdcPC/F:zdcNAC/F:zdcNCC/F:zem1/F:zem2/F:zvSPD/F:zvTPC/F:chunk/S:flags/S"
a9a39f46 89 ":spd1/S:spd2/S:ncontSPDV/S:ncontTPCV/S:nTrTPC/S:nTrTPCITS/S:nTracklets/S:v0A/S:v0C/S:v0Corr/S", 16777216);
90
91 if (fUseMC) {
c79a7c1c 92 fOutTree->Branch("gmc",&fGlobVars.mcZV,"mcZV/F:mcdNdEta/S:mcNPart/S:mcNBColl/S", 16777216);
a9a39f46 93 }
94 fOutput->Add(fOutTree);
95 //
96 // fTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
97 fTrackCuts = CreatedNdPtTrackCuts(23);
98 fTrackCuts->SetEtaRange(-0.8,0.8);
99 fTrackCuts1 = CreatedNdPtTrackCuts(72);
100 fTrackCuts1->SetEtaRange(-0.8,0.8);
101 //
102 PostData(1, fOutput);
103 printf("CreatingXXX\n");
104 //
105}
106
107//________________________________________________________________________
108void AliTaskGlobVar::UserExec(Option_t *)
109{
110 // Main loop
111 //
112 AliAnalysisManager* anMan = AliAnalysisManager::GetAnalysisManager();
113 AliESDInputHandler *hand = (AliESDInputHandler*)anMan->GetInputEventHandler();
114 if (!hand) { printf("No ESD handler\n"); return; }
115 AliESDEvent *esd = hand->GetEvent();
116 if (!esd) { printf("No AliESDEvent\n"); return; }
117 //
118 if (!fUseMC && !ZDCTimeTrigger(esd)) return;
119 //
120 const AliESDVertex* vtxESD = esd->GetPrimaryVertexSPD();
121 Bool_t vtxOK = kTRUE;
122 if (vtxESD->GetNContributors()<1) vtxOK = kFALSE; //return;
123 if (vtxESD->GetDispersion()>0.04) vtxOK = kFALSE; //return;
124 if (vtxESD->GetZRes()>0.25) vtxOK = kFALSE; //return;
125 const AliMultiplicity* multESD = esd->GetMultiplicity();
126 const AliESDVertex* vtxESDTPC = esd->GetPrimaryVertexTPC();
127 // if (vtxESDTPC->GetNContributors()<1) return;
128 // if (vtxESDTPC->GetNContributors()<(-10.+0.25*multESD->GetNumberOfITSClusters(0))) return;
129 //
c79a7c1c 130 fGlobVars.runID = esd->GetRunNumber();
a9a39f46 131 TString rid = "";
c79a7c1c 132 rid += fGlobVars.runID;
a9a39f46 133 TString flname = hand->GetTree()->GetCurrentFile()->GetName();
c79a7c1c 134 fGlobVars.chunk = 0;
a9a39f46 135 int id = 0;
136 while ( (id=flname.Index(rid))>=0 ) flname = flname.Data()+id+rid.Length();
137 id = flname.First('.');
138 if (id>=0) {
139 flname = flname.Data() + id+1;
c79a7c1c 140 fGlobVars.chunk = (Short_t)flname.Atoi();
a9a39f46 141 }
c79a7c1c 142 // printf("%d %s\n",fGlobVars.chunk,hand->GetTree()->GetCurrentFile()->GetName());
143 //
144 fGlobVars.timeStamp = esd->GetTimeStamp();
145 fGlobVars.timeStamp = esd->GetTimeStamp();
146 fGlobVars.zvSPD = vtxESD->GetZ();
147 fGlobVars.zvTPC = vtxESDTPC->GetZ();
148 fGlobVars.ncontSPDV = (Short_t)vtxESD->GetNContributors();
149 fGlobVars.ncontTPCV = (Short_t)vtxESDTPC->GetNContributors();
150 // fGlobVars.nTrTPC = fTrackCuts ? (Short_t)fTrackCuts->GetReferenceMultiplicity(esd,kTRUE):-1;
151 fGlobVars.nTrTPC = fTrackCuts ? (Short_t)fTrackCuts->CountAcceptedTracks(esd):-1;
152 fGlobVars.nTrTPCITS = fTrackCuts1 ? (Short_t)fTrackCuts1->CountAcceptedTracks(esd):-1;
153 fGlobVars.nTracklets = multESD->GetNumberOfTracklets();
a9a39f46 154 //
155 AliESDVZERO* esdV0 = esd->GetVZEROData();
156 if (esdV0) {
c79a7c1c 157 fGlobVars.v0A = (Short_t)esdV0->GetMTotV0A();
158 fGlobVars.v0C = (Short_t)esdV0->GetMTotV0C();
a9a39f46 159 }
c79a7c1c 160 else fGlobVars.v0A = fGlobVars.v0C = 0;
a9a39f46 161 //
c79a7c1c 162 fGlobVars.spd1 = (Short_t)multESD->GetNumberOfITSClusters(0);
163 fGlobVars.spd2 = (Short_t)multESD->GetNumberOfITSClusters(1);
a9a39f46 164 //
165 float v0Corr,v0CorrR;
cccba477 166 // v0Corr = GetCorrV0(esd,v0CorrR); MF: Deprecated: V0corr isnot needed any more
96a38ef0 167 v0Corr = esdV0->GetMTotV0A() + esdV0->GetMTotV0C();
c79a7c1c 168 fGlobVars.v0Corr = (Short_t)v0Corr;
169 // fGlobVars.v0CorrResc = (Short_t)v0CorrR;
a9a39f46 170
171 //---------------------------------------------
172 AliESDZDC *esdZDC = esd->GetESDZDC();
173 // --- ZDC offline trigger ---
174 // Returns if ZDC triggered, based on TDC information
175 Bool_t tdc[32] = {kFALSE};
176 for(Int_t itdc=0; itdc<32; itdc++){
177 for(Int_t i=0; i<4; i++){
178 if (0.025*esdZDC->GetZDCTDCData(itdc, i) != 0){
179 tdc[itdc] = kTRUE;
180 }
181 }
182 }
c79a7c1c 183 fGlobVars.flags = 0;
184 if ( tdc[12] ) fGlobVars.flags |= GloVars_t::kTDCNA; // Bool_t zdcNA = tdc[12];
185 if ( tdc[10] ) fGlobVars.flags |= GloVars_t::kTDCNC; // Bool_t zdcNC = tdc[10];
186 if ( tdc[13] ) fGlobVars.flags |= GloVars_t::kTDCPA; // Bool_t zdcPA = tdc[13];
187 if ( tdc[11] ) fGlobVars.flags |= GloVars_t::kTDCPC; // Bool_t zdcPC = tdc[11];
188 if ( vtxOK ) fGlobVars.flags |= GloVars_t::kSPDVTXOK;
189 //
96a38ef0 190
191 const Double_t * towZNC = esdZDC->GetZN1TowerEnergy();
192 const Double_t * towZPC = esdZDC->GetZP1TowerEnergy();
193 const Double_t * towZNA = esdZDC->GetZN2TowerEnergy();
194 const Double_t * towZPA = esdZDC->GetZP2TowerEnergy();
195
196 fGlobVars.zdcNC = (Float_t) (esdZDC->GetZDCN1Energy());
197 fGlobVars.zdcPC = (Float_t) (esdZDC->GetZDCP1Energy());
198 fGlobVars.zdcNA = (Float_t) (esdZDC->GetZDCN2Energy());
199 fGlobVars.zdcPA = (Float_t) (esdZDC->GetZDCP2Energy());
200
201 fGlobVars.zdcNCC = (Float_t) (towZNC[0]);
202 fGlobVars.zdcNAC = (Float_t) (towZNA[0]);
203
204
c79a7c1c 205 fGlobVars.zem1 = (Float_t) (esdZDC->GetZDCEMEnergy(0)) /8.;
206 fGlobVars.zem2 = (Float_t) (esdZDC->GetZDCEMEnergy(1)) /8.;
96a38ef0 207
208
209
a9a39f46 210 //-----------------------------------------------
211 //
212 // ---------------------- MC ONLY -------------------------------
213 AliMCEventHandler* eventHandler = (AliMCEventHandler*)anMan->GetMCtruthEventHandler();
214 AliStack* stack=0;
215 AliMCEvent* mcEvent=0;
c79a7c1c 216 fGlobVars.mcdNdEta = 0;
217 fGlobVars.mcNPart = 0;
218 fGlobVars.mcNBColl = 0;
a9a39f46 219 if (fUseMC && eventHandler && (mcEvent=eventHandler->MCEvent()) && (stack=mcEvent->Stack())) {
220 int ntr = stack->GetNtrack();
221 for (int itr=ntr;itr--;) {
222 if (!stack->IsPhysicalPrimary(itr)) continue;
223 AliMCParticle *part = (AliMCParticle*)mcEvent->GetTrack(itr);
224 if (!part || !part->Charge()) continue;
225 Float_t eta = part->Eta();
226 if (TMath::Abs(eta)>0.5) continue;
c79a7c1c 227 fGlobVars.mcdNdEta++;
a9a39f46 228 }
229 //
230 AliGenEventHeader* mcGenH = mcEvent->GenEventHeader();
231 if (mcGenH->InheritsFrom(AliGenHijingEventHeader::Class())) {
232 AliGenHijingEventHeader* hHijing = (AliGenHijingEventHeader*)mcGenH;
c79a7c1c 233 fGlobVars.mcNPart = (hHijing->ProjectileParticipants()+hHijing->TargetParticipants())/2.;
234 fGlobVars.mcNBColl = hHijing->NN()+hHijing->NNw()+hHijing->NwN()+hHijing->NwNw();
a9a39f46 235 }
236 else if (mcGenH->InheritsFrom(AliGenDPMjetEventHeader::Class())) {
237 AliGenDPMjetEventHeader* hDpmJet = (AliGenDPMjetEventHeader*)mcGenH;
c79a7c1c 238 fGlobVars.mcNPart = (hDpmJet->ProjectileParticipants()+hDpmJet->TargetParticipants())/2.;
239 fGlobVars.mcNBColl = hDpmJet->NN()+hDpmJet->NNw()+hDpmJet->NwN()+hDpmJet->NwNw();
a9a39f46 240 }
241 else {} // unknown generator
242 //
243 TArrayF vtxMC;
244 mcGenH->PrimaryVertex(vtxMC);
c79a7c1c 245 fGlobVars.mcZV = vtxMC[2];
a9a39f46 246 }
247 //
248 fOutTree->Fill();
249 //
250}
251//________________________________________________________________________
252void AliTaskGlobVar::Terminate(Option_t *)
253{
c79a7c1c 254 // print itself
a9a39f46 255 Printf("Terminating...");
256 // AliAnalysisTaskSE::Terminate();
257}
258
259
260//________________________________________________________________________
261Float_t AliTaskGlobVar::GetCorrV0(const AliESDEvent* esd, float &v0CorrResc) const
262{
263 // correct V0 non-linearity, prepare a version rescaled to SPD2 corr
264 const Double_t par0[64] = { 6.71e-02 , 6.86e-02 , 7.06e-02 , 6.32e-02 ,
265 5.91e-02 , 6.07e-02 , 5.78e-02 , 5.73e-02 , 5.91e-02 , 6.22e-02 ,
266 5.90e-02 , 6.11e-02 , 5.55e-02 , 5.29e-02 , 5.19e-02 , 5.56e-02 ,
267 6.25e-02 , 7.03e-02 , 5.64e-02 , 5.81e-02 , 4.57e-02 , 5.30e-02 ,
268 5.13e-02 , 6.43e-02 , 6.27e-02 , 6.48e-02 , 6.07e-02 , 1.01e-01 ,
269 6.68e-02 , 7.16e-02 , 6.36e-02 , 5.95e-02 , 2.52e-02 , 2.82e-02 ,
270 2.56e-02 , 2.86e-02 , 2.82e-02 , 2.10e-02 , 2.13e-02 , 2.32e-02 ,
271 2.75e-02 , 4.34e-02 , 3.78e-02 , 4.52e-02 , 4.11e-02 , 3.89e-02 ,
272 4.10e-02 , 3.73e-02 , 4.51e-02 , 5.07e-02 , 5.42e-02 , 4.74e-02 ,
273 4.33e-02 , 4.44e-02 , 4.64e-02 , 3.01e-02 , 6.38e-02 , 5.26e-02 ,
274 4.99e-02 , 5.26e-02 , 5.47e-02 , 3.84e-02 , 5.00e-02 , 5.20e-02 };
275 const Double_t par1[64] = { -6.68e-05 , -7.78e-05 , -6.88e-05 , -5.92e-05 ,
276 -2.43e-05 , -3.54e-05 , -2.91e-05 , -1.99e-05 , -1.40e-05 , -4.01e-05 ,
277 -2.29e-05 , -3.68e-05 , -2.53e-05 , -2.44e-06 , -9.22e-06 , -1.51e-05 ,
278 -2.80e-05 , -2.34e-05 , -1.72e-05 , -1.81e-05 , -1.29e-05 , -2.65e-05 ,
279 -1.61e-05 , -2.86e-05 , -1.74e-05 , -4.23e-05 , -3.41e-05 , -1.05e-04 ,
280 -2.76e-05 , -4.71e-05 , -3.06e-05 , -2.32e-05 , -1.55e-06 , 2.15e-05 ,
281 1.40e-05 , 2.16e-05 , 1.21e-05 , 3.05e-06 , 1.67e-05 , -3.84e-06 ,
282 3.09e-06 , 1.50e-05 , 3.47e-06 , 4.87e-06 , -3.71e-07 , -1.75e-06 ,
283 -1.80e-06 , 9.99e-06 , -6.46e-06 , -4.91e-06 , 1.33e-05 , -2.52e-07 ,
284 -3.85e-06 , 4.94e-06 , -2.48e-07 , -1.20e-05 , 2.07e-06 , 6.12e-06 ,
285 -1.18e-06 , 4.54e-06 , -1.54e-05 , -1.25e-05 , 1.46e-06 , -6.67e-06 };
286 const Double_t par2[64] = { 1.29e-08 , 1.51e-08 , 1.43e-08 , 1.11e-08 ,
287 5.04e-09 , 6.99e-09 , 5.58e-09 , 4.15e-09 , 4.00e-09 , 8.22e-09 ,
288 4.97e-09 , 7.66e-09 , 4.91e-09 , 1.10e-09 , 2.64e-09 , 3.64e-09 ,
289 5.76e-09 , 5.46e-09 , 3.38e-09 , 3.47e-09 , 2.43e-09 , 4.13e-09 ,
290 2.80e-09 , 5.80e-09 , 3.86e-09 , 7.46e-09 , 5.98e-09 , 2.58e-08 ,
291 5.50e-09 , 8.72e-09 , 5.23e-09 , 4.37e-09 , 2.33e-09 , -6.01e-10 ,
292 3.99e-11 , -2.02e-10 , 7.67e-10 , 2.03e-09 , 1.17e-10 , 2.56e-09 ,
293 1.16e-09 , -4.75e-10 , 1.28e-09 , 1.23e-09 , 1.62e-09 , 1.61e-09 ,
294 1.93e-09 , 2.97e-10 , 2.21e-09 , 2.16e-09 , 5.22e-10 , 1.03e-09 ,
295 1.56e-09 , 5.00e-10 , 1.01e-09 , 2.93e-09 , 1.05e-09 , 9.96e-11 ,
296 1.21e-09 , 7.45e-10 , 3.07e-09 , 2.31e-09 , 6.70e-10 , 1.89e-09 };
297 //
298 Float_t multCorr = 0;
299 Float_t multCorr2 = 0;
300 Float_t multChCorr[64];
301 AliESDVZERO* esdV0 = esd->GetVZEROData();
302 for(Int_t i = 0; i < 64; ++i) {
303 Double_t b = (esdV0->GetMultiplicity(i)*par1[i]-par0[i]);
304 Double_t s = (b*b-4.*par2[i]*esdV0->GetMultiplicity(i)*esdV0->GetMultiplicity(i));
305 Double_t n;
306 if (s<0) {
307 printf("FPE %d %.2f %.2f %.2e\n",i,esdV0->GetMultiplicity(i),b,(b*b-4.*par2[i]*esdV0->GetMultiplicity(i)*esdV0->GetMultiplicity(i)));
308 n = -b;
309 }
310 else {
311 n = (-b + TMath::Sqrt(s));
312 }
313 multChCorr[i] = 2.*esdV0->GetMultiplicity(i)/n*par0[i];
314 multCorr += multChCorr[i];
315 multCorr2 += (multChCorr[i]/par0[i]/64.);
316 }
317 v0CorrResc = multCorr2;
318 return multCorr;
319}
320
321//_________________________________________________________________
322Bool_t AliTaskGlobVar::ZDCTimeTrigger(const AliESDEvent *aEsd) const
323{
324 // This method implements a selection
325 // based on the timing in both sides of zdcN
326 // It can be used in order to eliminate
327 // parasitic collisions
328 Bool_t zdcAccept = kFALSE;
329
330 AliESDZDC *esdZDC = aEsd->GetESDZDC();
331
332 const Float_t refSum = -568.5;
333 const Float_t refDelta = -2.1;
334 const Float_t sigmaSum = 3.25;
335 const Float_t sigmaDelta = 2.25;
336 for(Int_t i = 0; i < 4; ++i) {
337 if (esdZDC->GetZDCTDCData(10,i) != 0) {
338 Float_t tdcC = 0.025*(esdZDC->GetZDCTDCData(10,i)-esdZDC->GetZDCTDCData(14,i));
339 for(Int_t j = 0; j < 4; ++j) {
340 if (esdZDC->GetZDCTDCData(12,j) != 0) {
341 Float_t tdcA = 0.025*(esdZDC->GetZDCTDCData(12,j)-esdZDC->GetZDCTDCData(14,j));
342 if (((tdcC-tdcA-refDelta)*(tdcC-tdcA-refDelta)/(sigmaDelta*sigmaDelta) +
343 (tdcC+tdcA-refSum)*(tdcC+tdcA-refSum)/(sigmaSum*sigmaSum))< 1.0)
344 zdcAccept = kTRUE;
345 }
346 }
347 }
348 }
349 return zdcAccept;
350}
351
352
353AliESDtrackCuts* AliTaskGlobVar::CreatedNdPtTrackCuts(Int_t cutMode, Bool_t fieldOn)
354{
355 // copy of PWG0/dNdPt/macros/CreatedNdPtTrackCuts.C
356 //
357 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");
358
359
360 Double_t cov1, cov2, cov3, cov4, cov5;
361 Double_t nSigma;
362 Double_t maxDCAtoVertex, maxDCAtoVertexXY, maxDCAtoVertexZ;
363 Int_t minNClustersTPC;
364 Double_t maxChi2PerClusterTPC;
365 Double_t minPt, maxPt;
366 TString tag;
367
368 // default cuts for ITS+TPC
369 if (cutMode == 0)
370 {
371 cov1 = 2;
372 cov2 = 2;
373 cov3 = 0.5;
374 cov4 = 0.5;
375 cov5 = 2;
376 nSigma = 3;
377 minNClustersTPC = 50;
378 maxChi2PerClusterTPC = 3.5;
379
380 esdTrackCuts->SetMaxCovDiagonalElements(cov1, cov2, cov3, cov4, cov5);
381 // esdTrackCuts->SetMinNsigmaToVertex(nSigma);
382 esdTrackCuts->SetRequireSigmaToVertex(kTRUE);
383 esdTrackCuts->SetRequireTPCRefit(kTRUE);
384 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
385 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
386 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
387
388 tag = "Global tracking";
389 }
390
391 // TPC-only cuts (vertex n sigma cut)
392 if (cutMode == 1)
393 {
394 // beta cuts (still under investigation)
395 //cov1 = 4;
396 //cov2 = 4;
397 cov1 = 2;
398 cov2 = 2;
399 cov3 = 0.5;
400 cov4 = 0.5;
401 cov5 = 2;
402 nSigma = 4;
403 minNClustersTPC = 50;
404 maxChi2PerClusterTPC = 3.5;
405
406 esdTrackCuts->SetMaxCovDiagonalElements(cov1, cov2, cov3, cov4, cov5);
407 // esdTrackCuts->SetMinNsigmaToVertex(nSigma);
408 esdTrackCuts->SetRequireSigmaToVertex(kTRUE);
409 esdTrackCuts->SetRequireTPCRefit(kFALSE);
410 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
411 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
412 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
413
414 tag = "TPC-only tracking";
415 }
416
417 // TPC-only cuts (vertex maxDCAtoVertex cut)
418 if (cutMode == 2)
419 {
420 // beta cuts (still under investigation)
421 maxDCAtoVertex = 3.0; // cm
422 minNClustersTPC = 50;
423 maxChi2PerClusterTPC = 3.5;
424
425 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
426 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertex);
427 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertex);
428 esdTrackCuts->SetRequireTPCRefit(kFALSE);
429 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
430 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
431 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
432
433 tag = "TPC-only tracking";
434 }
435
436 // TPC-only no vertex cuts
437 if (cutMode == 3)
438 {
439 // beta cuts (still under investigation)
440 minNClustersTPC = 50;
441 maxChi2PerClusterTPC = 3.5;
442
443 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
444 esdTrackCuts->SetRequireTPCRefit(kFALSE);
445 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
446 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
447 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
448
449 tag = "TPC-only tracking";
450 }
451
452 // TPC-only no cuts at all
453 if (cutMode == 4)
454 {
455
456 // beta cuts (still under investigation)
457 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
458 esdTrackCuts->SetRequireTPCRefit(kFALSE);
459 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
460
461 tag = "TPC-only tracking";
462 }
463
464 // TPC-only no kink removal no chi2
465 if (cutMode == 5)
466 {
467 // beta cuts (still under investigation)
468 minNClustersTPC = 50;
469 //maxChi2PerClusterTPC = 3.5;
470
471 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
472 esdTrackCuts->SetRequireTPCRefit(kFALSE);
473 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
474 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
475 //esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
476
477 tag = "TPC-only tracking";
478 }
479
480 // TPC-only no kink removal
481 if (cutMode == 6)
482 {
483 // beta cuts (still under investigation)
484 minNClustersTPC = 50;
485 maxChi2PerClusterTPC = 3.5;
486
487 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
488 esdTrackCuts->SetRequireTPCRefit(kFALSE);
489 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
490 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
491 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
492
493 tag = "TPC-only tracking";
494 }
495
496 // TPC-only no kink removal no minNClustersTPC
497 if (cutMode == 7)
498 {
499 // beta cuts (still under investigation)
500 //minNClustersTPC = 50;
501 maxChi2PerClusterTPC = 3.5;
502
503 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
504 esdTrackCuts->SetRequireTPCRefit(kFALSE);
505 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
506 //esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
507 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
508
509 tag = "TPC-only tracking";
510 }
511 // TPC-only no kink removal no minNClustersTPC
512 if (cutMode == 8)
513 {
514 // beta cuts (still under investigation)
515 //minNClustersTPC = 50;
516 maxChi2PerClusterTPC = 3.5;
517 maxDCAtoVertex = 3.0; // cm
518
519 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
520 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertex);
521 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertex);
522 esdTrackCuts->SetRequireTPCRefit(kFALSE);
523 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
524 //esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
525 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
526
527 tag = "TPC-only tracking";
528 }
529
530 // TPC-only no kink removal no minNClustersTPC no maxChi2PerClusterTPC
531 if (cutMode == 9)
532 {
533 // beta cuts (still under investigation)
534 //minNClustersTPC = 50;
535 //maxChi2PerClusterTPC = 3.5;
536 maxDCAtoVertex = 3.0; // cm
537
538 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
539 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertex);
540 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertex);
541 esdTrackCuts->SetRequireTPCRefit(kFALSE);
542 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
543 //esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
544 //esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
545
546 tag = "TPC-only tracking";
547 }
548
549 // TPC-only (loose cuts, absolute DCA cut)
550 if (cutMode == 10)
551 {
552 // beta cuts (still under investigation)
553 minNClustersTPC = 50;
554 maxChi2PerClusterTPC = 4.0;
555 maxDCAtoVertex = 2.8; // cm
556 minPt=0.15;
557 maxPt=1.e10;
558
559 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
560 esdTrackCuts->SetRequireTPCRefit(kFALSE);
561 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
562 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
563 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
564 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertex);
565 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertex);
566 esdTrackCuts->SetPtRange(minPt,maxPt);
567
568 tag = "TPC-only tracking";
569 }
570
571
572 // TPC-only (loose cuts, no DCA cut)
573 if (cutMode == 11)
574 {
575 // beta cuts (still under investigation)
576 minNClustersTPC = 50;
577 maxChi2PerClusterTPC = 4.0;
578 maxDCAtoVertexXY = 1.e10; // cm
579 maxDCAtoVertexZ = 1.e10; // cm
580 minPt=0.15;
581 maxPt=1.e10;
582
583 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
584 esdTrackCuts->SetRequireTPCRefit(kFALSE);
585 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
586 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
587 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
588 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
589 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
590 esdTrackCuts->SetDCAToVertex2D(kTRUE);
591 esdTrackCuts->SetPtRange(minPt,maxPt);
592
593 tag = "TPC-only tracking";
594 }
595
596 // TPC-only (standard cuts, no DCA cut)
597 if (cutMode == 12)
598 {
599 // beta cuts (still under investigation)
600 minNClustersTPC = 96;
601 maxChi2PerClusterTPC = 3.5;
602 maxDCAtoVertexXY = 1.e10; // cm
603 maxDCAtoVertexZ = 1.e10; // cm
604 minPt=0.2;
605 maxPt=1.e10;
606
607 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
608 esdTrackCuts->SetRequireTPCRefit(kFALSE);
609 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
610 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
611 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
612 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
613 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
614 esdTrackCuts->SetDCAToVertex2D(kTRUE);
615 esdTrackCuts->SetPtRange(minPt,maxPt);
616
617 tag = "TPC-only tracking";
618 }
619
620 // TPC-only (tight cuts, no DCA cut)
621 if (cutMode == 13)
622 {
623 // beta cuts (still under investigation)
624 minNClustersTPC = 120;
625 maxChi2PerClusterTPC = 3.5;
626 maxDCAtoVertexXY = 1.e10; // cm
627 maxDCAtoVertexZ = 1.e10; // cm
628 minPt=0.3;
629 maxPt=1.e10;
630
631 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
632 esdTrackCuts->SetRequireTPCRefit(kFALSE);
633 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
634 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
635 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
636 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
637 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
638 esdTrackCuts->SetDCAToVertex2D(kTRUE);
639 esdTrackCuts->SetPtRange(minPt,maxPt);
640
641 tag = "TPC-only tracking";
642 }
643
644 // TPC-only (loose cuts, no pt cut)
645 if (cutMode == 14)
646 {
647 // beta cuts (still under investigation)
648 minNClustersTPC = 50;
649 maxChi2PerClusterTPC = 4.0;
650 maxDCAtoVertexXY = 1.e10; // cm
651 maxDCAtoVertexZ = 1.e10; // cm
652 minPt=0.0;
653 maxPt=1.e10;
654
655 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
656 esdTrackCuts->SetRequireTPCRefit(kFALSE);
657 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
658 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
659 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
660 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
661 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
662 esdTrackCuts->SetDCAToVertex2D(kTRUE);
663 esdTrackCuts->SetPtRange(minPt,maxPt);
664
665 tag = "TPC-only tracking";
666 }
667
668 // TPC-only (standard cuts, no pt cut)
669 if (cutMode == 15)
670 {
671 // beta cuts (still under investigation)
672 minNClustersTPC = 96;
673 maxChi2PerClusterTPC = 3.5;
674 maxDCAtoVertexXY = 1.e10; // cm
675 maxDCAtoVertexZ = 1.e10; // cm
676 minPt=0.0;
677 maxPt=1.e10;
678
679 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
680 esdTrackCuts->SetRequireTPCRefit(kFALSE);
681 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
682 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
683 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
684 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
685 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
686 esdTrackCuts->SetDCAToVertex2D(kTRUE);
687 esdTrackCuts->SetPtRange(minPt,maxPt);
688
689 tag = "TPC-only tracking";
690 }
691
692 // TPC-only (tight cuts, no pt cuts)
693 if (cutMode == 16)
694 {
695 // beta cuts (still under investigation)
696 minNClustersTPC = 120;
697 maxChi2PerClusterTPC = 3.5;
698 maxDCAtoVertexXY = 1.e10; // cm
699 maxDCAtoVertexZ = 1.e10; // cm
700 minPt=0.0;
701 maxPt=1.e10;
702
703 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
704 esdTrackCuts->SetRequireTPCRefit(kFALSE);
705 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
706 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
707 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
708 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
709 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
710 esdTrackCuts->SetDCAToVertex2D(kTRUE);
711 esdTrackCuts->SetPtRange(minPt,maxPt);
712
713 tag = "TPC-only tracking";
714 }
715 // TPC-only (loose cuts)
716 if (cutMode == 17)
717 {
718 // beta cuts (still under investigation)
719 minNClustersTPC = 50;
720 maxChi2PerClusterTPC = 4.0;
721 //maxDCAtoVertexXY = 2.4; // cm
722 //maxDCAtoVertexZ = 3.2; // cm
723 maxDCAtoVertexXY = 1.6; // cm
724 maxDCAtoVertexZ = 2.1; // cm
725 minPt=0.15;
726 maxPt=1.e10;
727
728 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
729 esdTrackCuts->SetRequireTPCRefit(kFALSE);
730 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
731 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
732 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
733 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
734 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
735 esdTrackCuts->SetDCAToVertex2D(kTRUE);
736 esdTrackCuts->SetPtRange(minPt,maxPt);
737
738 tag = "TPC-only tracking";
739 }
740
741 // TPC-only (standard cuts)
742 if (cutMode == 18)
743 {
744 // beta cuts (still under investigation)
745 minNClustersTPC = 96;
746 maxChi2PerClusterTPC = 3.5;
747 //maxDCAtoVertexXY = 2.4; // cm
748 //maxDCAtoVertexZ = 3.2; // cm
749 maxDCAtoVertexXY = 1.4; // cm
750 maxDCAtoVertexZ = 1.8; // cm
751 minPt=0.2;
752 maxPt=1.e10;
753
754 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
755 esdTrackCuts->SetRequireTPCRefit(kFALSE);
756 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
757 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
758 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
759 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
760 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
761 esdTrackCuts->SetDCAToVertex2D(kTRUE);
762 esdTrackCuts->SetPtRange(minPt,maxPt);
763
764 tag = "TPC-only tracking";
765 }
766
767 // TPC-only (tight cuts)
768 if (cutMode == 19)
769 {
770 // beta cuts (still under investigation)
771 minNClustersTPC = 120;
772 maxChi2PerClusterTPC = 3.0;
773 //maxDCAtoVertexXY = 2.4; // cm
774 //maxDCAtoVertexZ = 3.2; // cm
775 maxDCAtoVertexXY = 1.4; // cm
776 maxDCAtoVertexZ = 1.8; // cm
777 minPt=0.3;
778 maxPt=1.e10;
779
780 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
781 esdTrackCuts->SetRequireTPCRefit(kFALSE);
782 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
783 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
784 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
785 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
786 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
787 esdTrackCuts->SetDCAToVertex2D(kTRUE);
788 esdTrackCuts->SetPtRange(minPt,maxPt);
789
790 tag = "TPC-only tracking";
791 }
792
793 // TPC-only (arb. cuts, kink cuts included)
794 if (cutMode == 20)
795 {
796 // beta cuts (still under investigation)
797 minNClustersTPC = 50;
798 maxChi2PerClusterTPC = 1.e10;
799 maxDCAtoVertexXY = 3.0; // cm
800 maxDCAtoVertexZ = 3.0; // cm
801 minPt=0.0;
802 maxPt=1.e10;
803
804 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
805 esdTrackCuts->SetRequireTPCRefit(kFALSE);
806 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
807 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
808 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
809 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
810 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
811 esdTrackCuts->SetDCAToVertex2D(kTRUE);
812 esdTrackCuts->SetPtRange(minPt,maxPt);
813
814 tag = "TPC-only tracking";
815 }
816
817 // TPC-only (arb. cuts, kink cuts excluded)
818 if (cutMode == 21)
819 {
820 // beta cuts (still under investigation)
821 minNClustersTPC = 50;
822 maxChi2PerClusterTPC = 1.e10;
823 maxDCAtoVertexXY = 3.0; // cm
824 maxDCAtoVertexZ = 3.0; // cm
825 minPt=0.0;
826 maxPt=1.e10;
827
828 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
829 esdTrackCuts->SetRequireTPCRefit(kFALSE);
830 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
831 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
832 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
833 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
834 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
835 esdTrackCuts->SetDCAToVertex2D(kTRUE);
836 esdTrackCuts->SetPtRange(minPt,maxPt);
837
838 tag = "TPC-only tracking";
839 }
840
841 // TPC-only (arb. cuts, kink cuts excluded, no chi2, no DCA)
842 if (cutMode == 22)
843 {
844 // beta cuts (still under investigation)
845 minNClustersTPC = 50;
846 maxChi2PerClusterTPC = 1.e10;
847 maxDCAtoVertexXY = 1.e10; // cm
848 maxDCAtoVertexZ = 1.e10; // cm
849 minPt=0.15;
850 maxPt=1.e10;
851
852 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
853 esdTrackCuts->SetRequireTPCRefit(kFALSE);
854 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
855 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
856 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
857 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
858 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
859 esdTrackCuts->SetDCAToVertex2D(kTRUE);
860 esdTrackCuts->SetPtRange(minPt,maxPt);
861
862 tag = "TPC-only tracking";
863 }
864
865 // TPC-only
866 if (cutMode == 23)
867 {
868 // beta cuts (still under investigation)
869 minNClustersTPC = 70;
870 maxChi2PerClusterTPC = 4.0;
871 maxDCAtoVertexXY = 2.4; // cm
872 maxDCAtoVertexZ = 3.2; // cm
873
874 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
875 esdTrackCuts->SetRequireTPCRefit(kFALSE);
876 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
877 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
878 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
879 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
880 esdTrackCuts->SetRequireITSRefit(kFALSE);
881 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
882 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
883 esdTrackCuts->SetDCAToVertex2D(kTRUE);
884 //esdTrackCuts->SetPtRange(minPt,maxPt);
885 //esdTrackCuts->SetEtaRange(minEta,maxEta);
886
887 tag = "TPC-only tracking";
888 }
889
890 // TPC-only (no pt cut, no eta cut)
891 if (cutMode == 24)
892 {
893 // beta cuts (still under investigation)
894 minNClustersTPC = 50;
895 maxChi2PerClusterTPC = 4.0;
896 maxDCAtoVertexXY = 2.4; // cm
897 maxDCAtoVertexZ = 3.2; // cm
898 minPt=0.0;
899 maxPt=1.e10;
900
901 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
902 esdTrackCuts->SetRequireTPCRefit(kFALSE);
903 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
904 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
905 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
906 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
907 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
908 esdTrackCuts->SetDCAToVertex2D(kTRUE);
909 esdTrackCuts->SetPtRange(minPt,maxPt);
910
911 tag = "TPC-only tracking";
912 }
913
914 //
915 // systematic errors DCA cut studies
916 //
917 // TPC-only
918 if (cutMode == 25)
919 {
920 // beta cuts (still under investigation)
921 minNClustersTPC = 50;
922 maxChi2PerClusterTPC = 4.0;
923 maxDCAtoVertexXY = 1.4; // cm
924 maxDCAtoVertexZ = 2.2; // cm
925 minPt=0.0;
926 maxPt=1.e10;
927
928 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
929 esdTrackCuts->SetRequireTPCRefit(kFALSE);
930 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
931 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
932 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
933 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
934 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
935 esdTrackCuts->SetDCAToVertex2D(kTRUE);
936 esdTrackCuts->SetPtRange(minPt,maxPt);
937
938 tag = "TPC-only tracking";
939 }
940
941 if (cutMode == 26)
942 {
943 // beta cuts (still under investigation)
944 minNClustersTPC = 50;
945 maxChi2PerClusterTPC = 4.0;
946 maxDCAtoVertexXY = 1.6; // cm
947 maxDCAtoVertexZ = 2.4; // cm
948 minPt=0.0;
949 maxPt=1.e10;
950
951 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
952 esdTrackCuts->SetRequireTPCRefit(kFALSE);
953 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
954 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
955 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
956 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
957 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
958 esdTrackCuts->SetDCAToVertex2D(kTRUE);
959 esdTrackCuts->SetPtRange(minPt,maxPt);
960
961 tag = "TPC-only tracking";
962 }
963
964 //
965 // systematic errors cut studies
966 //
967 // TPC-only
968 if (cutMode == 27)
969 {
970 // beta cuts (still under investigation)
971 minNClustersTPC = 50;
972 maxChi2PerClusterTPC = 4.0;
973 maxDCAtoVertexXY = 1.8; // cm
974 maxDCAtoVertexZ = 2.6; // cm
975 minPt=0.0;
976 maxPt=1.e10;
977
978 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
979 esdTrackCuts->SetRequireTPCRefit(kFALSE);
980 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
981 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
982 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
983 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
984 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
985 esdTrackCuts->SetDCAToVertex2D(kTRUE);
986 esdTrackCuts->SetPtRange(minPt,maxPt);
987
988 tag = "TPC-only tracking";
989 }
990
991 if (cutMode == 28)
992 {
993 // beta cuts (still under investigation)
994 minNClustersTPC = 50;
995 maxChi2PerClusterTPC = 4.0;
996 maxDCAtoVertexXY = 2.0; // cm
997 maxDCAtoVertexZ = 2.8; // cm
998 minPt=0.0;
999 maxPt=1.e10;
1000
1001 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1002 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1003 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1004 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1005 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1006 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1007 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1008 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1009 esdTrackCuts->SetPtRange(minPt,maxPt);
1010
1011 tag = "TPC-only tracking";
1012 }
1013
1014 if (cutMode == 29)
1015 {
1016 // beta cuts (still under investigation)
1017 minNClustersTPC = 50;
1018 maxChi2PerClusterTPC = 4.0;
1019 maxDCAtoVertexXY = 2.2; // cm
1020 maxDCAtoVertexZ = 3.0; // cm
1021 minPt=0.0;
1022 maxPt=1.e10;
1023
1024 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1025 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1026 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1027 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1028 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1029 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1030 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1031 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1032 esdTrackCuts->SetPtRange(minPt,maxPt);
1033
1034 tag = "TPC-only tracking";
1035 }
1036
1037 if (cutMode == 30)
1038 {
1039 // beta cuts (still under investigation)
1040 minNClustersTPC = 50;
1041 maxChi2PerClusterTPC = 4.0;
1042 maxDCAtoVertexXY = 2.4; // cm
1043 maxDCAtoVertexZ = 3.2; // cm
1044 minPt=0.0;
1045 maxPt=1.e10;
1046
1047 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1048 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1049 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1050 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1051 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1052 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1053 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1054 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1055 esdTrackCuts->SetPtRange(minPt,maxPt);
1056
1057 tag = "TPC-only tracking";
1058 }
1059
1060 if (cutMode == 31)
1061 {
1062 // beta cuts (still under investigation)
1063 minNClustersTPC = 50;
1064 maxChi2PerClusterTPC = 4.0;
1065 maxDCAtoVertexXY = 2.6; // cm
1066 maxDCAtoVertexZ = 3.4; // cm
1067 minPt=0.0;
1068 maxPt=1.e10;
1069
1070 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1071 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1072 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1073 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1074 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1075 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1076 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1077 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1078 esdTrackCuts->SetPtRange(minPt,maxPt);
1079
1080 tag = "TPC-only tracking";
1081 }
1082
1083
1084 if (cutMode == 32)
1085 {
1086 // beta cuts (still under investigation)
1087 minNClustersTPC = 50;
1088 maxChi2PerClusterTPC = 4.0;
1089 maxDCAtoVertexXY = 2.8; // cm
1090 maxDCAtoVertexZ = 3.6; // cm
1091 minPt=0.0;
1092 maxPt=1.e10;
1093
1094 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1095 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1096 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1097 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1098 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1099 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1100 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1101 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1102 esdTrackCuts->SetPtRange(minPt,maxPt);
1103
1104 tag = "TPC-only tracking";
1105 }
1106
1107 if (cutMode == 33)
1108 {
1109 // beta cuts (still under investigation)
1110 minNClustersTPC = 50;
1111 maxChi2PerClusterTPC = 4.0;
1112 maxDCAtoVertexXY = 3.0; // cm
1113 maxDCAtoVertexZ = 3.8; // cm
1114 minPt=0.0;
1115 maxPt=1.e10;
1116
1117 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1118 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1119 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1120 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1121 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1122 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1123 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1124 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1125 esdTrackCuts->SetPtRange(minPt,maxPt);
1126
1127 tag = "TPC-only tracking";
1128 }
1129
1130 if (cutMode == 34)
1131 {
1132 // beta cuts (still under investigation)
1133 minNClustersTPC = 50;
1134 maxChi2PerClusterTPC = 4.0;
1135 maxDCAtoVertexXY = 3.2; // cm
1136 maxDCAtoVertexZ = 4.0; // cm
1137 minPt=0.0;
1138 maxPt=1.e10;
1139
1140 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1141 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1142 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1143 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1144 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1145 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1146 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1147 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1148 esdTrackCuts->SetPtRange(minPt,maxPt);
1149
1150 tag = "TPC-only tracking";
1151 }
1152
1153 if (cutMode == 35)
1154 {
1155 // beta cuts (still under investigation)
1156 minNClustersTPC = 50;
1157 maxChi2PerClusterTPC = 4.0;
1158 maxDCAtoVertexXY = 3.4; // cm
1159 maxDCAtoVertexZ = 4.2; // cm
1160 minPt=0.0;
1161 maxPt=1.e10;
1162
1163 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1164 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1165 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1166 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1167 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1168 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1169 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1170 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1171 esdTrackCuts->SetPtRange(minPt,maxPt);
1172
1173 tag = "TPC-only tracking";
1174 }
1175
1176//
1177// cut stability systematics
1178//
1179
1180 if (cutMode == 36)
1181 {
1182 // beta cuts (still under investigation)
1183 minNClustersTPC = 70;
1184 maxChi2PerClusterTPC = 4.0;
1185 maxDCAtoVertexXY = 2.4; // cm
1186 maxDCAtoVertexZ = 3.2; // cm
1187 minPt=0.0;
1188 maxPt=1.e10;
1189
1190 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1191 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1192 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1193 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1194 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1195 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1196 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1197 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1198 esdTrackCuts->SetPtRange(minPt,maxPt);
1199
1200 tag = "TPC-only tracking";
1201 }
1202
1203 if (cutMode == 37)
1204 {
1205 // beta cuts (still under investigation)
1206 minNClustersTPC = 90;
1207 maxChi2PerClusterTPC = 4.0;
1208 maxDCAtoVertexXY = 2.4; // cm
1209 maxDCAtoVertexZ = 3.2; // cm
1210 minPt=0.0;
1211 maxPt=1.e10;
1212
1213 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1214 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1215 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1216 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1217 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1218 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1219 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1220 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1221 esdTrackCuts->SetPtRange(minPt,maxPt);
1222
1223 tag = "TPC-only tracking";
1224 }
1225
1226 if (cutMode == 38)
1227 {
1228 // beta cuts (still under investigation)
1229 minNClustersTPC = 50;
1230 maxChi2PerClusterTPC = 3.0;
1231 maxDCAtoVertexXY = 2.4; // cm
1232 maxDCAtoVertexZ = 3.2; // cm
1233 minPt=0.0;
1234 maxPt=1.e10;
1235
1236 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1237 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1238 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1239 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1240 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1241 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1242 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1243 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1244 esdTrackCuts->SetPtRange(minPt,maxPt);
1245
1246 tag = "TPC-only tracking";
1247 }
1248
1249 if (cutMode == 39)
1250 {
1251 // beta cuts (still under investigation)
1252 minNClustersTPC = 50;
1253 maxChi2PerClusterTPC = 5.0;
1254 maxDCAtoVertexXY = 2.4; // cm
1255 maxDCAtoVertexZ = 3.2; // cm
1256 minPt=0.0;
1257 maxPt=1.e10;
1258
1259 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1260 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1261 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1262 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1263 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1264 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1265 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1266 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1267 esdTrackCuts->SetPtRange(minPt,maxPt);
1268
1269 tag = "TPC-only tracking";
1270 }
1271
1272 if (cutMode == 40)
1273 {
1274 // beta cuts (still under investigation)
1275 minNClustersTPC = 50;
1276 maxChi2PerClusterTPC = 4.0;
1277 maxDCAtoVertexXY = 1.4; // cm
1278 maxDCAtoVertexZ = 2.2; // cm
1279 minPt=0.0;
1280 maxPt=1.e10;
1281
1282 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1283 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1284 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1285 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1286 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1287 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1288 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1289 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1290 esdTrackCuts->SetPtRange(minPt,maxPt);
1291
1292 tag = "TPC-only tracking";
1293 }
1294
1295 if (cutMode == 41)
1296 {
1297 // beta cuts (still under investigation)
1298 minNClustersTPC = 50;
1299 maxChi2PerClusterTPC = 4.0;
1300 maxDCAtoVertexXY = 3.4; // cm
1301 maxDCAtoVertexZ = 4.2; // cm
1302 minPt=0.0;
1303 maxPt=1.e10;
1304
1305 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1306 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1307 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1308 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1309 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1310 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1311 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1312 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1313 esdTrackCuts->SetPtRange(minPt,maxPt);
1314
1315 tag = "TPC-only tracking";
1316 }
1317
1318 if (cutMode == 42)
1319 {
1320 // beta cuts (still under investigation)
1321 minNClustersTPC = 50;
1322 maxChi2PerClusterTPC = 4.0;
1323 maxDCAtoVertexXY = 2.4; // cm
1324 maxDCAtoVertexZ = 3.2; // cm
1325 minPt=0.0;
1326 maxPt=1.e10;
1327
1328 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1329 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1330 //esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1331 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
1332 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1333 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1334 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1335 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1336 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1337 esdTrackCuts->SetPtRange(minPt,maxPt);
1338
1339 tag = "TPC-only tracking";
1340 }
1341 // test
1342 if (cutMode == 43)
1343 {
1344 // beta cuts (still under investigation)
1345 minNClustersTPC = 50;
1346 maxChi2PerClusterTPC = 4.0;
1347 //maxDCAtoVertexXY = 2.4; // cm
1348 //maxDCAtoVertexZ = 3.2; // cm
1349 //minPt=0.15;
1350 //maxPt=1.e10;
1351
1352 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1353 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1354 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1355 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1356 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1357 //esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1358 //esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1359 //esdTrackCuts->SetDCAToVertex2D(kTRUE);
1360 //esdTrackCuts->SetPtRange(minPt,maxPt);
1361 //esdTrackCuts->SetEtaRange(minEta,maxEta);
1362
1363 tag = "TPC-only tracking";
1364 }
1365
1366 // TPC-only + pt cut + eta cut
1367 if (cutMode == 45)
1368 {
1369 // beta cuts (still under investigation)
1370 //minNClustersTPC = 50;
1371 //maxChi2PerClusterTPC = 4.0;
1372 maxDCAtoVertexXY = 2.4; // cm
1373 maxDCAtoVertexZ = 3.2; // cm
1374 //minPt=0.15;
1375 //maxPt=1.e10;
1376
1377 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1378 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1379 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1380 //esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1381 //esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1382 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1383 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1384 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1385 //esdTrackCuts->SetPtRange(minPt,maxPt);
1386 //esdTrackCuts->SetEtaRange(minEta,maxEta);
1387
1388 tag = "TPC-only tracking";
1389 }
1390
1391 // TPC-tracks + SPD point + ITS refit
1392 if (cutMode == 50)
1393 {
1394 Int_t minclsTPC=70;
1395 Double_t maxchi2perTPCcl=4.;
1396 //Double_t maxEtaInAcc=0.8;
1397 Double_t maxdcaxyITSTPC=0.2;
1398 Double_t maxdcazITSTPC=1.e9;
1399
1400 esdTrackCuts->SetMaxDCAToVertexXY(maxdcaxyITSTPC);
1401 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1402 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1403 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1404 esdTrackCuts->SetRequireITSRefit(kTRUE);
1405 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1406 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1407 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1408 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1409 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1410 //esdTrackCuts->SetEtaRange(-maxEtaInAcc,maxEtaInAcc);
1411
1412 tag = "TPC-tracks + ITS refit + >1 SPD cluster";
1413 }
1414
1415 // TPC-tracks + SPD point + ITS refit
1416 if (cutMode == 60)
1417 {
1418 Int_t minclsITS=4;
1419 Int_t minclsTPC=70;
1420 Double_t maxchi2perTPCcl=4.;
1421 Double_t maxdcaxyITSTPC=0.2;
1422 Double_t maxdcazITSTPC=1.e9;
1423
1424 esdTrackCuts->SetMaxDCAToVertexXY(maxdcaxyITSTPC);
1425 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1426 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1427 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1428 esdTrackCuts->SetRequireITSRefit(kTRUE);
1429 esdTrackCuts->SetMinNClustersITS(minclsITS);
1430 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1431 //esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1432 esdTrackCuts->SetRequireTPCRefit(kTRUE);
1433 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1434 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1435 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1436
1437 tag = "Global tracking: TPC refit + ITS refit + >3 ITS clusters + >=1 SPD cluster";
1438 }
1439
1440 /*
1441 // TPC-tracks + SPD point + ITS refit + DCAr(pt)
1442 if (cutMode == 70)
1443 {
1444 Int_t minclsTPC=70;
1445 Double_t maxchi2perTPCcl=4.;
1446 Double_t maxdcaxyITSTPC=1.e9;
1447 Double_t maxdcazITSTPC=1.e9;
1448
1449 esdTrackCuts->SetMaxDCAToVertexXY(maxdcaxyITSTPC);
1450 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1451 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1452 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1453 esdTrackCuts->SetRequireITSRefit(kTRUE);
1454 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1455 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1456 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1457 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1458 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1459
1460 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt)";
1461 }
1462 */
1463
1464 // TPC-tracks + SPD point + ITS refit + DCAr(pt)
1465 if (cutMode == 70)
1466 {
1467 Int_t minclsTPC=70;
1468 Double_t maxchi2perTPCcl=4.;
1469 Double_t maxdcazITSTPC=1.e9;
1470
1471 //
1472 // TPC
1473 //
1474 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1475 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1476 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1477 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1478 //
1479 // ITS
1480 //
1481 esdTrackCuts->SetRequireITSRefit(kTRUE);
1482 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1483 //
1484 // primary selection
1485 //
1486 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1487 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1488 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1489
1490 // 7*(0.0050+0.0060/pt^0.9)
1491 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
1492
1493 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt)";
1494 }
1495
1496 // TPC+ITS combine tracking + DCAr(pt) + DCAz(pt)
1497 if (cutMode == 71)
1498 {
1499 Int_t minclsTPC=70;
1500 Double_t maxchi2perTPCcl=4.;
1501 Double_t maxdcazITSTPC=1.e9;
1502
1503 //
1504 // TPC
1505 //
1506 esdTrackCuts->SetRequireTPCRefit(kTRUE);
1507 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1508 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1509 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1510 //
1511 // ITS
1512 //
1513 esdTrackCuts->SetRequireITSRefit(kTRUE);
1514 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1515 //
1516 // primary selection
1517 //
1518 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1519 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1520 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1521
1522 // DCArphi parametrization (LHC10c pass2)
1523 // 7*(0.0026+0.0050/pt^1.01)
1524 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
1525
1526 // DCArphi parametrization (LHC10c pass2)
1527 // 7*(0.01+0.011/pt^0.72)
1528 esdTrackCuts->SetMaxDCAToVertexZPtDep("0.07+0.077/pt^0.72");
1529
1530 tag = "TPC+ITS combine tracking + DCAr(pt) + DCAz(pt)";
1531 }
1532
1533 // TPC+ITS combine tracking + DCAr(pt) (2010)
1534 if (cutMode == 72)
1535 {
1536 Int_t minclsTPC=70;
1537 Double_t maxchi2perTPCcl=4.;
1538 Double_t maxdcazITSTPC=2.0;
1539
1540 //
1541 // TPC
1542 //
1543 esdTrackCuts->SetRequireTPCRefit(kTRUE);
1544 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1545 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1546 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1547 //
1548 // ITS
1549 //
1550 esdTrackCuts->SetRequireITSRefit(kTRUE);
1551 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1552 //
1553 // primary selection
1554 //
1555 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1556 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1557 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1558
1559 // DCArphi parametrization (LHC10c pass2)
1560 // 7*(0.0026+0.0050/pt^1.01)
1561 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
1562
1563 tag = "TPC+ITS combine tracking + DCAr(pt) (2010)";
1564 }
1565
1566 // TPC-tracks + SPD point + ITS refit + DCAr(pt) 4-sigma
1567 if (cutMode == 75)
1568 {
1569 Int_t minclsTPC=70;
1570 Double_t maxchi2perTPCcl=4.;
1571 Double_t maxdcazITSTPC=1.e9;
1572
1573 //
1574 // TPC
1575 //
1576 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1577 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1578 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1579 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1580 //
1581 // ITS
1582 //
1583 esdTrackCuts->SetRequireITSRefit(kTRUE);
1584 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1585 //
1586 // primary selection
1587 //
1588 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1589 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1590 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1591
1592 // 4*(0.0050+0.0060/pt^0.9)
1593 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.02+0.024/pt^0.9");
1594
1595 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt) 4-sigma";
1596 }
1597
1598 // TPC-tracks + SPD point + ITS refit + DCAr(pt) 10-sigma
1599 if (cutMode == 80)
1600 {
1601 Int_t minclsTPC=70;
1602 Double_t maxchi2perTPCcl=4.;
1603 Double_t maxdcazITSTPC=1.e9;
1604
1605 //
1606 // TPC
1607 //
1608 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1609 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1610 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1611 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1612 //
1613 // ITS
1614 //
1615 esdTrackCuts->SetRequireITSRefit(kTRUE);
1616 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1617 //
1618 // primary selection
1619 //
1620 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1621 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1622 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1623
1624 // 10*(0.0050+0.0060/pt^0.9)
1625 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.05+0.06/pt^0.9");
1626
1627 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt) 10 sigma";
1628 }
1629
1630 // TPC-tracks + SPD point + ITS refit + DCAr(pt) + 60 TPCclust
1631 if (cutMode == 85)
1632 {
1633 Int_t minclsTPC=60;
1634 Double_t maxchi2perTPCcl=4.;
1635 Double_t maxdcazITSTPC=1.e9;
1636
1637 //
1638 // TPC
1639 //
1640 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1641 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1642 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1643 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1644 //
1645 // ITS
1646 //
1647 esdTrackCuts->SetRequireITSRefit(kTRUE);
1648 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1649 //
1650 // primary selection
1651 //
1652 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1653 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1654 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1655
1656 // 7*(0.0050+0.0060/pt^0.9)
1657 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
1658
1659 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt) + 60 TPCclust";
1660 }
1661
1662 // TPC-tracks + SPD point + ITS refit + DCAr(pt) + 80 clusters
1663 if (cutMode == 90)
1664 {
1665 Int_t minclsTPC=80;
1666 Double_t maxchi2perTPCcl=4.;
1667 Double_t maxdcazITSTPC=1.e9;
1668
1669 //
1670 // TPC
1671 //
1672 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1673 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1674 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1675 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1676 //
1677 // ITS
1678 //
1679 esdTrackCuts->SetRequireITSRefit(kTRUE);
1680 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1681 //
1682 // primary selection
1683 //
1684 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1685 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1686 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1687
1688 // 7*(0.0050+0.0060/pt^0.9)
1689 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
1690
1691 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt) + 80 TPCclust";
1692 }
1693
1694 // TPC-tracks + SPD point + ITS refit + DCAr(pt) + TPCchi2=3.5
1695 if (cutMode == 95)
1696 {
1697 Int_t minclsTPC=80;
1698 Double_t maxchi2perTPCcl=3.5;
1699 Double_t maxdcazITSTPC=1.e9;
1700
1701 //
1702 // TPC
1703 //
1704 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1705 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1706 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1707 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1708 //
1709 // ITS
1710 //
1711 esdTrackCuts->SetRequireITSRefit(kTRUE);
1712 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1713 //
1714 // primary selection
1715 //
1716 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1717 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1718 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1719
1720 // 7*(0.0050+0.0060/pt^0.9)
1721 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
1722
1723 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt) + TPCchi2 3.5";
1724 }
1725
1726 // TPC-tracks + SPD point + ITS refit + DCAr(pt) + TPCchi2=4.5
1727 if (cutMode == 100)
1728 {
1729 Int_t minclsTPC=80;
1730 Double_t maxchi2perTPCcl=4.5;
1731 Double_t maxdcazITSTPC=1.e9;
1732
1733 //
1734 // TPC
1735 //
1736 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1737 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1738 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1739 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1740 //
1741 // ITS
1742 //
1743 esdTrackCuts->SetRequireITSRefit(kTRUE);
1744 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1745 //
1746 // primary selection
1747 //
1748 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1749 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1750 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1751
1752 // 7*(0.0050+0.0060/pt^0.9)
1753 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
1754
1755 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt) + TPCchi2 4.5";
1756 }
1757
1758 // TPC-tracks
1759 if (cutMode == 110)
1760 {
1761
1762 minNClustersTPC = 70;
1763 maxChi2PerClusterTPC = 4.0;
1764 maxDCAtoVertexXY = 1.e9; // cm
1765 maxDCAtoVertexZ = 1.e9; // cm
1766
1767 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1768 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1769 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1770 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1771 esdTrackCuts->SetMinNClustersTPC(minNClustersTPC);
1772 esdTrackCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
1773 esdTrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertexXY);
1774 esdTrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertexZ);
1775 esdTrackCuts->SetDCAToVertex2D(kTRUE);
1776
1777 tag = "TPC-tracks loose criteria";
1778 }
1779
1780
1781 // TPC-tracks + SPD point + ITS refit + DCAr(pt) + 50 TPCclust
1782 if (cutMode == 120)
1783 {
1784 Int_t minclsTPC=50;
1785 Double_t maxchi2perTPCcl=4.;
1786 Double_t maxdcazITSTPC=1.e9;
1787
1788 //
1789 // TPC
1790 //
1791 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1792 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1793 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1794 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1795 //
1796 // ITS
1797 //
1798 esdTrackCuts->SetRequireITSRefit(kTRUE);
1799 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1800 //
1801 // primary selection
1802 //
1803 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1804 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1805 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1806
1807 // 7*(0.0050+0.0060/pt^0.9)
1808 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
1809
1810 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt) + 60 TPCclust";
1811 }
1812
1813 // TPC-tracks + SPD point + ITS refit + DCAr(pt) + 70 TPCclust + accept kink daughters
1814 if (cutMode == 130)
1815 {
1816 Int_t minclsTPC=70;
1817 Double_t maxchi2perTPCcl=4.;
1818 Double_t maxdcazITSTPC=1.e9;
1819
1820 //
1821 // TPC
1822 //
1823 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1824 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
1825 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1826 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1827 //
1828 // ITS
1829 //
1830 esdTrackCuts->SetRequireITSRefit(kTRUE);
1831 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1832 //
1833 // primary selection
1834 //
1835 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1836 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1837 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1838
1839 // 7*(0.0050+0.0060/pt^0.9)
1840 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
1841
1842 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt) + 60 TPCclust";
1843 }
1844
1845 // TPC-tracks + SPD point + ITS refit + DCAr(pt) + 30 TPCclust + accept kink daughters
1846 if (cutMode == 140)
1847 {
1848 Int_t minclsTPC=30;
1849 Double_t maxchi2perTPCcl=4.;
1850 Double_t maxdcazITSTPC=1.e9;
1851
1852 //
1853 // TPC
1854 //
1855 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1856 esdTrackCuts->SetAcceptKinkDaughters(kTRUE);
1857 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1858 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1859 //
1860 // ITS
1861 //
1862 esdTrackCuts->SetRequireITSRefit(kTRUE);
1863 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1864 //
1865 // primary selection
1866 //
1867 esdTrackCuts->SetDCAToVertex2D(kFALSE);
1868 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1869 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1870
1871 // 7*(0.0050+0.0060/pt^0.9)
1872 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
1873
1874 tag = "TPC-tracks + ITS refit + >1 SPD cluster + DCAr(Pt) + 60 TPCclust";
1875 }
1876
1877 // Adam Kisiel track selectiion
1878 if (cutMode == 150)
1879 {
1880 Int_t minclsTPC=70;
1881 Double_t maxchi2perTPCcl=4.;
1882 Double_t maxdcazITSTPC=0.25;
1883 Double_t maxdcaxyITSTPC=0.2;
1884
1885 //
1886 // TPC
1887 //
1888 //esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1889 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1890 esdTrackCuts->SetMinNClustersTPC(minclsTPC);
1891 esdTrackCuts->SetMaxChi2PerClusterTPC(maxchi2perTPCcl);
1892 //
1893 // ITS
1894 //
1895 esdTrackCuts->SetRequireITSRefit(kTRUE);
1896 //esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1897 //
1898 // primary selection
1899 //
1900 //esdTrackCuts->SetDCAToVertex2D(kFALSE);
1901 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1902 esdTrackCuts->SetMaxDCAToVertexZ(maxdcazITSTPC);
1903 esdTrackCuts->SetMaxDCAToVertexXY(maxdcaxyITSTPC);
1904
1905 // 7*(0.0050+0.0060/pt^0.9)
1906 //esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
1907
1908 tag = "Adam Kisiel track selection";
1909 }
1910
1911 // TPC+ITS refit
1912 // for cut studies
1913 if (cutMode == 151)
1914 {
1915 //
1916 // TPC
1917 //
1918 esdTrackCuts->SetRequireTPCRefit(kTRUE);
1919 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1920 //
1921 // ITS
1922 //
1923 esdTrackCuts->SetRequireITSRefit(kTRUE);
1924 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1925 //
1926
1927 tag = "TPC+ITS refit required - for cut studies";
1928 }
1929
1930 // TPC+ITS
1931 // for cut studies
1932 if (cutMode == 152)
1933 {
1934 //
1935 // TPC
1936 //
1937 esdTrackCuts->SetRequireTPCRefit(kTRUE);
1938 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1939 //
1940 // ITS
1941 //
1942 //esdTrackCuts->SetRequireITSRefit(kTRUE);
1943 //esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1944 //
1945
1946 tag = "TPC refit required - for cut studies";
1947 }
1948
1949 // TPC
1950 // for cut studies
1951 if (cutMode == 153)
1952 {
1953 //
1954 // TPC
1955 //
1956 esdTrackCuts->SetRequireTPCRefit(kFALSE);
1957 esdTrackCuts->SetRequireITSRefit(kFALSE);
1958 esdTrackCuts->SetRequireTPCStandAlone(kTRUE);
1959 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
1960 //
1961 // ITS
1962 //
1963 //esdTrackCuts->SetRequireITSRefit(kTRUE);
1964 //esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
1965 //
1966
1967 tag = "TPC stand alone - for cut studies";
1968 }
1969
1970
1971
1972
1973
1974
1975 // cuts for data without field
1976 if (!fieldOn)
1977 {
1978 cov5 = 1e10;
1979 tag += " without field";
1980 }
1981
1982 Printf("Created track cuts for: %s", tag.Data());
1983
1984 return esdTrackCuts;
1985}