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