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