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