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