PWG4/JetTasks/AliPWG4HighPtQATPConly.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, 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 // This class compares the global reconstruction with the TPConly
  18 // reconstruction
  19 // Momentum resolution is stored as function of track cuts and pt.
  20 // Output: Histograms for different set of cuts
  21 //-----------------------------------------------------------------------
  22 // Author : Marta Verweij - UU
  23 //-----------------------------------------------------------------------
  24
  25 #ifndef ALIPWG4HIGHPTQATPCONLY_CXX
  26 #define ALIPWG4HIGHPTQATPCONLY_CXX
  27
  28 #include "AliPWG4HighPtQATPConly.h"
  29
  30 #include "TVector3.h"
  31 #include <iostream>
  32 #include "TH1.h"
  33 #include "TH2.h"
  34 #include "TH3.h"
  35 #include "TList.h"
  36 #include "TChain.h"
  37 #include "TH3F.h"
  38 #include <Bytes.h>
  39 #include <TTree.h>
  40
  41 #include "AliAnalysisManager.h"
  42 #include "AliESDInputHandler.h"
  43 #include "AliESDtrack.h"
  44 #include "AliESDfriend.h"
  45 #include "AliESDfriendTrack.h"
  46 #include "AliESDtrackCuts.h"
  47 #include "AliExternalTrackParam.h"
  48 #include "AliLog.h"
  49 //#include "AliAnalysisHelperJetTasks.h"
  50
  51 #include "TH1I.h"
  52
  53 using namespace std; //required for resolving the 'cout' symbol
  54
  55 ClassImp(AliPWG4HighPtQATPConly)
  56
  57 AliPWG4HighPtQATPConly::AliPWG4HighPtQATPConly(): AliAnalysisTask("AliPWG4HighPtQATPConly", ""),
  58   fESD(0),
  59   fESDfriend(0),
  60   fCutType(1),
  61   fTrackCuts(0),
  62   fTrackCutsITS(0),
  63   fPtMax(100.),
  64   fNEventAll(0),
  65   fNEventSel(0),
  66   fPtAll(0),
  67   fPtSel(0),
  68   fPtAllminPtTPCvsPtAll(0),
  69   fPtAllminPtTPCvsPtAllEtaPos(0),
  70   fPtAllminPtTPCvsPtAllEtaNeg(0),
  71   fPtAllminPtTPCvsPtAllNPointTPC(0),
  72   fPtAllminPtTPCvsPtAllDCAR(0),
  73   fPtAllminPtTPCvsPtAllDCAZ(0),
  74   fPtAllminPtTPCvsPtAllPhi(0),
  75   fPtAllminPtTPCvsPtAllNPointITS(0),
  76   fPtAllminPtTPCvsPtAllNSigmaToVertex(0),
  77   fPtAllminPtTPCvsPtAllChi2C(0),
  78   fPtAllminPtTPCvsPtAllRel1PtUncertainty(0),
  79   fPtAllminPtTPCvsPtAllChi2PerNClusTPC(0),
  80   fPtAllminPtTPCvsPtAllChi2PerNClusITS(0),
  81   fPtAllminPtTPCvsNPointTPCPhi(0),
  82   fPtAllminPtTPCvsNPointITSPhi(0),
  83   fPtAllminPtTPCvsRel1PtUncertaintyPhi(0),
  84   fEtaPhiOutliers(0),
  85   fPtSelITSouter(0),
  86   fPtITSouterminPtTPCvsPtAll(0),
  87   fPtITSouterminPtTPCvsPtAllEtaPos(0),
  88   fPtITSouterminPtTPCvsPtAllEtaNeg(0),
  89   fPtITSouterminPtTPCvsPtAllNPointTPC(0),
  90   fPtITSouterminPtTPCvsPtAllDCAR(0),
  91   fPtITSouterminPtTPCvsPtAllDCAZ(0),
  92   fPtITSouterminPtTPCvsPtAllPhi(0),
  93   fPtITSouterminPtTPCvsPtAllNPointITS(0),
  94   fPtITSouterminPtTPCvsPtAllNSigmaToVertex(0),
  95   fPtITSouterminPtTPCvsPtAllChi2C(0),
  96   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty(0),
  97   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC(0),
  98   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS(0),
  99   fPtITSouterminPtTPCvsPtAllITSLayer0(0),
 100   fPtITSouterminPtTPCvsPtAllITSLayer1(0),
 101   fPtITSouterminPtTPCvsPtAllITSLayer2(0),
 102   fPtITSouterminPtTPCvsPtAllITSLayer3(0),
 103   fPtITSouterminPtTPCvsPtAllITSLayer4(0),
 104   fPtITSouterminPtTPCvsPtAllITSLayer5(0),
 105   fPtITSouterminPtTPCvsPtAllNoSPD(0),
 106   fPtITSouterminPtTPCvsPtAllNoSDD(0),
 107   fPtITSouterminPtTPCvsPtAllNoSSD(0),
 108   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0(0),
 109   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1(0),
 110   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2(0),
 111   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3(0),
 112   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4(0),
 113   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5(0),
 114   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD(0),
 115   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD(0),
 116   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD(0),
 117   fHistList(0),
 118   fPtAllTPC(0),
 119   fPtSelTPC(0),
 120   fPtSelTPCITS(0),
 121   fHistListTPC(0),
 122   fPtSelITS(0),
 123   fPtITSminPtTPCvsPtITS(0),
 124   fPtITSminPtTPCvsPtITSEtaPos(0),
 125   fPtITSminPtTPCvsPtITSEtaNeg(0),
 126   fPtITSminPtTPCvsPtITSNPointTPC(0),
 127   fPtITSminPtTPCvsPtITSDCAR(0),
 128   fPtITSminPtTPCvsPtITSDCAZ(0),
 129   fPtITSminPtTPCvsPtITSPhi(0),
 130   fPtITSminPtTPCvsPtITSNPointITS(0),
 131   fPtITSminPtTPCvsPtITSNSigmaToVertex(0),
 132   fPtITSminPtTPCvsPtITSChi2C(0),
 133   fPtITSminPtTPCvsPtITSRel1PtUncertainty(0),
 134   fPtITSminPtTPCvsPtITSChi2PerNClusTPC(0),
 135   fPtITSminPtTPCvsPtITSChi2PerNClusITS(0),
 136   fPtITSminPtTPCvsNPointTPCPhi(0),
 137   fPtITSminPtTPCvsNPointITSPhi(0),
 138   fPtITSminPtTPCvsRel1PtUncertaintyPhi(0),
 139   fPtRel1PtUncertaintyChi2PerClusTPC(0),
 140   fHistListITS(0)
 141
 142 {
 143
 144 }
 145 //________________________________________________________________________
 146 AliPWG4HighPtQATPConly::AliPWG4HighPtQATPConly(const char *name):
 147   AliAnalysisTask(name, ""),
 148   fESD(0),
 149   fESDfriend(0),
 150   fCutType(1),
 151   fTrackCuts(),
 152   fTrackCutsITS(),
 153   fPtMax(100.),
 154   fNEventAll(0),
 155   fNEventSel(0),
 156   fPtAll(0),
 157   fPtSel(0),
 158   fPtAllminPtTPCvsPtAll(0),
 159   fPtAllminPtTPCvsPtAllEtaPos(0),
 160   fPtAllminPtTPCvsPtAllEtaNeg(0),
 161   fPtAllminPtTPCvsPtAllNPointTPC(0),
 162   fPtAllminPtTPCvsPtAllDCAR(0),
 163   fPtAllminPtTPCvsPtAllDCAZ(0),
 164   fPtAllminPtTPCvsPtAllPhi(0),
 165   fPtAllminPtTPCvsPtAllNPointITS(0),
 166   fPtAllminPtTPCvsPtAllNSigmaToVertex(0),
 167   fPtAllminPtTPCvsPtAllChi2C(0),
 168   fPtAllminPtTPCvsPtAllRel1PtUncertainty(0),
 169   fPtAllminPtTPCvsPtAllChi2PerNClusTPC(0),
 170   fPtAllminPtTPCvsPtAllChi2PerNClusITS(0),
 171   fPtAllminPtTPCvsNPointTPCPhi(0),
 172   fPtAllminPtTPCvsNPointITSPhi(0),
 173   fPtAllminPtTPCvsRel1PtUncertaintyPhi(0),
 174   fEtaPhiOutliers(0),
 175   fPtSelITSouter(0),
 176   fPtITSouterminPtTPCvsPtAll(0),
 177   fPtITSouterminPtTPCvsPtAllEtaPos(0),
 178   fPtITSouterminPtTPCvsPtAllEtaNeg(0),
 179   fPtITSouterminPtTPCvsPtAllNPointTPC(0),
 180   fPtITSouterminPtTPCvsPtAllDCAR(0),
 181   fPtITSouterminPtTPCvsPtAllDCAZ(0),
 182   fPtITSouterminPtTPCvsPtAllPhi(0),
 183   fPtITSouterminPtTPCvsPtAllNPointITS(0),
 184   fPtITSouterminPtTPCvsPtAllNSigmaToVertex(0),
 185   fPtITSouterminPtTPCvsPtAllChi2C(0),
 186   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty(0),
 187   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC(0),
 188   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS(0),
 189   fPtITSouterminPtTPCvsPtAllITSLayer0(0),
 190   fPtITSouterminPtTPCvsPtAllITSLayer1(0),
 191   fPtITSouterminPtTPCvsPtAllITSLayer2(0),
 192   fPtITSouterminPtTPCvsPtAllITSLayer3(0),
 193   fPtITSouterminPtTPCvsPtAllITSLayer4(0),
 194   fPtITSouterminPtTPCvsPtAllITSLayer5(0),
 195   fPtITSouterminPtTPCvsPtAllNoSPD(0),
 196   fPtITSouterminPtTPCvsPtAllNoSDD(0),
 197   fPtITSouterminPtTPCvsPtAllNoSSD(0),
 198   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0(0),
 199   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1(0),
 200   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2(0),
 201   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3(0),
 202   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4(0),
 203   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5(0),
 204   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD(0),
 205   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD(0),
 206   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD(0),
 207   fHistList(0),
 208   fPtAllTPC(0),
 209   fPtSelTPC(0),
 210   fPtSelTPCITS(0),
 211   fHistListTPC(0),
 212   fPtSelITS(0),
 213   fPtITSminPtTPCvsPtITS(0),
 214   fPtITSminPtTPCvsPtITSEtaPos(0),
 215   fPtITSminPtTPCvsPtITSEtaNeg(0),
 216   fPtITSminPtTPCvsPtITSNPointTPC(0),
 217   fPtITSminPtTPCvsPtITSDCAR(0),
 218   fPtITSminPtTPCvsPtITSDCAZ(0),
 219   fPtITSminPtTPCvsPtITSPhi(0),
 220   fPtITSminPtTPCvsPtITSNPointITS(0),
 221   fPtITSminPtTPCvsPtITSNSigmaToVertex(0),
 222   fPtITSminPtTPCvsPtITSChi2C(0),
 223   fPtITSminPtTPCvsPtITSRel1PtUncertainty(0),
 224   fPtITSminPtTPCvsPtITSChi2PerNClusTPC(0),
 225   fPtITSminPtTPCvsPtITSChi2PerNClusITS(0),
 226   fPtITSminPtTPCvsNPointTPCPhi(0),
 227   fPtITSminPtTPCvsNPointITSPhi(0),
 228   fPtITSminPtTPCvsRel1PtUncertaintyPhi(0),
 229   fPtRel1PtUncertaintyChi2PerClusTPC(0),
 230   fHistListITS(0)
 231 {
 232   //
 233   // Constructor. Initialization of Inputs and Outputs
 234   //
 235   Info("AliPWG4HighPtQATPConly","Calling Constructor");
 236   // Input slot #0 works with a TChain ESD
 237   DefineInput(0, TChain::Class());
 238   // Output slot #0, #1, #2 and #3 writes into a TList
 239   DefineOutput(0, TList::Class());
 240   DefineOutput(1, TList::Class());
 241   DefineOutput(2, TList::Class());
 242   // Output slot #4 and #5 writes into a AliESDtrackCuts
 243   DefineOutput(3, AliESDtrackCuts::Class());
 244   DefineOutput(4, AliESDtrackCuts::Class());
 245
 246 }
 247
 248 //________________________________________________________________________
 249 void AliPWG4HighPtQATPConly::LocalInit()
 250 {
 251   //
 252   // Only called once at beginning
 253   //
 254   PostData(3,fTrackCuts);
 255   PostData(4,fTrackCutsITS);
 256 }
 257
 258 //________________________________________________________________________
 259 void AliPWG4HighPtQATPConly::ConnectInputData(Option_t *)
 260 {
 261   // Connect ESD here
 262   // Called once
 263   AliDebug(2,Form(">> AliPWG4HighPtSpectra::ConnectInputData \n"));
 264   TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
 265   if (!tree) {
 266     AliDebug(2,Form( "ERROR: Could not read chain from input slot 0 \n"));
 267     return;
 268   }
 269
 270   AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 271
 272   if (!esdH) {
 273     AliDebug(2,Form("ERROR: Could not get ESDInputHandler"));
 274     return;
 275   } else
 276     fESD = esdH->GetEvent();
 277
 278   fESDfriend = esdH->GetESDfriend();
 279
 280 }
 281
 282 //________________________________________________________________________
 283 void AliPWG4HighPtQATPConly::CreateOutputObjects() {
 284   //Create output objects
 285   AliDebug(2,Form(">> AliPWG4HighPtQATPConly::CreateOutputObjects \n"));
 286
 287   Bool_t oldStatus = TH1::AddDirectoryStatus();
 288   TH1::AddDirectory(kFALSE);
 289
 290   OpenFile(0);
 291   fHistList = new TList();
 292   fHistList->SetOwner(kTRUE);
 293   OpenFile(1);
 294   fHistListTPC = new TList();
 295   fHistListTPC->SetOwner(kTRUE);
 296   OpenFile(2);
 297   fHistListITS = new TList();
 298   fHistListITS->SetOwner(kTRUE);
 299
 300   Int_t fgkNPhiBins=18;
 301   Float_t kMinPhi = 0.;
 302   Float_t kMaxPhi = 2.*TMath::Pi();
 303   Double_t *binsPhi=new Double_t[fgkNPhiBins+1];
 304   for(Int_t i=0; i<=fgkNPhiBins; i++) binsPhi[i]=(Double_t)kMinPhi + (kMaxPhi-kMinPhi)/fgkNPhiBins*(Double_t)i ;
 305
 306   Float_t fgkPtMin=0.;
 307   Float_t fgkPtMax=fPtMax;
 308
 309   Float_t ptBinEdges[2][2];
 310   ptBinEdges[0][0] = 10.;
 311   ptBinEdges[0][1] = 1.;
 312   ptBinEdges[1][0] = 20.;
 313   ptBinEdges[1][1] = 2.;
 314   Float_t binWidth3 = 5.;
 315   if(fPtMax>100.) {
 316     ptBinEdges[0][0] = 100.;
 317     ptBinEdges[0][1] = 5.;
 318     ptBinEdges[1][0] = 300.;
 319     ptBinEdges[1][1] = 10.;
 320     binWidth3 = 20.;
 321   }
 322
 323   const Float_t ptmin1 =  fgkPtMin;
 324   const Float_t ptmax1 =  ptBinEdges[0][0];
 325   const Float_t ptmin2 =  ptmax1 ;
 326   const Float_t ptmax2 =  ptBinEdges[1][0];
 327   const Float_t ptmin3 =  ptmax2 ;
 328   const Float_t ptmax3 =  fgkPtMax;
 329   const Int_t nbin11 = (int)((ptmax1-ptmin1)/ptBinEdges[0][1]);
 330   const Int_t nbin12 = (int)((ptmax2-ptmin2)/ptBinEdges[1][1])+nbin11;
 331   const Int_t nbin13 = (int)((ptmax3-ptmin3)/binWidth3)+nbin12;
 332   Int_t fgkNPtBins=nbin13;
 333   //Create array with low edges of each bin
 334   Double_t *binsPt=new Double_t[fgkNPtBins+1];
 335   for(Int_t i=0; i<=fgkNPtBins; i++) {
 336     if(i<=nbin11) binsPt[i]=(Double_t)ptmin1 + (ptmax1-ptmin1)/nbin11*(Double_t)i ;
 337     if(i<=nbin12 && i>nbin11) binsPt[i]=(Double_t)ptmin2 + (ptmax2-ptmin2)/(nbin12-nbin11)*((Double_t)i-(Double_t)nbin11) ;
 338     if(i<=nbin13 && i>nbin12) binsPt[i]=(Double_t)ptmin3 + (ptmax3-ptmin3)/(nbin13-nbin12)*((Double_t)i-(Double_t)nbin12) ;
 339   }
 340
 341   Float_t fgkChi2PerClusMin = 0.;
 342   Float_t fgkChi2PerClusMax = 4.;
 343   Int_t fgkNChi2PerClusBins = (int)(fgkChi2PerClusMax*10.);
 344   Double_t *binsChi2PerClus=new Double_t[fgkNChi2PerClusBins+1];
 345   for(Int_t i=0; i<=fgkNChi2PerClusBins; i++) binsChi2PerClus[i]=(Double_t)fgkChi2PerClusMin + (fgkChi2PerClusMax-fgkChi2PerClusMin)/fgkNChi2PerClusBins*(Double_t)i ;
 346
 347   Int_t fgkNResPtBins=80;
 348   Float_t fgkResPtMin = -1.;
 349   Float_t fgkResPtMax = 1.;
 350   Double_t *binsResPt=new Double_t[fgkNResPtBins+1];
 351   for(Int_t i=0; i<=fgkNResPtBins; i++) binsResPt[i]=(Double_t)fgkResPtMin + (fgkResPtMax-fgkResPtMin)/fgkNResPtBins*(Double_t)i ;
 352
 353   Int_t fgkNEtaBins=20;
 354   Float_t fgkEtaMin = -1.;
 355   Float_t fgkEtaMax = 1.;
 356   Double_t *binsEta=new Double_t[fgkNEtaBins+1];
 357   for(Int_t i=0; i<=fgkNEtaBins; i++) binsEta[i]=(Double_t)fgkEtaMin + (fgkEtaMax-fgkEtaMin)/fgkNEtaBins*(Double_t)i ;
 358
 359   Int_t fgkNNPointTPCBins=80;
 360   Float_t fgkNPointTPCMin = 0.5;
 361   Float_t fgkNPointTPCMax = 160.5;
 362   Double_t *binsNPointTPC=new Double_t[fgkNNPointTPCBins+1];
 363   for(Int_t i=0; i<=fgkNNPointTPCBins; i++) binsNPointTPC[i]=(Double_t)fgkNPointTPCMin + (fgkNPointTPCMax-fgkNPointTPCMin)/fgkNNPointTPCBins*(Double_t)i ;
 364
 365   Int_t fgkNDCARBins=80;
 366   Float_t fgkDCARMin = -0.2;
 367   Float_t fgkDCARMax = 0.2;
 368   Double_t *binsDCAR=new Double_t[fgkNDCARBins+1];
 369   for(Int_t i=0; i<=fgkNDCARBins; i++) binsDCAR[i]=(Double_t)fgkDCARMin + (fgkDCARMax-fgkDCARMin)/fgkNDCARBins*(Double_t)i ;
 370
 371   Int_t fgkNDCAZBins=80;
 372   Float_t fgkDCAZMin = -2.;
 373   Float_t fgkDCAZMax = 2.;
 374   Double_t *binsDCAZ=new Double_t[fgkNDCAZBins+1];
 375   for(Int_t i=0; i<=fgkNDCAZBins; i++) binsDCAZ[i]=(Double_t)fgkDCAZMin + (fgkDCAZMax-fgkDCAZMin)/fgkNDCAZBins*(Double_t)i ;
 376
 377   Int_t fgkNNPointITSBins=9;
 378   Float_t fgkNPointITSMin = -0.5;
 379   Float_t fgkNPointITSMax = 8.5;
 380   Double_t *binsNPointITS=new Double_t[fgkNNPointITSBins+1];
 381   for(Int_t i=0; i<=fgkNNPointITSBins; i++) binsNPointITS[i]=(Double_t)fgkNPointITSMin + (fgkNPointITSMax-fgkNPointITSMin)/fgkNNPointITSBins*(Double_t)i ;
 382
 383   Int_t fgkNNSigmaToVertexBins=40;
 384   Float_t fgkNSigmaToVertexMin = 0.;
 385   Float_t fgkNSigmaToVertexMax = 8.;
 386   Double_t *binsNSigmaToVertex=new Double_t[fgkNNSigmaToVertexBins+1];
 387   for(Int_t i=0; i<=fgkNNSigmaToVertexBins; i++) binsNSigmaToVertex[i]=(Double_t)fgkNSigmaToVertexMin + (fgkNSigmaToVertexMax-fgkNSigmaToVertexMin)/fgkNNSigmaToVertexBins*(Double_t)i ;
 388
 389   Int_t fgkNChi2CBins=20;
 390   Float_t fgkChi2CMin = 0.;
 391   Float_t fgkChi2CMax = 10.;
 392   Double_t *binsChi2C=new Double_t[fgkNChi2CBins+1];
 393   for(Int_t i=0; i<=fgkNChi2CBins; i++) binsChi2C[i]=(Double_t)fgkChi2CMin + (fgkChi2CMax-fgkChi2CMin)/fgkNChi2CBins*(Double_t)i ;
 394
 395   Int_t fgkNRel1PtUncertaintyBins=30;
 396   Float_t fgkRel1PtUncertaintyMin = 0.;
 397   Float_t fgkRel1PtUncertaintyMax = 0.3;
 398   Double_t *binsRel1PtUncertainty=new Double_t[fgkNRel1PtUncertaintyBins+1];
 399   for(Int_t i=0; i<=fgkNRel1PtUncertaintyBins; i++) binsRel1PtUncertainty[i]=(Double_t)fgkRel1PtUncertaintyMin + (fgkRel1PtUncertaintyMax-fgkRel1PtUncertaintyMin)/fgkNRel1PtUncertaintyBins*(Double_t)i ;
 400
 401   fNEventAll = new TH1F("fNEventAll","NEventAll",1,-0.5,0.5);
 402   fHistList->Add(fNEventAll);
 403   fNEventSel = new TH1F("fNEventSel","NEvent Selected for analysis",1,-0.5,0.5);
 404   fHistList->Add(fNEventSel);
 405   fPtAll = new TH1F("fPtAll","PtAll",fgkNPtBins, binsPt);
 406   fHistList->Add(fPtAll);
 407   fPtSel = new TH1F("fPtSel","PtSel",fgkNPtBins, binsPt);
 408   fHistList->Add(fPtSel);
 409
 410   fPtAllminPtTPCvsPtAll = new TH2F("fPtAllminPtTPCvsPtAll","PtAllminPtTPCvsPtAll",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 411   fPtAllminPtTPCvsPtAll->SetXTitle("p_{t}^{Global}");
 412   fPtAllminPtTPCvsPtAll->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 413   fHistList->Add(fPtAllminPtTPCvsPtAll);
 414
 415   fPtAllminPtTPCvsPtAllEtaPos = new TH3F("fPtAllminPtTPCvsPtAllEtaPos","PtAllminPtTPCvsPtAllEtaPos",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNEtaBins,binsEta);
 416   fPtAllminPtTPCvsPtAllEtaPos->SetXTitle("p_{t}^{Global}");
 417   fPtAllminPtTPCvsPtAllEtaPos->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 418   fPtAllminPtTPCvsPtAllEtaPos->SetZTitle("#eta");
 419   fHistList->Add(fPtAllminPtTPCvsPtAllEtaPos);
 420
 421   fPtAllminPtTPCvsPtAllEtaNeg = new TH3F("fPtAllminPtTPCvsPtAllEtaNeg","PtAllminPtTPCvsPtAllEtaNeg",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNEtaBins,binsEta);
 422   fPtAllminPtTPCvsPtAllEtaNeg->SetXTitle("p_{t}^{Global}");
 423   fPtAllminPtTPCvsPtAllEtaNeg->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 424   fPtAllminPtTPCvsPtAllEtaNeg->SetZTitle("#eta");
 425   fHistList->Add(fPtAllminPtTPCvsPtAllEtaNeg);
 426
 427   fPtAllminPtTPCvsPtAllNPointTPC = new TH3F("fPtAllminPtTPCvsPtAllNPointTPC","PtAllminPtTPCvsPtAllNPointTPC",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNNPointTPCBins,binsNPointTPC);
 428   fPtAllminPtTPCvsPtAllNPointTPC->SetXTitle("p_{t}^{Global}");
 429   fPtAllminPtTPCvsPtAllNPointTPC->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 430   fPtAllminPtTPCvsPtAllNPointTPC->SetZTitle("N_{point,TPC}");
 431   fHistList->Add(fPtAllminPtTPCvsPtAllNPointTPC);
 432
 433   fPtAllminPtTPCvsPtAllDCAR = new TH3F("fPtAllminPtTPCvsPtAllDCAR","PtAllminPtTPCvsPtAllDCAR",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNDCARBins,binsDCAR);
 434   fPtAllminPtTPCvsPtAllDCAR->SetXTitle("p_{t}^{Global}");
 435   fPtAllminPtTPCvsPtAllDCAR->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 436   fPtAllminPtTPCvsPtAllDCAR->SetZTitle("DCA_{R}");
 437   fHistList->Add(fPtAllminPtTPCvsPtAllDCAR);
 438
 439   fPtAllminPtTPCvsPtAllDCAZ = new TH3F("fPtAllminPtTPCvsPtAllDCAZ","PtAllminPtTPCvsPtAllDCAZ",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNDCAZBins,binsDCAZ);
 440   fPtAllminPtTPCvsPtAllDCAZ->SetXTitle("p_{t}^{Global}");
 441   fPtAllminPtTPCvsPtAllDCAZ->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 442   fPtAllminPtTPCvsPtAllDCAZ->SetZTitle("DCA_{Z}");
 443   fHistList->Add(fPtAllminPtTPCvsPtAllDCAZ);
 444
 445   fPtAllminPtTPCvsPtAllPhi = new TH3F("fPtAllminPtTPCvsPtAllPhi","PtAllminPtTPCvsPtAllPhi",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNPhiBins,binsPhi);
 446   fPtAllminPtTPCvsPtAllPhi->SetXTitle("p_{t}^{Global}");
 447   fPtAllminPtTPCvsPtAllPhi->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 448   fPtAllminPtTPCvsPtAllPhi->SetZTitle("#phi");
 449   fHistList->Add(fPtAllminPtTPCvsPtAllPhi);
 450
 451   fPtAllminPtTPCvsPtAllNPointITS = new TH3F("fPtAllminPtTPCvsPtAllNPointITS","PtAllminPtTPCvsPtAllNPointITS",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNNPointITSBins,binsNPointITS);
 452   fPtAllminPtTPCvsPtAllNPointITS->SetXTitle("p_{t}^{Global}");
 453   fPtAllminPtTPCvsPtAllNPointITS->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 454   fPtAllminPtTPCvsPtAllNPointITS->SetZTitle("N_{point,ITS}");
 455   fHistList->Add(fPtAllminPtTPCvsPtAllNPointITS);
 456
 457   fPtAllminPtTPCvsPtAllNSigmaToVertex = new TH3F("fPtAllminPtTPCvsPtAllNSigmaToVertex","PtAllminPtTPCvsPtAllNSigmaToVertex",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNNSigmaToVertexBins,binsNSigmaToVertex);
 458   fPtAllminPtTPCvsPtAllNSigmaToVertex->SetXTitle("p_{t}^{Global}");
 459   fPtAllminPtTPCvsPtAllNSigmaToVertex->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 460   fPtAllminPtTPCvsPtAllNSigmaToVertex->SetZTitle("N#sigma to vertex");
 461   fHistList->Add(fPtAllminPtTPCvsPtAllNSigmaToVertex);
 462
 463   fPtAllminPtTPCvsPtAllChi2C = new TH3F("fPtAllminPtTPCvsPtAllChi2C","PtAllminPtTPCvsPtAllChi2C",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2CBins,binsChi2C);
 464   fPtAllminPtTPCvsPtAllChi2C->SetXTitle("p_{t}^{Global}");
 465   fPtAllminPtTPCvsPtAllChi2C->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 466   fPtAllminPtTPCvsPtAllChi2C->SetZTitle("Constrained #chi^{2}");
 467   fHistList->Add(fPtAllminPtTPCvsPtAllChi2C);
 468
 469   fPtAllminPtTPCvsPtAllRel1PtUncertainty = new TH3F("fPtAllminPtTPCvsPtAllRel1PtUncertainty","PtAllminPtTPCvsPtAllRel1PtUncertainty",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty);
 470   fPtAllminPtTPCvsPtAllRel1PtUncertainty->SetXTitle("p_{t}^{Global}");
 471   fPtAllminPtTPCvsPtAllRel1PtUncertainty->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 472   fPtAllminPtTPCvsPtAllRel1PtUncertainty->SetZTitle("Rel1PtUncertainty");
 473   fHistList->Add(fPtAllminPtTPCvsPtAllRel1PtUncertainty);
 474
 475   fPtAllminPtTPCvsPtAllChi2PerNClusTPC = new TH3F("fPtAllminPtTPCvsPtAllChi2PerNClusTPC","PtAllminPtTPCvsPtAllChi2PerNClusTPC",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 476   fPtAllminPtTPCvsPtAllChi2PerNClusTPC->SetXTitle("p_{t}^{Global}");
 477   fPtAllminPtTPCvsPtAllChi2PerNClusTPC->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 478   fPtAllminPtTPCvsPtAllChi2PerNClusTPC->SetZTitle("#chi^{2}/(2*NClusTPC-5)");
 479   fHistList->Add(fPtAllminPtTPCvsPtAllChi2PerNClusTPC);
 480
 481   fPtAllminPtTPCvsPtAllChi2PerNClusITS = new TH3F("fPtAllminPtTPCvsPtAllChi2PerNClusITS","PtAllminPtTPCvsPtAllChi2PerNClusITS",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 482   fPtAllminPtTPCvsPtAllChi2PerNClusITS->SetXTitle("p_{t}^{Global}");
 483   fPtAllminPtTPCvsPtAllChi2PerNClusITS->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 484   fPtAllminPtTPCvsPtAllChi2PerNClusITS->SetZTitle("#chi^{2}/(2*NClusITS-5)");
 485   fHistList->Add(fPtAllminPtTPCvsPtAllChi2PerNClusITS);
 486
 487   fPtAllminPtTPCvsNPointTPCPhi = new TH3F("fPtAllminPtTPCvsNPointTPCPhi","PtAllminPtTPCvsNPointTPCPhi",fgkNResPtBins,binsResPt,fgkNNPointTPCBins,binsNPointTPC,fgkNPhiBins,binsPhi);
 488   fPtAllminPtTPCvsNPointTPCPhi->SetXTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 489   fPtAllminPtTPCvsNPointTPCPhi->SetYTitle("N_{point,TPC}");
 490   fPtAllminPtTPCvsNPointTPCPhi->SetZTitle("#phi");
 491   fHistList->Add(fPtAllminPtTPCvsNPointTPCPhi);
 492
 493   fPtAllminPtTPCvsNPointITSPhi = new TH3F("fPtAllminPtTPCvsNPointITSPhi","PtAllminPtTPCvsNPointITSPhi",fgkNResPtBins,binsResPt,fgkNNPointITSBins,binsNPointITS,fgkNPhiBins,binsPhi);
 494   fPtAllminPtTPCvsNPointITSPhi->SetXTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 495   fPtAllminPtTPCvsNPointITSPhi->SetYTitle("N_{point,ITS}");
 496   fPtAllminPtTPCvsNPointITSPhi->SetZTitle("#phi");
 497   fHistList->Add(fPtAllminPtTPCvsNPointITSPhi);
 498
 499   fPtAllminPtTPCvsRel1PtUncertaintyPhi = new TH3F("fPtAllminPtTPCvsRel1PtUncertaintyPhi","PtAllminPtTPCvsRel1PtUncertaintyPhi",fgkNResPtBins,binsResPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNPhiBins,binsPhi);
 500   fPtAllminPtTPCvsRel1PtUncertaintyPhi->SetXTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 501   fPtAllminPtTPCvsRel1PtUncertaintyPhi->SetYTitle("Rel1PtUncertainty");
 502   fPtAllminPtTPCvsRel1PtUncertaintyPhi->SetZTitle("#phi");
 503   fHistList->Add(fPtAllminPtTPCvsRel1PtUncertaintyPhi);
 504
 505   fEtaPhiOutliers = new TH2F("fEtaPhiOutliers","PtAllminPtTPCvsPtAll",20, -1.,1.,fgkNPhiBins,binsPhi);
 506   fEtaPhiOutliers->SetXTitle("#eta");
 507   fEtaPhiOutliers->SetYTitle("#phi");
 508   fHistList->Add(fEtaPhiOutliers);
 509
 510   //Global vs ITSouter-TPCinner
 511   fPtSelITSouter = new TH1F("fPtSelITSouter","PtSelITSouter",fgkNPtBins,binsPt);
 512   fHistList->Add(fPtSelITSouter);
 513
 514   fPtITSouterminPtTPCvsPtAll = new TH2F("fPtITSouterminPtTPCvsPtAll","PtITSouterminPtTPCvsPtAll",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 515   fPtITSouterminPtTPCvsPtAll->SetXTitle("p_{t}^{Global}");
 516   fPtITSouterminPtTPCvsPtAll->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 517   fHistList->Add(fPtITSouterminPtTPCvsPtAll);
 518
 519   fPtITSouterminPtTPCvsPtAllEtaPos = new TH3F("fPtITSouterminPtTPCvsPtAllEtaPos","PtITSouterminPtTPCvsPtAllEtaPos",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNEtaBins,binsEta);
 520   fPtITSouterminPtTPCvsPtAllEtaPos->SetXTitle("p_{t}^{Global}");
 521   fPtITSouterminPtTPCvsPtAllEtaPos->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 522   fHistList->Add(fPtITSouterminPtTPCvsPtAllEtaPos);
 523
 524   fPtITSouterminPtTPCvsPtAllEtaNeg = new TH3F("fPtITSouterminPtTPCvsPtAllEtaNeg","PtITSouterminPtTPCvsPtAllEtaNeg",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNEtaBins,binsEta);
 525   fPtITSouterminPtTPCvsPtAllEtaNeg->SetXTitle("p_{t}^{Global}");
 526   fPtITSouterminPtTPCvsPtAllEtaNeg->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 527   fHistList->Add(fPtITSouterminPtTPCvsPtAllEtaNeg);
 528
 529   fPtITSouterminPtTPCvsPtAllNPointTPC = new TH3F("fPtITSouterminPtTPCvsPtAllNPointTPC","PtITSouterminPtTPCvsPtAllNPointTPC",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNNPointTPCBins,binsNPointTPC);
 530   fPtITSouterminPtTPCvsPtAllNPointTPC->SetXTitle("p_{t}^{Global}");
 531   fPtITSouterminPtTPCvsPtAllNPointTPC->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 532   fPtITSouterminPtTPCvsPtAllNPointTPC->SetZTitle("N_{point,TPC}");
 533   fHistList->Add(fPtITSouterminPtTPCvsPtAllNPointTPC);
 534
 535   fPtITSouterminPtTPCvsPtAllDCAR = new TH3F("fPtITSouterminPtTPCvsPtAllDCAR","PtITSouterminPtTPCvsPtAllDCAR",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNDCARBins,binsDCAR);
 536   fPtITSouterminPtTPCvsPtAllDCAR->SetXTitle("p_{t}^{Global}");
 537   fPtITSouterminPtTPCvsPtAllDCAR->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 538   fPtITSouterminPtTPCvsPtAllDCAR->SetZTitle("DCA_{R}");
 539   fHistList->Add(fPtITSouterminPtTPCvsPtAllDCAR);
 540
 541   fPtITSouterminPtTPCvsPtAllDCAZ = new TH3F("fPtITSouterminPtTPCvsPtAllDCAZ","PtITSouterminPtTPCvsPtAllDCAZ",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNDCAZBins,binsDCAZ);
 542   fPtITSouterminPtTPCvsPtAllDCAZ->SetXTitle("p_{t}^{Global}");
 543   fPtITSouterminPtTPCvsPtAllDCAZ->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 544   fPtITSouterminPtTPCvsPtAllDCAZ->SetZTitle("DCA_{Z}");
 545   fHistList->Add(fPtITSouterminPtTPCvsPtAllDCAZ);
 546
 547   fPtITSouterminPtTPCvsPtAllPhi = new TH3F("fPtITSouterminPtTPCvsPtAllPhi","PtITSouterminPtTPCvsPtAllPhi",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNPhiBins,binsPhi);
 548   fPtITSouterminPtTPCvsPtAllPhi->SetXTitle("p_{t}^{Global}");
 549   fPtITSouterminPtTPCvsPtAllPhi->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 550   fPtITSouterminPtTPCvsPtAllPhi->SetZTitle("#phi");
 551   fHistList->Add(fPtITSouterminPtTPCvsPtAllPhi);
 552
 553   fPtITSouterminPtTPCvsPtAllNPointITS = new TH3F("fPtITSouterminPtTPCvsPtAllNPointITS","PtITSouterminPtTPCvsPtAllNPointITS",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNNPointITSBins,binsNPointITS);
 554   fPtITSouterminPtTPCvsPtAllNPointITS->SetXTitle("p_{t}^{Global}");
 555   fPtITSouterminPtTPCvsPtAllNPointITS->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 556   fPtITSouterminPtTPCvsPtAllNPointITS->SetZTitle("N_{point,ITS}");
 557   fHistList->Add(fPtITSouterminPtTPCvsPtAllNPointITS);
 558
 559   fPtITSouterminPtTPCvsPtAllNSigmaToVertex = new TH3F("fPtITSouterminPtTPCvsPtAllNSigmaToVertex","PtITSouterminPtTPCvsPtAllNSigmaToVertex",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNNSigmaToVertexBins,binsNSigmaToVertex);
 560   fPtITSouterminPtTPCvsPtAllNSigmaToVertex->SetXTitle("p_{t}^{Global}");
 561   fPtITSouterminPtTPCvsPtAllNSigmaToVertex->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 562   fPtITSouterminPtTPCvsPtAllNSigmaToVertex->SetZTitle("N#sigma to vertex");
 563   fHistList->Add(fPtITSouterminPtTPCvsPtAllNSigmaToVertex);
 564
 565   fPtITSouterminPtTPCvsPtAllChi2C = new TH3F("fPtITSouterminPtTPCvsPtAllChi2C","PtITSouterminPtTPCvsPtAllChi2C",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2CBins,binsChi2C);
 566   fPtITSouterminPtTPCvsPtAllChi2C->SetXTitle("p_{t}^{Global}");
 567   fPtITSouterminPtTPCvsPtAllChi2C->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 568   fPtITSouterminPtTPCvsPtAllChi2C->SetZTitle("Constrained #chi^{2}");
 569   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2C);
 570
 571   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty = new TH3F("fPtITSouterminPtTPCvsPtAllRel1PtUncertainty","PtITSouterminPtTPCvsPtAllRel1PtUncertainty",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty);
 572   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty->SetXTitle("p_{t}^{Global}");
 573   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 574   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty->SetZTitle("Rel1PtUncertainty");
 575   fHistList->Add(fPtITSouterminPtTPCvsPtAllRel1PtUncertainty);
 576
 577   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC","PtITSouterminPtTPCvsPtAllChi2PerNClusTPC",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 578   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC->SetXTitle("p_{t}^{Global}");
 579   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 580   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC->SetZTitle("#chi^{2}/(2*NClusTPC-5)");
 581   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC);
 582
 583   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS","PtITSouterminPtTPCvsPtAllChi2PerNClusITS",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 584   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS->SetXTitle("p_{t}^{Global}");
 585   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 586   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS->SetZTitle("#chi^{2}/(2*NClusITS-5)");
 587   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS);
 588
 589   //As function of ITS layers
 590   fPtITSouterminPtTPCvsPtAllITSLayer0 = new TH2F("fPtITSouterminPtTPCvsPtAllITSLayer0","PtITSouterminPtTPCvsPtAllITSLayer0",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 591   fPtITSouterminPtTPCvsPtAllITSLayer0->SetXTitle("p_{t}^{Global}");
 592   fPtITSouterminPtTPCvsPtAllITSLayer0->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 593   fHistList->Add(fPtITSouterminPtTPCvsPtAllITSLayer0);
 594
 595   fPtITSouterminPtTPCvsPtAllITSLayer1 = new TH2F("fPtITSouterminPtTPCvsPtAllITSLayer1","PtITSouterminPtTPCvsPtAllITSLayer1",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 596   fPtITSouterminPtTPCvsPtAllITSLayer1->SetXTitle("p_{t}^{Global}");
 597   fPtITSouterminPtTPCvsPtAllITSLayer1->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 598   fHistList->Add(fPtITSouterminPtTPCvsPtAllITSLayer1);
 599
 600   fPtITSouterminPtTPCvsPtAllITSLayer2 = new TH2F("fPtITSouterminPtTPCvsPtAllITSLayer2","PtITSouterminPtTPCvsPtAllITSLayer2",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 601   fPtITSouterminPtTPCvsPtAllITSLayer2->SetXTitle("p_{t}^{Global}");
 602   fPtITSouterminPtTPCvsPtAllITSLayer2->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 603   fHistList->Add(fPtITSouterminPtTPCvsPtAllITSLayer2);
 604
 605   fPtITSouterminPtTPCvsPtAllITSLayer3 = new TH2F("fPtITSouterminPtTPCvsPtAllITSLayer3","PtITSouterminPtTPCvsPtAllITSLayer3",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 606   fPtITSouterminPtTPCvsPtAllITSLayer3->SetXTitle("p_{t}^{Global}");
 607   fPtITSouterminPtTPCvsPtAllITSLayer3->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 608   fHistList->Add(fPtITSouterminPtTPCvsPtAllITSLayer3);
 609
 610   fPtITSouterminPtTPCvsPtAllITSLayer4 = new TH2F("fPtITSouterminPtTPCvsPtAllITSLayer4","PtITSouterminPtTPCvsPtAllITSLayer4",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 611   fPtITSouterminPtTPCvsPtAllITSLayer4->SetXTitle("p_{t}^{Global}");
 612   fPtITSouterminPtTPCvsPtAllITSLayer4->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 613   fHistList->Add(fPtITSouterminPtTPCvsPtAllITSLayer4);
 614
 615   fPtITSouterminPtTPCvsPtAllITSLayer5 = new TH2F("fPtITSouterminPtTPCvsPtAllITSLayer5","PtITSouterminPtTPCvsPtAllITSLayer5",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 616   fPtITSouterminPtTPCvsPtAllITSLayer5->SetXTitle("p_{t}^{Global}");
 617   fPtITSouterminPtTPCvsPtAllITSLayer5->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 618   fHistList->Add(fPtITSouterminPtTPCvsPtAllITSLayer5);
 619
 620   fPtITSouterminPtTPCvsPtAllNoSPD = new TH2F("fPtITSouterminPtTPCvsPtAllNoSPD","PtITSouterminPtTPCvsPtAllNoSPD",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 621   fPtITSouterminPtTPCvsPtAllNoSPD->SetXTitle("p_{t}^{Global}");
 622   fPtITSouterminPtTPCvsPtAllNoSPD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 623   fHistList->Add(fPtITSouterminPtTPCvsPtAllNoSPD);
 624
 625   fPtITSouterminPtTPCvsPtAllNoSDD = new TH2F("fPtITSouterminPtTPCvsPtAllNoSDD","PtITSouterminPtTPCvsPtAllNoSDD",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 626   fPtITSouterminPtTPCvsPtAllNoSDD->SetXTitle("p_{t}^{Global}");
 627   fPtITSouterminPtTPCvsPtAllNoSDD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 628   fHistList->Add(fPtITSouterminPtTPCvsPtAllNoSDD);
 629
 630   fPtITSouterminPtTPCvsPtAllNoSSD = new TH2F("fPtITSouterminPtTPCvsPtAllNoSSD","PtITSouterminPtTPCvsPtAllNoSSD",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 631   fPtITSouterminPtTPCvsPtAllNoSSD->SetXTitle("p_{t}^{Global}");
 632   fPtITSouterminPtTPCvsPtAllNoSSD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 633   fHistList->Add(fPtITSouterminPtTPCvsPtAllNoSSD);
 634
 635   //
 636   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0","PtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 637   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0->SetXTitle("p_{t}^{Global}");
 638   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 639   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0->SetZTitle("#chi^{2}/NPointITS");
 640   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0);
 641
 642   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1","PtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 643   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1->SetXTitle("p_{t}^{Global}");
 644   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 645   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1->SetZTitle("#chi^{2}/NPointITS");
 646   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1);
 647
 648   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2","PtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 649   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2->SetXTitle("p_{t}^{Global}");
 650   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 651   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2->SetZTitle("#chi^{2}/NPointITS");
 652   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2);
 653
 654   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3","PtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 655   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3->SetXTitle("p_{t}^{Global}");
 656   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 657   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3->SetZTitle("#chi^{2}/NPointITS");
 658   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3);
 659
 660   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4","PtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 661   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4->SetXTitle("p_{t}^{Global}");
 662   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 663   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4->SetZTitle("#chi^{2}/NPointITS");
 664   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4);
 665
 666   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5","PtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 667   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5->SetXTitle("p_{t}^{Global}");
 668   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 669   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5->SetZTitle("#chi^{2}/NPointITS");
 670   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5);
 671
 672   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD","PtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 673   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD->SetXTitle("p_{t}^{Global}");
 674   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 675   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD->SetZTitle("#chi^{2}/(2*NPointITS-5)");
 676   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD);
 677
 678   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD","PtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 679   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD->SetXTitle("p_{t}^{Global}");
 680   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 681   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD->SetZTitle("#chi^{2}/(2*NPointITS-5)");
 682   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD);
 683
 684   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD","PtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 685   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD->SetXTitle("p_{t}^{Global}");
 686   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 687   fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD->SetZTitle("#chi^{2}/(2*NPointITS-5)");
 688   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD);
 689
 690
 691   //ITSrefit
 692   fPtSelITS = new TH1F("fPtSelITSrefit","PtSel",fgkNPtBins, binsPt);
 693   fHistListITS->Add(fPtSelITS);
 694
 695   fPtITSminPtTPCvsPtITS = new TH2F("fPtITSminPtTPCvsPtITS","PtITSminPtTPCvsPtITS",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt);
 696   fPtITSminPtTPCvsPtITS->SetXTitle("p_{t}^{Global}");
 697   fPtITSminPtTPCvsPtITS->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 698   fHistListITS->Add(fPtITSminPtTPCvsPtITS);
 699
 700   fPtITSminPtTPCvsPtITSEtaPos = new TH3F("fPtITSminPtTPCvsPtITSEtaPos","PtITSminPtTPCvsPtITSEtaPos",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNEtaBins,binsEta);
 701   fPtITSminPtTPCvsPtITSEtaPos->SetXTitle("p_{t}^{Global}");
 702   fPtITSminPtTPCvsPtITSEtaPos->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 703   fHistListITS->Add(fPtITSminPtTPCvsPtITSEtaPos);
 704
 705   fPtITSminPtTPCvsPtITSEtaNeg = new TH3F("fPtITSminPtTPCvsPtITSEtaNeg","PtITSminPtTPCvsPtITSEtaNeg",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNEtaBins,binsEta);
 706   fPtITSminPtTPCvsPtITSEtaNeg->SetXTitle("p_{t}^{Global}");
 707   fPtITSminPtTPCvsPtITSEtaNeg->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 708   fHistListITS->Add(fPtITSminPtTPCvsPtITSEtaNeg);
 709
 710   fPtITSminPtTPCvsPtITSNPointTPC = new TH3F("fPtITSminPtTPCvsPtITSNPointTPC","PtITSminPtTPCvsPtITSNPointTPC",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNNPointTPCBins,binsNPointTPC);
 711   fPtITSminPtTPCvsPtITSNPointTPC->SetXTitle("p_{t}^{Global}");
 712   fPtITSminPtTPCvsPtITSNPointTPC->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 713   fPtITSminPtTPCvsPtITSNPointTPC->SetZTitle("N_{point,TPC}");
 714   fHistListITS->Add(fPtITSminPtTPCvsPtITSNPointTPC);
 715
 716   fPtITSminPtTPCvsPtITSDCAR = new TH3F("fPtITSminPtTPCvsPtITSDCAR","PtITSminPtTPCvsPtITSDCAR",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNDCARBins,binsDCAR);
 717   fPtITSminPtTPCvsPtITSDCAR->SetXTitle("p_{t}^{Global}");
 718   fPtITSminPtTPCvsPtITSDCAR->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 719   fPtITSminPtTPCvsPtITSDCAR->SetZTitle("DCA_{R}");
 720   fHistListITS->Add(fPtITSminPtTPCvsPtITSDCAR);
 721
 722   fPtITSminPtTPCvsPtITSDCAZ = new TH3F("fPtITSminPtTPCvsPtITSDCAZ","PtITSminPtTPCvsPtITSDCAZ",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNDCAZBins,binsDCAZ);
 723   fPtITSminPtTPCvsPtITSDCAZ->SetXTitle("p_{t}^{Global}");
 724   fPtITSminPtTPCvsPtITSDCAZ->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 725   fPtITSminPtTPCvsPtITSDCAZ->SetZTitle("DCA_{Z}");
 726   fHistListITS->Add(fPtITSminPtTPCvsPtITSDCAZ);
 727
 728   fPtITSminPtTPCvsPtITSPhi = new TH3F("fPtITSminPtTPCvsPtITSPhi","PtITSminPtTPCvsPtITSPhi",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNPhiBins,binsPhi);
 729   fPtITSminPtTPCvsPtITSPhi->SetXTitle("p_{t}^{Global}");
 730   fPtITSminPtTPCvsPtITSPhi->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 731   fPtITSminPtTPCvsPtITSPhi->SetZTitle("#phi");
 732   fHistListITS->Add(fPtITSminPtTPCvsPtITSPhi);
 733
 734   fPtITSminPtTPCvsPtITSNPointITS = new TH3F("fPtITSminPtTPCvsPtITSNPointITS","PtITSminPtTPCvsPtITSNPointITS",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNNPointITSBins,binsNPointITS);
 735   fPtITSminPtTPCvsPtITSNPointITS->SetXTitle("p_{t}^{Global}");
 736   fPtITSminPtTPCvsPtITSNPointITS->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 737   fPtITSminPtTPCvsPtITSNPointITS->SetZTitle("N_{point,ITS}");
 738   fHistListITS->Add(fPtITSminPtTPCvsPtITSNPointITS);
 739
 740   fPtITSminPtTPCvsPtITSNSigmaToVertex = new TH3F("fPtITSminPtTPCvsPtITSNSigmaToVertex","PtITSminPtTPCvsPtITSNSigmaToVertex",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNNSigmaToVertexBins,binsNSigmaToVertex);
 741   fPtITSminPtTPCvsPtITSNSigmaToVertex->SetXTitle("p_{t}^{Global}");
 742   fPtITSminPtTPCvsPtITSNSigmaToVertex->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 743   fPtITSminPtTPCvsPtITSNSigmaToVertex->SetZTitle("N#sigma to vertex");
 744   fHistListITS->Add(fPtITSminPtTPCvsPtITSNSigmaToVertex);
 745
 746   fPtITSminPtTPCvsPtITSChi2C = new TH3F("fPtITSminPtTPCvsPtITSChi2C","PtITSminPtTPCvsPtITSChi2C",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2CBins,binsChi2C);
 747   fPtITSminPtTPCvsPtITSChi2C->SetXTitle("p_{t}^{Global}");
 748   fPtITSminPtTPCvsPtITSChi2C->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 749   fPtITSminPtTPCvsPtITSChi2C->SetZTitle("Constrained #chi^{2}");
 750   fHistListITS->Add(fPtITSminPtTPCvsPtITSChi2C);
 751
 752   fPtITSminPtTPCvsPtITSRel1PtUncertainty = new TH3F("fPtITSminPtTPCvsPtITSRel1PtUncertainty","PtITSminPtTPCvsPtITSRel1PtUncertainty",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty);
 753   fPtITSminPtTPCvsPtITSRel1PtUncertainty->SetXTitle("p_{t}^{Global}");
 754   fPtITSminPtTPCvsPtITSRel1PtUncertainty->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 755   fPtITSminPtTPCvsPtITSRel1PtUncertainty->SetZTitle("Rel1PtUncertainty");
 756   fHistListITS->Add(fPtITSminPtTPCvsPtITSRel1PtUncertainty);
 757
 758   fPtITSminPtTPCvsPtITSChi2PerNClusTPC = new TH3F("fPtITSminPtTPCvsPtITSChi2PerNClusTPC","PtITSminPtTPCvsPtITSChi2PerNClusTPC",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 759   fPtITSminPtTPCvsPtITSChi2PerNClusTPC->SetXTitle("p_{t}^{Global}");
 760   fPtITSminPtTPCvsPtITSChi2PerNClusTPC->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 761   fPtITSminPtTPCvsPtITSChi2PerNClusTPC->SetZTitle("#chi^{2}/(2*NClusTPC-5)");
 762   fHistListITS->Add(fPtITSminPtTPCvsPtITSChi2PerNClusTPC);
 763
 764   fPtITSminPtTPCvsPtITSChi2PerNClusITS = new TH3F("fPtITSminPtTPCvsPtITSChi2PerNClusITS","PtITSminPtTPCvsPtITSChi2PerNClusITS",fgkNPtBins, binsPt,fgkNResPtBins,binsResPt,fgkNChi2PerClusBins,binsChi2PerClus);
 765   fPtITSminPtTPCvsPtITSChi2PerNClusITS->SetXTitle("p_{t}^{Global}");
 766   fPtITSminPtTPCvsPtITSChi2PerNClusITS->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 767   fPtITSminPtTPCvsPtITSChi2PerNClusITS->SetZTitle("#chi^{2}/(2*NClusITS-5)");
 768   fHistListITS->Add(fPtITSminPtTPCvsPtITSChi2PerNClusITS);
 769
 770   fPtITSminPtTPCvsNPointTPCPhi = new TH3F("fPtITSminPtTPCvsNPointTPCPhi","PtITSminPtTPCvsNPointTPCPhi",fgkNResPtBins,binsResPt,fgkNNPointTPCBins,binsNPointTPC,fgkNPhiBins,binsPhi);
 771   fPtITSminPtTPCvsNPointTPCPhi->SetXTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 772   fPtITSminPtTPCvsNPointTPCPhi->SetYTitle("N_{point,TPC}");
 773   fPtITSminPtTPCvsNPointTPCPhi->SetZTitle("#phi");
 774   fHistListITS->Add(fPtITSminPtTPCvsNPointTPCPhi);
 775
 776   fPtITSminPtTPCvsNPointITSPhi = new TH3F("fPtITSminPtTPCvsNPointITSPhi","PtITSminPtTPCvsNPointITSPhi",fgkNResPtBins,binsResPt,fgkNNPointITSBins,binsNPointITS,fgkNPhiBins,binsPhi);
 777   fPtITSminPtTPCvsNPointITSPhi->SetXTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 778   fPtITSminPtTPCvsNPointITSPhi->SetYTitle("N_{point,ITS}");
 779   fPtITSminPtTPCvsNPointITSPhi->SetZTitle("#phi");
 780   fHistListITS->Add(fPtITSminPtTPCvsNPointITSPhi);
 781
 782   fPtITSminPtTPCvsRel1PtUncertaintyPhi = new TH3F("fPtITSminPtTPCvsRel1PtUncertaintyPhi","PtITSminPtTPCvsRel1PtUncertaintyPhi",fgkNResPtBins,binsResPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNPhiBins,binsPhi);
 783   fPtITSminPtTPCvsRel1PtUncertaintyPhi->SetXTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 784   fPtITSminPtTPCvsRel1PtUncertaintyPhi->SetYTitle("Rel1PtUncertainty");
 785   fPtITSminPtTPCvsRel1PtUncertaintyPhi->SetZTitle("#phi");
 786   fHistListITS->Add(fPtITSminPtTPCvsRel1PtUncertaintyPhi);
 787
 788   fPtRel1PtUncertaintyChi2PerClusTPC = new TH3F("fPtRel1PtUncertaintyChi2PerClusTPC","PtITSminPtTPCvsPtITSRel1PtUncertainty",fgkNPtBins, binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNChi2PerClusBins,binsChi2PerClus);
 789   fPtRel1PtUncertaintyChi2PerClusTPC->SetXTitle("p_{t}^{global}");
 790   fPtRel1PtUncertaintyChi2PerClusTPC->SetYTitle("Rel1PtUncertainty");
 791   fPtRel1PtUncertaintyChi2PerClusTPC->SetZTitle("#chi^{2}/(2*N_{clusters}^{TPC}-5)");
 792   fHistListITS->Add(fPtRel1PtUncertaintyChi2PerClusTPC);
 793
 794   fPtAllTPC = new TH1F("fPtAllTPC","PtAll",fgkNPtBins,binsPt);
 795   fHistListTPC->Add(fPtAllTPC);
 796   fPtSelTPC = new TH1F("fPtSelTPC","PtSel",fgkNPtBins,binsPt);
 797   fHistListTPC->Add(fPtSelTPC);
 798   fPtSelTPCITS = new TH1F("fPtSelTPCITS","PtSel",fgkNPtBins,binsPt);
 799   fHistListTPC->Add(fPtSelTPCITS);
 800
 801   TH1::AddDirectory(oldStatus);
 802
 803   if(binsPhi) delete [] binsPhi;
 804   if(binsChi2PerClus) delete [] binsChi2PerClus;
 805   if(binsPt) delete [] binsPt;
 806   if(binsResPt) delete [] binsResPt;
 807   if(binsNPointTPC) delete [] binsNPointTPC;
 808   if(binsDCAR) delete [] binsDCAR;
 809   if(binsDCAZ) delete [] binsDCAZ;
 810   if(binsNPointITS) delete [] binsNPointITS;
 811   if(binsNSigmaToVertex) delete [] binsNSigmaToVertex;
 812   if(binsChi2C) delete [] binsChi2C;
 813   if(binsEta) delete [] binsEta;
 814   if(binsRel1PtUncertainty) delete [] binsRel1PtUncertainty;
 815
 816
 817 }
 818 //________________________________________________________________________
 819 void AliPWG4HighPtQATPConly::Exec(Option_t *) {
 820   // Main loop
 821   // Called for each event
 822   AliDebug(2,Form(">> AliPWG4HighPtQATPConly::Exec \n"));
 823
 824   // All events without selection
 825   fNEventAll->Fill(0.);
 826
 827   if (!fESD) {
 828     AliDebug(2,Form("ERROR: fESD not available"));
 829     // Post output data
 830      PostData(0, fHistList);
 831      PostData(1, fHistListTPC);
 832      PostData(2, fHistListITS);
 833     return;
 834   }
 835
 836   UInt_t isSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
 837   if(!(isSelected&AliVEvent::kMB)) { //Select collison candidates
 838     AliDebug(2,Form(" Trigger Selection: event REJECTED ... "));
 839     // Post output data
 840      PostData(0, fHistList);
 841      PostData(1, fHistListTPC);
 842      PostData(2, fHistListITS);
 843     return;
 844   }
 845
 846   const AliESDVertex *vtx = fESD->GetPrimaryVertexTracks();
 847   // Need vertex cut
 848   TString vtxName(vtx->GetName());
 849   if(vtx->GetNContributors() < 2 || (vtxName.Contains("TPCVertex")) ) {
 850     // SPD vertex
 851     vtx = fESD->GetPrimaryVertexSPD();
 852     if(vtx->GetNContributors()<2) {
 853       vtx = 0x0;
 854       // Post output data
 855       PostData(0, fHistList);
 856       PostData(1, fHistListTPC);
 857       PostData(2, fHistListITS);
 858       return;
 859     }
 860   }
 861
 862   AliDebug(2,Form("Vertex title %s, status %d, nCont %d\n",vtx->GetTitle(), vtx->GetStatus(), vtx->GetNContributors()));
 863   double primVtx[3] = {0.,0.,0.};
 864   vtx->GetXYZ(primVtx);
 865   //  printf("primVtx: %g  %g  %g \n",primVtx[0],primVtx[1],primVtx[2]);
 866   if(TMath::Sqrt(primVtx[0]*primVtx[0] + primVtx[1]*primVtx[1])>1. || TMath::Abs(primVtx[2]>10.)){
 867     // Post output data
 868     PostData(0, fHistList);
 869     PostData(1, fHistListTPC);
 870     PostData(2, fHistListITS);
 871     return;
 872   }
 873   if(!fESD->GetNumberOfTracks() || fESD->GetNumberOfTracks()<2){
 874     // Post output data
 875     PostData(0, fHistList);
 876     PostData(1, fHistListTPC);
 877     PostData(2, fHistListITS);
 878     return;
 879   }
 880   Int_t nTracks = fESD->GetNumberOfTracks();
 881   AliDebug(2,Form("nTracks %d\n", nTracks));
 882
 883   if(!fTrackCuts) {
 884    // Post output data
 885     PostData(0, fHistList);
 886     PostData(1, fHistListTPC);
 887     PostData(2, fHistListITS);
 888     return;
 889   }
 890
 891   // Selected events for analysis
 892   fNEventSel->Fill(0.);
 893
 894   for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
 895
 896     AliESDtrack *track = fESD->GetTrack(iTrack);
 897     AliExternalTrackParam *trackTPC = (AliExternalTrackParam *)track->GetTPCInnerParam();
 898     if(!track || !trackTPC) continue;
 899
 900     const AliESDfriendTrack* constfriendtrack = 0x0;
 901     if(fESDfriend && fESDfriend->TestSkipBit()==kFALSE) constfriendtrack = track->GetFriendTrack();
 902
 903     Float_t pt = track->Pt();
 904     Float_t ptTPC = trackTPC->Pt();
 905     Float_t phi = track->Phi();
 906     Float_t dca2D = 0.;
 907     Float_t dcaZ = 0.;
 908
 909     track->GetImpactParameters(dca2D,dcaZ);
 910
 911     UChar_t itsMap = track->GetITSClusterMap();
 912     Int_t nPointITS = 0;
 913     for (Int_t i=0; i < 6; i++) {
 914       if (itsMap & (1 << i))
 915         nPointITS ++;
 916     }
 917     double mom[3] = {0.,0.,0.};
 918     track->GetPxPyPz(mom);
 919     double momTPC[3] = {0.,0.,0.};
 920     trackTPC->GetPxPyPz(momTPC);
 921     Float_t nSigmaToVertex = fTrackCuts->GetSigmaToVertex(track);// Calculates the number of sigma to the vertex for a track.
 922     Float_t chi2C = track->GetConstrainedChi2();
 923     Float_t relUncertainty1Pt = TMath::Sqrt(TMath::Abs(track->GetSigma1Pt2()))*pt;
 924     Float_t chi2PerClusterTPC = -1.;
 925     Float_t nClustersTPC = track->GetTPCNcls();
 926     if(nClustersTPC>0.) chi2PerClusterTPC = track->GetTPCchi2()/(2.*nClustersTPC-5.);
 927     Float_t chi2PerNPointITS = -1.;
 928     if(nPointITS>3) chi2PerNPointITS = track->GetITSchi2()/(2.*(float)nPointITS-5.);
 929
 930     fPtAll->Fill(pt);
 931     fPtAllTPC->Fill(ptTPC);
 932
 933     if (fTrackCuts->AcceptTrack(track)) {
 934       fPtSel->Fill(pt);
 935       fPtSelTPC->Fill(ptTPC);
 936       if(ptTPC==0. || pt==0.) continue;
 937       fPtAllminPtTPCvsPtAll->Fill(pt,(1./pt-1./ptTPC)/(1./pt) );
 938
 939       if(track->GetSign()>0.) fPtAllminPtTPCvsPtAllEtaPos->Fill(pt,(1./pt-1./ptTPC)/(1./pt),track->Eta());
 940       if(track->GetSign()<0.) fPtAllminPtTPCvsPtAllEtaNeg->Fill(pt,(1./pt-1./ptTPC)/(1./pt),track->Eta());
 941
 942       fPtAllminPtTPCvsPtAllNPointTPC->Fill(pt,(1./pt-1./ptTPC)/(1./pt),nClustersTPC);
 943       fPtAllminPtTPCvsPtAllDCAR->Fill(pt,(1./pt-1./ptTPC)/(1./pt),dca2D);
 944       fPtAllminPtTPCvsPtAllDCAZ->Fill(pt,(1./pt-1./ptTPC)/(1./pt),dcaZ);
 945       fPtAllminPtTPCvsPtAllPhi->Fill(pt,(1./pt-1./ptTPC)/(1./pt),phi);
 946       fPtAllminPtTPCvsPtAllNPointITS->Fill(pt,(1./pt-1./ptTPC)/(1./pt),nPointITS);
 947       fPtAllminPtTPCvsPtAllNSigmaToVertex->Fill(pt,(1./pt-1./ptTPC)/(1./pt),nSigmaToVertex);
 948       fPtAllminPtTPCvsPtAllChi2C->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2C);
 949       fPtAllminPtTPCvsPtAllRel1PtUncertainty->Fill(pt,(1./pt-1./ptTPC)/(1./pt),relUncertainty1Pt);
 950       fPtAllminPtTPCvsPtAllChi2PerNClusTPC->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2PerClusterTPC);
 951       if(nPointITS>3) fPtAllminPtTPCvsPtAllChi2PerNClusITS->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2PerNPointITS);
 952       fPtAllminPtTPCvsNPointTPCPhi->Fill((1./pt-1./ptTPC)/(1./pt),nClustersTPC,phi);
 953       fPtAllminPtTPCvsNPointITSPhi->Fill((1./pt-1./ptTPC)/(1./pt),nPointITS,phi);
 954       fPtAllminPtTPCvsRel1PtUncertaintyPhi->Fill((1./pt-1./ptTPC)/(1./pt),relUncertainty1Pt,phi);
 955
 956       if(TMath::Abs((1./pt-1./ptTPC)/(1./pt))>0.8) fEtaPhiOutliers->Fill(track->Eta(),phi);
 957
 958       if (constfriendtrack) {
 959         AliESDfriendTrack friendtrack(*constfriendtrack);
 960         if (friendtrack.GetITSOut()) {
 961           AliExternalTrackParam trackITSouter(*(friendtrack.GetITSOut()));
 962           Float_t ptITSouter = trackITSouter.Pt();
 963           if(ptITSouter==0.) continue;
 964           fPtSelITSouter->Fill(ptITSouter);
 965           fPtITSouterminPtTPCvsPtAll->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter) );
 966
 967           if(trackITSouter.GetSign()>0.) fPtITSouterminPtTPCvsPtAllEtaPos->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),trackITSouter.Eta());
 968           if(trackITSouter.GetSign()<0.) fPtITSouterminPtTPCvsPtAllEtaNeg->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),trackITSouter.Eta());
 969
 970           fPtITSouterminPtTPCvsPtAllNPointTPC->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),nClustersTPC);
 971           fPtITSouterminPtTPCvsPtAllDCAR->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),dca2D);
 972           fPtITSouterminPtTPCvsPtAllDCAZ->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),dcaZ);
 973           fPtITSouterminPtTPCvsPtAllPhi->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),phi);
 974           fPtITSouterminPtTPCvsPtAllNPointITS->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),nPointITS);
 975           fPtITSouterminPtTPCvsPtAllNSigmaToVertex->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),nSigmaToVertex);
 976           fPtITSouterminPtTPCvsPtAllChi2C->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2C);
 977           fPtITSouterminPtTPCvsPtAllRel1PtUncertainty->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),relUncertainty1Pt);
 978           fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerClusterTPC);
 979           if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
 980           if(track->HasPointOnITSLayer(0)) {
 981             fPtITSouterminPtTPCvsPtAllITSLayer0->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 982             if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer0->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
 983           }
 984           if(!track->HasPointOnITSLayer(0) && track->HasPointOnITSLayer(1)) {
 985             fPtITSouterminPtTPCvsPtAllITSLayer1->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 986             if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer1->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
 987           }
 988           if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1) && track->HasPointOnITSLayer(2)) {
 989             fPtITSouterminPtTPCvsPtAllITSLayer2->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 990             if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer2->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
 991           }
 992           if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1) && !track->HasPointOnITSLayer(2) && track->HasPointOnITSLayer(3)) {
 993             fPtITSouterminPtTPCvsPtAllITSLayer3->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 994             if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer3->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
 995           }
 996           if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1) && !track->HasPointOnITSLayer(2) && !track->HasPointOnITSLayer(3) && track->HasPointOnITSLayer(4)) {
 997             fPtITSouterminPtTPCvsPtAllITSLayer4->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 998             if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer4->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
 999           }
1000           if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1) && !track->HasPointOnITSLayer(2) && !track->HasPointOnITSLayer(3) && !track->HasPointOnITSLayer(4) && track->HasPointOnITSLayer(5)) {
1001             fPtITSouterminPtTPCvsPtAllITSLayer5->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
1002             if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITSLayer5->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
1003           }
1004
1005           if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1)) {
1006             fPtITSouterminPtTPCvsPtAllNoSPD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
1007             if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSPD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
1008           }
1009           if(!track->HasPointOnITSLayer(2) && !track->HasPointOnITSLayer(3)) {
1010             fPtITSouterminPtTPCvsPtAllNoSDD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
1011             if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSDD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
1012           }
1013           if(!track->HasPointOnITSLayer(4) && !track->HasPointOnITSLayer(5)) {
1014             fPtITSouterminPtTPCvsPtAllNoSSD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
1015             if(nPointITS>3) fPtITSouterminPtTPCvsPtAllChi2PerNClusITSNoSSD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerNPointITS);
1016           }
1017         }
1018       }
1019     }//fTrackCuts selection
1020
1021
1022     //ITSrefit selection
1023     if (fTrackCutsITS->AcceptTrack(track)) {
1024
1025       fPtSelITS->Fill(pt);
1026       fPtSelTPCITS->Fill(ptTPC);
1027       fPtITSminPtTPCvsPtITS->Fill(pt,(1./pt-1./ptTPC)/(1./pt) );
1028       if(track->GetSign()>0.) fPtITSminPtTPCvsPtITSEtaPos->Fill(pt,(1./pt-1./ptTPC)/(1./pt),track->Eta());
1029       if(track->GetSign()<0.) fPtITSminPtTPCvsPtITSEtaNeg->Fill(pt,(1./pt-1./ptTPC)/(1./pt),track->Eta());
1030       fPtITSminPtTPCvsPtITSNPointTPC->Fill(pt,(1./pt-1./ptTPC)/(1./pt),nClustersTPC);
1031       fPtITSminPtTPCvsPtITSDCAR->Fill(pt,(1./pt-1./ptTPC)/(1./pt),dca2D);
1032       fPtITSminPtTPCvsPtITSDCAZ->Fill(pt,(1./pt-1./ptTPC)/(1./pt),dcaZ);
1033       fPtITSminPtTPCvsPtITSPhi->Fill(pt,(1./pt-1./ptTPC)/(1./pt),phi);
1034       fPtITSminPtTPCvsPtITSNPointITS->Fill(pt,(1./pt-1./ptTPC)/(1./pt),nPointITS);
1035       fPtITSminPtTPCvsPtITSNSigmaToVertex->Fill(pt,(1./pt-1./ptTPC)/(1./pt),nSigmaToVertex);
1036       fPtITSminPtTPCvsPtITSChi2C->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2C);
1037       fPtITSminPtTPCvsPtITSRel1PtUncertainty->Fill(pt,(1./pt-1./ptTPC)/(1./pt),relUncertainty1Pt);
1038       fPtITSminPtTPCvsPtITSChi2PerNClusTPC->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2PerClusterTPC);
1039       if(nPointITS>3) fPtITSminPtTPCvsPtITSChi2PerNClusITS->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2PerNPointITS);
1040       fPtITSminPtTPCvsNPointTPCPhi->Fill((1./pt-1./ptTPC)/(1./pt),nClustersTPC,phi);
1041       fPtITSminPtTPCvsNPointITSPhi->Fill((1./pt-1./ptTPC)/(1./pt),nPointITS,phi);
1042       fPtITSminPtTPCvsRel1PtUncertaintyPhi->Fill((1./pt-1./ptTPC)/(1./pt),relUncertainty1Pt,phi);
1043
1044       fPtRel1PtUncertaintyChi2PerClusTPC->Fill(pt,relUncertainty1Pt,chi2PerClusterTPC);
1045     }//fTrackCutsITS loop
1046
1047   }//ESD track loop
1048
1049   // Post output data
1050   PostData(0, fHistList);
1051   PostData(1, fHistListTPC);
1052   PostData(2, fHistListITS);
1053
1054 }
1055
1056 //________________________________________________________________________
1057 void AliPWG4HighPtQATPConly::Terminate(Option_t *)
1058 {
1059   //
1060   // Terminate
1061   //
1062
1063 }
1064
1065 #endif