PWGUD/multVScentPbPb/AliTaskGlobVar.cxx

   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"
  39 #include "AliCentrality.h"
  40 #include "AliESDtrackCuts.h"
  41 #include "AliTaskGlobVar.h"
  42 #include "AliGenEventHeader.h"
  43 #include "AliGenHijingEventHeader.h"
  44 #include "AliGenDPMjetEventHeader.h"
  45 #include "AliTriggerAnalysis.h"
  46
  47
  48 ClassImp(AliTaskGlobVar)
  49
  50
  51 //________________________________________________________________________
  52 AliTaskGlobVar::AliTaskGlobVar(const char *name)
  53   : AliAnalysisTaskSE(name),
  54     //
  55     fUseMC(kFALSE),
  56     fOutput(0),
  57     fOutTree(0),
  58     fTrackCuts(0),
  59   fTrackCuts1(0),
  60   fGlobVars()
  61 {
  62   // Constructor
  63   DefineOutput(1, TList::Class());
  64   //
  65 }
  66
  67 //________________________________________________________________________
  68 AliTaskGlobVar::~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;
  76   }
  77   //
  78 }
  79
  80 //________________________________________________________________________
  81 void AliTaskGlobVar::UserCreateOutputObjects()
  82 {
  83   // create ouptut
  84   fOutput = new TList();
  85   fOutput->SetOwner();
  86   //
  87   fOutTree = new TTree("globTree","globTree");
  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"
  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) {
  92     fOutTree->Branch("gmc",&fGlobVars.mcZV,"mcZV/F:mcdNdEta/S:mcNPart/S:mcNBColl/S", 16777216);
  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 //________________________________________________________________________
 108 void 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   //
 130   fGlobVars.runID = esd->GetRunNumber();
 131   TString rid = "";
 132   rid +=  fGlobVars.runID;
 133   TString flname        = hand->GetTree()->GetCurrentFile()->GetName();
 134   fGlobVars.chunk        = 0;
 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;
 140     fGlobVars.chunk = (Short_t)flname.Atoi();
 141   }
 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();
 154   //
 155   AliESDVZERO* esdV0 = esd->GetVZEROData();
 156   if (esdV0) {
 157     fGlobVars.v0A = (Short_t)esdV0->GetMTotV0A();
 158     fGlobVars.v0C = (Short_t)esdV0->GetMTotV0C();
 159   }
 160   else fGlobVars.v0A = fGlobVars.v0C = 0;
 161   //
 162   fGlobVars.spd1 = (Short_t)multESD->GetNumberOfITSClusters(0);
 163   fGlobVars.spd2 = (Short_t)multESD->GetNumberOfITSClusters(1);
 164   //
 165   float v0Corr,v0CorrR;
 166   //  v0Corr = GetCorrV0(esd,v0CorrR); MF: Deprecated: V0corr isnot needed any more
 167   v0Corr = esdV0->GetMTotV0A() + esdV0->GetMTotV0C();
 168   fGlobVars.v0Corr = (Short_t)v0Corr;
 169   //  fGlobVars.v0CorrResc = (Short_t)v0CorrR;
 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   }
 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   //
 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
 205   fGlobVars.zem1  = (Float_t) (esdZDC->GetZDCEMEnergy(0)) /8.;
 206   fGlobVars.zem2  = (Float_t) (esdZDC->GetZDCEMEnergy(1)) /8.;
 207
 208
 209
 210   //-----------------------------------------------
 211   //
 212   // ---------------------- MC ONLY -------------------------------
 213   AliMCEventHandler* eventHandler = (AliMCEventHandler*)anMan->GetMCtruthEventHandler();
 214   AliStack*    stack=0;
 215   AliMCEvent*  mcEvent=0;
 216   fGlobVars.mcdNdEta = 0;
 217   fGlobVars.mcNPart  = 0;
 218   fGlobVars.mcNBColl = 0;
 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;
 227       fGlobVars.mcdNdEta++;
 228     }
 229     //
 230     AliGenEventHeader* mcGenH = mcEvent->GenEventHeader();
 231     if (mcGenH->InheritsFrom(AliGenHijingEventHeader::Class())) {
 232       AliGenHijingEventHeader* hHijing = (AliGenHijingEventHeader*)mcGenH;
 233       fGlobVars.mcNPart  = (hHijing->ProjectileParticipants()+hHijing->TargetParticipants())/2.;
 234       fGlobVars.mcNBColl = hHijing->NN()+hHijing->NNw()+hHijing->NwN()+hHijing->NwNw();
 235     }
 236     else if (mcGenH->InheritsFrom(AliGenDPMjetEventHeader::Class())) {
 237       AliGenDPMjetEventHeader* hDpmJet = (AliGenDPMjetEventHeader*)mcGenH;
 238       fGlobVars.mcNPart  = (hDpmJet->ProjectileParticipants()+hDpmJet->TargetParticipants())/2.;
 239       fGlobVars.mcNBColl = hDpmJet->NN()+hDpmJet->NNw()+hDpmJet->NwN()+hDpmJet->NwNw();
 240     }
 241     else {} // unknown generator
 242     //
 243     TArrayF vtxMC;
 244     mcGenH->PrimaryVertex(vtxMC);
 245     fGlobVars.mcZV = vtxMC[2];
 246   }
 247   //
 248   fOutTree->Fill();
 249   //
 250 }
 251 //________________________________________________________________________
 252 void AliTaskGlobVar::Terminate(Option_t *)
 253 {
 254   // print itself
 255   Printf("Terminating...");
 256   //  AliAnalysisTaskSE::Terminate();
 257 }
 258
 259
 260 //________________________________________________________________________
 261 Float_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 //_________________________________________________________________
 322 Bool_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
 353 AliESDtrackCuts* 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 }