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   fTrackCuts(0),
  66   fTrackCutsITS(0),
  67   fTrigger(0),
  68   fNEventAll(0),
  69   fNEventSel(0),
  70   fPtAll(0),
  71   fPtSel(0),
  72   fPtAllminPtTPCvsPtAll(0),
  73   fPtAllminPtTPCvsPtAllNPointTPC(0),
  74   fPtAllminPtTPCvsPtAllDCAR(0),
  75   fPtAllminPtTPCvsPtAllDCAZ(0),
  76   fPtAllminPtTPCvsPtAllPhi(0),
  77   fPtAllminPtTPCvsPtAllNPointITS(0),
  78   fPtAllminPtTPCvsPtAllNSigmaToVertex(0),
  79   fPtAllminPtTPCvsPtAllChi2C(0),
  80   fPtAllminPtTPCvsPtAllRel1PtUncertainty(0),
  81   fPtAllminPtTPCvsPtAllChi2PerNClusTPC(0),
  82   fPtAllminPtTPCvsPtAllChi2PerNClusITS(0),
  83   fEtaPhiOutliers(0),
  84   fPtSelITSouter(0),
  85   fPtITSouterminPtTPCvsPtAll(0),
  86   fPtITSouterminPtTPCvsPtAllNPointTPC(0),
  87   fPtITSouterminPtTPCvsPtAllDCAR(0),
  88   fPtITSouterminPtTPCvsPtAllDCAZ(0),
  89   fPtITSouterminPtTPCvsPtAllPhi(0),
  90   fPtITSouterminPtTPCvsPtAllNPointITS(0),
  91   fPtITSouterminPtTPCvsPtAllNSigmaToVertex(0),
  92   fPtITSouterminPtTPCvsPtAllChi2C(0),
  93   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty(0),
  94   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC(0),
  95   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS(0),
  96   fPtITSouterminPtTPCvsPtAll_ITSLayer0(0),
  97   fPtITSouterminPtTPCvsPtAll_ITSLayer1(0),
  98   fPtITSouterminPtTPCvsPtAll_ITSLayer2(0),
  99   fPtITSouterminPtTPCvsPtAll_ITSLayer3(0),
 100   fPtITSouterminPtTPCvsPtAll_ITSLayer4(0),
 101   fPtITSouterminPtTPCvsPtAll_ITSLayer5(0),
 102   fPtITSouterminPtTPCvsPtAll_NoSPD(0),
 103   fPtITSouterminPtTPCvsPtAll_NoSDD(0),
 104   fPtITSouterminPtTPCvsPtAll_NoSSD(0),
 105   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0(0),
 106   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1(0),
 107   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2(0),
 108   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3(0),
 109   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4(0),
 110   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5(0),
 111   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSPD(0),
 112   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSDD(0),
 113   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSSD(0),
 114   fHistList(0),
 115   fPtAllTPC(0),
 116   fPtSelTPC(0),
 117   fPtSelTPCITS(0),
 118   fHistListTPC(0),
 119   fPtSelITS(0),
 120   fPtITSminPtTPCvsPtITS(0),
 121   fPtITSminPtTPCvsPtITSNPointTPC(0),
 122   fPtITSminPtTPCvsPtITSDCAR(0),
 123   fPtITSminPtTPCvsPtITSDCAZ(0),
 124   fPtITSminPtTPCvsPtITSPhi(0),
 125   fPtITSminPtTPCvsPtITSNPointITS(0),
 126   fPtITSminPtTPCvsPtITSNSigmaToVertex(0),
 127   fPtITSminPtTPCvsPtITSChi2C(0),
 128   fPtITSminPtTPCvsPtITSRel1PtUncertainty(0),
 129   fPtITSminPtTPCvsPtITSChi2PerNClusTPC(0),
 130   fPtITSminPtTPCvsPtITSChi2PerNClusITS(0),
 131   fPtOuterPtInner(0),
 132   fPtRel1PtUncertaintyChi2PerClusTPC(0),
 133   fHistListITS(0)
 134 {
 135
 136 }
 137 //________________________________________________________________________
 138 AliPWG4HighPtQATPConly::AliPWG4HighPtQATPConly(const char *name):
 139   AliAnalysisTask(name, ""),
 140   fESD(0),
 141   fESDfriend(0),
 142   fMC(0),
 143   fTrackCuts(),
 144   fTrackCutsITS(),
 145   fTrigger(0),
 146   fNEventAll(0),
 147   fNEventSel(0),
 148   fPtAll(0),
 149   fPtSel(0),
 150   fPtAllminPtTPCvsPtAll(0),
 151   fPtAllminPtTPCvsPtAllNPointTPC(0),
 152   fPtAllminPtTPCvsPtAllDCAR(0),
 153   fPtAllminPtTPCvsPtAllDCAZ(0),
 154   fPtAllminPtTPCvsPtAllPhi(0),
 155   fPtAllminPtTPCvsPtAllNPointITS(0),
 156   fPtAllminPtTPCvsPtAllNSigmaToVertex(0),
 157   fPtAllminPtTPCvsPtAllChi2C(0),
 158   fPtAllminPtTPCvsPtAllRel1PtUncertainty(0),
 159   fPtAllminPtTPCvsPtAllChi2PerNClusTPC(0),
 160   fPtAllminPtTPCvsPtAllChi2PerNClusITS(0),
 161   fEtaPhiOutliers(0),
 162   fPtSelITSouter(0),
 163   fPtITSouterminPtTPCvsPtAll(0),
 164   fPtITSouterminPtTPCvsPtAllNPointTPC(0),
 165   fPtITSouterminPtTPCvsPtAllDCAR(0),
 166   fPtITSouterminPtTPCvsPtAllDCAZ(0),
 167   fPtITSouterminPtTPCvsPtAllPhi(0),
 168   fPtITSouterminPtTPCvsPtAllNPointITS(0),
 169   fPtITSouterminPtTPCvsPtAllNSigmaToVertex(0),
 170   fPtITSouterminPtTPCvsPtAllChi2C(0),
 171   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty(0),
 172   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC(0),
 173   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS(0),
 174   fPtITSouterminPtTPCvsPtAll_ITSLayer0(0),
 175   fPtITSouterminPtTPCvsPtAll_ITSLayer1(0),
 176   fPtITSouterminPtTPCvsPtAll_ITSLayer2(0),
 177   fPtITSouterminPtTPCvsPtAll_ITSLayer3(0),
 178   fPtITSouterminPtTPCvsPtAll_ITSLayer4(0),
 179   fPtITSouterminPtTPCvsPtAll_ITSLayer5(0),
 180   fPtITSouterminPtTPCvsPtAll_NoSPD(0),
 181   fPtITSouterminPtTPCvsPtAll_NoSDD(0),
 182   fPtITSouterminPtTPCvsPtAll_NoSSD(0),
 183   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0(0),
 184   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1(0),
 185   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2(0),
 186   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3(0),
 187   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4(0),
 188   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5(0),
 189   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSPD(0),
 190   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSDD(0),
 191   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSSD(0),
 192   fHistList(0),
 193   fPtAllTPC(0),
 194   fPtSelTPC(0),
 195   fPtSelTPCITS(0),
 196   fHistListTPC(0),
 197   fPtSelITS(0),
 198   fPtITSminPtTPCvsPtITS(0),
 199   fPtITSminPtTPCvsPtITSNPointTPC(0),
 200   fPtITSminPtTPCvsPtITSDCAR(0),
 201   fPtITSminPtTPCvsPtITSDCAZ(0),
 202   fPtITSminPtTPCvsPtITSPhi(0),
 203   fPtITSminPtTPCvsPtITSNPointITS(0),
 204   fPtITSminPtTPCvsPtITSNSigmaToVertex(0),
 205   fPtITSminPtTPCvsPtITSChi2C(0),
 206   fPtITSminPtTPCvsPtITSRel1PtUncertainty(0),
 207   fPtITSminPtTPCvsPtITSChi2PerNClusTPC(0),
 208   fPtITSminPtTPCvsPtITSChi2PerNClusITS(0),
 209   fPtOuterPtInner(0),
 210   fPtRel1PtUncertaintyChi2PerClusTPC(0),
 211   fHistListITS(0)
 212 {
 213   //
 214   // Constructor. Initialization of Inputs and Outputs
 215   //
 216   Info("AliPWG4HighPtQATPConly","Calling Constructor");
 217   // Input slot #0 works with a TChain ESD
 218   DefineInput(0, TChain::Class());
 219   // Output slot #0 writes into a TList
 220   DefineOutput(0, TList::Class());
 221   // Output slot #1 writes into a TList
 222   DefineOutput(1, TList::Class());
 223   // Output slot #2 writes into a TList
 224   DefineOutput(2, TList::Class());
 225 }
 226
 227 //________________________________________________________________________
 228 void AliPWG4HighPtQATPConly::ConnectInputData(Option_t *)
 229 {
 230   // Connect ESD here
 231   // Called once
 232   AliDebug(2,Form(">> AliPWG4HighPtSpectra::ConnectInputData \n"));
 233   TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
 234   if (!tree) {
 235     AliDebug(2,Form( "ERROR: Could not read chain from input slot 0 \n"));
 236     return;
 237   }
 238
 239   AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 240
 241   if (!esdH) {
 242     AliDebug(2,Form("ERROR: Could not get ESDInputHandler"));
 243     return;
 244   } else
 245     fESD = esdH->GetEvent();
 246
 247  AliMCEventHandler *eventHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
 248  // AliMCEventHandler* mcH = dynamic_cast<AliMCEventHandler*>
 249  //                        (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
 250   if (!eventHandler) {
 251     AliDebug(2,Form( "ERROR: Could not retrieve MC event handler \n"));
 252   }
 253   else
 254     fMC = eventHandler->MCEvent();
 255
 256   //attach the ESD friend
 257    //  tree->SetBranchStatus("*", kTRUE);
 258 //   tree->SetBranchStatus("Tracks*", kTRUE);
 259 //   tree->SetBranchStatus("ESDfriend*", kTRUE);
 260   //  fESD->ReadFromTree(tree);
 261
 262   fESDfriend = (AliESDfriend*)fESD->FindListObject("AliESDfriend");
 263   if (!fESDfriend)
 264     {
 265       // works for both, we just want to avoid setting the branch adress twice
 266       // in case of the new ESD
 267       tree->SetBranchAddress("ESDfriend.",&fESDfriend);
 268     }
 269
 270 }
 271
 272 //________________________________________________________________________
 273 void AliPWG4HighPtQATPConly::CreateOutputObjects() {
 274   //Create output objects
 275   AliDebug(2,Form(">> AliPWG4HighPtQATPConly::CreateOutputObjects \n"));
 276
 277   Bool_t oldStatus = TH1::AddDirectoryStatus();
 278   TH1::AddDirectory(kFALSE);
 279
 280   OpenFile(0);
 281   fHistList = new TList();
 282   OpenFile(1);
 283   fHistListTPC = new TList();
 284   OpenFile(2);
 285   fHistListITS = new TList();
 286
 287   Int_t fgkNPhiBins=18;
 288   Float_t kMinPhi = 0.;
 289   Float_t kMaxPhi = 2.*TMath::Pi();
 290
 291   Float_t fgkPtMin=0.;
 292   Float_t fgkPtMax=100.;
 293   Int_t fgkNPtBins=(int)(fgkPtMax-fgkPtMin);
 294
 295   Float_t fgkChi2PerClusMin = 0.;
 296   Float_t fgkChi2PerClusMax = 3.5;
 297   Int_t fgkChi2PerClusBins = (int)(fgkChi2PerClusMax*10.);
 298
 299
 300   Int_t fgkResPtBins=80;
 301
 302   fNEventAll = new TH1F("fNEventAll","NEventAll",1,-0.5,0.5);
 303   fHistList->Add(fNEventAll);
 304   fNEventSel = new TH1F("fNEventSel","NEvent Selected for analysis",1,-0.5,0.5);
 305   fHistList->Add(fNEventSel);
 306   fPtAll = new TH1F("fPtAll","PtAll",fgkNPtBins, fgkPtMin, fgkPtMax);
 307   fHistList->Add(fPtAll);
 308   fPtSel = new TH1F("fPtSel","PtSel",fgkNPtBins, fgkPtMin, fgkPtMax);
 309   fHistList->Add(fPtSel);
 310
 311   fPtAllminPtTPCvsPtAll = new TH2F("fPtAllminPtTPCvsPtAll","PtAllminPtTPCvsPtAll",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 312   fPtAllminPtTPCvsPtAll->SetXTitle("p_{t}^{Global}");
 313   fPtAllminPtTPCvsPtAll->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 314   fHistList->Add(fPtAllminPtTPCvsPtAll);
 315
 316   fPtAllminPtTPCvsPtAllNPointTPC = new TH3F("fPtAllminPtTPCvsPtAllNPointTPC","PtAllminPtTPCvsPtAllNPointTPC",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,160,0.5,160.5);
 317   fPtAllminPtTPCvsPtAllNPointTPC->SetXTitle("p_{t}^{Global}");
 318   fPtAllminPtTPCvsPtAllNPointTPC->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 319   fPtAllminPtTPCvsPtAllNPointTPC->SetZTitle("N_{point,TPC}");
 320   fHistList->Add(fPtAllminPtTPCvsPtAllNPointTPC);
 321
 322   fPtAllminPtTPCvsPtAllDCAR = new TH3F("fPtAllminPtTPCvsPtAllDCAR","PtAllminPtTPCvsPtAllDCAR",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-0.2,0.2);
 323   fPtAllminPtTPCvsPtAllDCAR->SetXTitle("p_{t}^{Global}");
 324   fPtAllminPtTPCvsPtAllDCAR->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 325   fPtAllminPtTPCvsPtAllDCAR->SetZTitle("DCA_{R}");
 326   fHistList->Add(fPtAllminPtTPCvsPtAllDCAR);
 327
 328   fPtAllminPtTPCvsPtAllDCAZ = new TH3F("fPtAllminPtTPCvsPtAllDCAZ","PtAllminPtTPCvsPtAllDCAZ",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-2.,2.);
 329   fPtAllminPtTPCvsPtAllDCAZ->SetXTitle("p_{t}^{Global}");
 330   fPtAllminPtTPCvsPtAllDCAZ->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 331   fPtAllminPtTPCvsPtAllDCAZ->SetZTitle("DCA_{Z}");
 332   fHistList->Add(fPtAllminPtTPCvsPtAllDCAZ);
 333
 334   fPtAllminPtTPCvsPtAllPhi = new TH3F("fPtAllminPtTPCvsPtAllPhi","PtAllminPtTPCvsPtAllPhi",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkNPhiBins,kMinPhi,kMaxPhi);
 335   fPtAllminPtTPCvsPtAllPhi->SetXTitle("p_{t}^{Global}");
 336   fPtAllminPtTPCvsPtAllPhi->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 337   fPtAllminPtTPCvsPtAllPhi->SetZTitle("#phi");
 338   fHistList->Add(fPtAllminPtTPCvsPtAllPhi);
 339
 340   fPtAllminPtTPCvsPtAllNPointITS = new TH3F("fPtAllminPtTPCvsPtAllNPointITS","PtAllminPtTPCvsPtAllNPointITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,9,-0.5,8.5);
 341   fPtAllminPtTPCvsPtAllNPointITS->SetXTitle("p_{t}^{Global}");
 342   fPtAllminPtTPCvsPtAllNPointITS->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 343   fPtAllminPtTPCvsPtAllNPointITS->SetZTitle("N_{point,ITS}");
 344   fHistList->Add(fPtAllminPtTPCvsPtAllNPointITS);
 345
 346   fPtAllminPtTPCvsPtAllNSigmaToVertex = new TH3F("fPtAllminPtTPCvsPtAllNSigmaToVertex","PtAllminPtTPCvsPtAllNSigmaToVertex",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,40,0.,8.);
 347   fPtAllminPtTPCvsPtAllNSigmaToVertex->SetXTitle("p_{t}^{Global}");
 348   fPtAllminPtTPCvsPtAllNSigmaToVertex->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 349   fPtAllminPtTPCvsPtAllNSigmaToVertex->SetZTitle("N#sigma to vertex");
 350   fHistList->Add(fPtAllminPtTPCvsPtAllNSigmaToVertex);
 351
 352   fPtAllminPtTPCvsPtAllChi2C = new TH3F("fPtAllminPtTPCvsPtAllChi2C","PtAllminPtTPCvsPtAllChi2C",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,20,0.,10.);
 353   fPtAllminPtTPCvsPtAllChi2C->SetXTitle("p_{t}^{Global}");
 354   fPtAllminPtTPCvsPtAllChi2C->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 355   fPtAllminPtTPCvsPtAllChi2C->SetZTitle("Constrained #chi^{2}");
 356   fHistList->Add(fPtAllminPtTPCvsPtAllChi2C);
 357
 358   fPtAllminPtTPCvsPtAllRel1PtUncertainty = new TH3F("fPtAllminPtTPCvsPtAllRel1PtUncertainty","PtAllminPtTPCvsPtAllRel1PtUncertainty",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,30,0.,0.3);
 359   fPtAllminPtTPCvsPtAllRel1PtUncertainty->SetXTitle("p_{t}^{Global}");
 360   fPtAllminPtTPCvsPtAllRel1PtUncertainty->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 361   fPtAllminPtTPCvsPtAllRel1PtUncertainty->SetZTitle("Rel1PtUncertainty");
 362   fHistList->Add(fPtAllminPtTPCvsPtAllRel1PtUncertainty);
 363
 364   fPtAllminPtTPCvsPtAllChi2PerNClusTPC = new TH3F("fPtAllminPtTPCvsPtAllChi2PerNClusTPC","PtAllminPtTPCvsPtAllChi2PerNClusTPC",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 365   fPtAllminPtTPCvsPtAllChi2PerNClusTPC->SetXTitle("p_{t}^{Global}");
 366   fPtAllminPtTPCvsPtAllChi2PerNClusTPC->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 367   fPtAllminPtTPCvsPtAllChi2PerNClusTPC->SetZTitle("#chi^{2}/NClusTPC");
 368   fHistList->Add(fPtAllminPtTPCvsPtAllChi2PerNClusTPC);
 369
 370   fPtAllminPtTPCvsPtAllChi2PerNClusITS = new TH3F("fPtAllminPtTPCvsPtAllChi2PerNClusITS","PtAllminPtTPCvsPtAllChi2PerNClusITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 371   fPtAllminPtTPCvsPtAllChi2PerNClusITS->SetXTitle("p_{t}^{Global}");
 372   fPtAllminPtTPCvsPtAllChi2PerNClusITS->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 373   fPtAllminPtTPCvsPtAllChi2PerNClusITS->SetZTitle("#chi^{2}/NClusITS");
 374   fHistList->Add(fPtAllminPtTPCvsPtAllChi2PerNClusITS);
 375
 376   fEtaPhiOutliers = new TH2F("fEtaPhiOutliers","PtAllminPtTPCvsPtAll",20, -1.,1.,fgkNPhiBins,kMinPhi,kMaxPhi);
 377   fEtaPhiOutliers->SetXTitle("#eta");
 378   fEtaPhiOutliers->SetYTitle("#phi");
 379   fHistList->Add(fEtaPhiOutliers);
 380
 381   //Global vs ITSouter-TPCinner
 382   fPtSelITSouter = new TH1F("fPtSelITSouter","PtSelITSouter",fgkNPtBins,fgkPtMin,fgkPtMax);
 383   fHistList->Add(fPtSelITSouter);
 384
 385   fPtITSouterminPtTPCvsPtAll = new TH2F("fPtITSouterminPtTPCvsPtAll","PtAllminPtTPCvsPtAll",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 386   fPtITSouterminPtTPCvsPtAll->SetXTitle("p_{t}^{Global}");
 387   fPtITSouterminPtTPCvsPtAll->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 388   fHistList->Add(fPtITSouterminPtTPCvsPtAll);
 389
 390   fPtITSouterminPtTPCvsPtAllNPointTPC = new TH3F("fPtITSouterminPtTPCvsPtAllNPointTPC","PtAllminPtTPCvsPtAllNPointTPC",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,160,0.5,160.5);
 391   fPtITSouterminPtTPCvsPtAllNPointTPC->SetXTitle("p_{t}^{Global}");
 392   fPtITSouterminPtTPCvsPtAllNPointTPC->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 393   fPtITSouterminPtTPCvsPtAllNPointTPC->SetZTitle("N_{point,TPC}");
 394   fHistList->Add(fPtITSouterminPtTPCvsPtAllNPointTPC);
 395
 396   fPtITSouterminPtTPCvsPtAllDCAR = new TH3F("fPtITSouterminPtTPCvsPtAllDCAR","PtAllminPtTPCvsPtAllDCAR",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-0.2,0.2);
 397   fPtITSouterminPtTPCvsPtAllDCAR->SetXTitle("p_{t}^{Global}");
 398   fPtITSouterminPtTPCvsPtAllDCAR->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 399   fPtITSouterminPtTPCvsPtAllDCAR->SetZTitle("DCA_{R}");
 400   fHistList->Add(fPtITSouterminPtTPCvsPtAllDCAR);
 401
 402   fPtITSouterminPtTPCvsPtAllDCAZ = new TH3F("fPtITSouterminPtTPCvsPtAllDCAZ","PtAllminPtTPCvsPtAllDCAZ",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-2.,2.);
 403   fPtITSouterminPtTPCvsPtAllDCAZ->SetXTitle("p_{t}^{Global}");
 404   fPtITSouterminPtTPCvsPtAllDCAZ->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 405   fPtITSouterminPtTPCvsPtAllDCAZ->SetZTitle("DCA_{Z}");
 406   fHistList->Add(fPtITSouterminPtTPCvsPtAllDCAZ);
 407
 408   fPtITSouterminPtTPCvsPtAllPhi = new TH3F("fPtITSouterminPtTPCvsPtAllPhi","PtAllminPtTPCvsPtAllPhi",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkNPhiBins,kMinPhi,kMaxPhi);
 409   fPtITSouterminPtTPCvsPtAllPhi->SetXTitle("p_{t}^{Global}");
 410   fPtITSouterminPtTPCvsPtAllPhi->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 411   fPtITSouterminPtTPCvsPtAllPhi->SetZTitle("#phi");
 412   fHistList->Add(fPtITSouterminPtTPCvsPtAllPhi);
 413
 414   fPtITSouterminPtTPCvsPtAllNPointITS = new TH3F("fPtITSouterminPtTPCvsPtAllNPointITS","PtAllminPtTPCvsPtAllNPointITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,9,-0.5,8.5);
 415   fPtITSouterminPtTPCvsPtAllNPointITS->SetXTitle("p_{t}^{Global}");
 416   fPtITSouterminPtTPCvsPtAllNPointITS->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 417   fPtITSouterminPtTPCvsPtAllNPointITS->SetZTitle("N_{point,ITS}");
 418   fHistList->Add(fPtITSouterminPtTPCvsPtAllNPointITS);
 419
 420   fPtITSouterminPtTPCvsPtAllNSigmaToVertex = new TH3F("fPtITSouterminPtTPCvsPtAllNSigmaToVertex","PtAllminPtTPCvsPtAllNSigmaToVertex",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,40,0.,8.);
 421   fPtITSouterminPtTPCvsPtAllNSigmaToVertex->SetXTitle("p_{t}^{Global}");
 422   fPtITSouterminPtTPCvsPtAllNSigmaToVertex->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 423   fPtITSouterminPtTPCvsPtAllNSigmaToVertex->SetZTitle("N#sigma to vertex");
 424   fHistList->Add(fPtITSouterminPtTPCvsPtAllNSigmaToVertex);
 425
 426   fPtITSouterminPtTPCvsPtAllChi2C = new TH3F("fPtITSouterminPtTPCvsPtAllChi2C","PtAllminPtTPCvsPtAllChi2C",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,20,0.,10.);
 427   fPtITSouterminPtTPCvsPtAllChi2C->SetXTitle("p_{t}^{Global}");
 428   fPtITSouterminPtTPCvsPtAllChi2C->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 429   fPtITSouterminPtTPCvsPtAllChi2C->SetZTitle("Constrained #chi^{2}");
 430   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2C);
 431
 432   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty = new TH3F("fPtITSouterminPtTPCvsPtAllRel1PtUncertainty","PtAllminPtTPCvsPtAllRel1PtUncertainty",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,30,0.,0.3);
 433   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty->SetXTitle("p_{t}^{Global}");
 434   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 435   fPtITSouterminPtTPCvsPtAllRel1PtUncertainty->SetZTitle("Rel1PtUncertainty");
 436   fHistList->Add(fPtITSouterminPtTPCvsPtAllRel1PtUncertainty);
 437
 438   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC","PtAllminPtTPCvsPtAllChi2PerNClusTPC",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,35,0.,3.5);
 439   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC->SetXTitle("p_{t}^{Global}");
 440   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 441   fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC->SetZTitle("#chi^{2}/NClusTPC");
 442   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC);
 443
 444   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS","PtAllminPtTPCvsPtAllChi2PerNClusITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,35,0.,3.5);
 445   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS->SetXTitle("p_{t}^{Global}");
 446   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS->SetYTitle("(1/p_{t}^{Global}-1/p_{t}^{TPC})/(1/p_{t}^{Global})");
 447   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS->SetZTitle("#chi^{2}/NClusITS");
 448   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS);
 449
 450   //As function of ITS layers
 451   fPtITSouterminPtTPCvsPtAll_ITSLayer0 = new TH2F("fPtITSouterminPtTPCvsPtAll_ITSLayer0","PtAllminPtTPCvsPtAll_ITSLayer0",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 452   fPtITSouterminPtTPCvsPtAll_ITSLayer0->SetXTitle("p_{t}^{Global}");
 453   fPtITSouterminPtTPCvsPtAll_ITSLayer0->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 454   fHistList->Add(fPtITSouterminPtTPCvsPtAll_ITSLayer0);
 455
 456   fPtITSouterminPtTPCvsPtAll_ITSLayer1 = new TH2F("fPtITSouterminPtTPCvsPtAll_ITSLayer1","PtAllminPtTPCvsPtAll_ITSLayer1",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 457   fPtITSouterminPtTPCvsPtAll_ITSLayer1->SetXTitle("p_{t}^{Global}");
 458   fPtITSouterminPtTPCvsPtAll_ITSLayer1->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 459   fHistList->Add(fPtITSouterminPtTPCvsPtAll_ITSLayer1);
 460
 461   fPtITSouterminPtTPCvsPtAll_ITSLayer2 = new TH2F("fPtITSouterminPtTPCvsPtAll_ITSLayer2","PtAllminPtTPCvsPtAll_ITSLayer2",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 462   fPtITSouterminPtTPCvsPtAll_ITSLayer2->SetXTitle("p_{t}^{Global}");
 463   fPtITSouterminPtTPCvsPtAll_ITSLayer2->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 464   fHistList->Add(fPtITSouterminPtTPCvsPtAll_ITSLayer2);
 465
 466   fPtITSouterminPtTPCvsPtAll_ITSLayer3 = new TH2F("fPtITSouterminPtTPCvsPtAll_ITSLayer3","PtAllminPtTPCvsPtAll_ITSLayer3",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 467   fPtITSouterminPtTPCvsPtAll_ITSLayer3->SetXTitle("p_{t}^{Global}");
 468   fPtITSouterminPtTPCvsPtAll_ITSLayer3->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 469   fHistList->Add(fPtITSouterminPtTPCvsPtAll_ITSLayer3);
 470
 471   fPtITSouterminPtTPCvsPtAll_ITSLayer4 = new TH2F("fPtITSouterminPtTPCvsPtAll_ITSLayer4","PtAllminPtTPCvsPtAll_ITSLayer4",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 472   fPtITSouterminPtTPCvsPtAll_ITSLayer4->SetXTitle("p_{t}^{Global}");
 473   fPtITSouterminPtTPCvsPtAll_ITSLayer4->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 474   fHistList->Add(fPtITSouterminPtTPCvsPtAll_ITSLayer4);
 475
 476   fPtITSouterminPtTPCvsPtAll_ITSLayer5 = new TH2F("fPtITSouterminPtTPCvsPtAll_ITSLayer5","PtAllminPtTPCvsPtAll_ITSLayer5",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 477   fPtITSouterminPtTPCvsPtAll_ITSLayer5->SetXTitle("p_{t}^{Global}");
 478   fPtITSouterminPtTPCvsPtAll_ITSLayer5->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 479   fHistList->Add(fPtITSouterminPtTPCvsPtAll_ITSLayer5);
 480
 481   fPtITSouterminPtTPCvsPtAll_NoSPD = new TH2F("fPtITSouterminPtTPCvsPtAll_NoSPD","PtAllminPtTPCvsPtAll_NoSPD",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 482   fPtITSouterminPtTPCvsPtAll_NoSPD->SetXTitle("p_{t}^{Global}");
 483   fPtITSouterminPtTPCvsPtAll_NoSPD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 484   fHistList->Add(fPtITSouterminPtTPCvsPtAll_NoSPD);
 485
 486   fPtITSouterminPtTPCvsPtAll_NoSDD = new TH2F("fPtITSouterminPtTPCvsPtAll_NoSDD","PtAllminPtTPCvsPtAll_NoSDD",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 487   fPtITSouterminPtTPCvsPtAll_NoSDD->SetXTitle("p_{t}^{Global}");
 488   fPtITSouterminPtTPCvsPtAll_NoSDD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 489   fHistList->Add(fPtITSouterminPtTPCvsPtAll_NoSDD);
 490
 491   fPtITSouterminPtTPCvsPtAll_NoSSD = new TH2F("fPtITSouterminPtTPCvsPtAll_NoSSD","PtAllminPtTPCvsPtAll_NoSSD",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 492   fPtITSouterminPtTPCvsPtAll_NoSSD->SetXTitle("p_{t}^{Global}");
 493   fPtITSouterminPtTPCvsPtAll_NoSSD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 494   fHistList->Add(fPtITSouterminPtTPCvsPtAll_NoSSD);
 495
 496   //
 497   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0","PtAllminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 498   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0->SetXTitle("p_{t}^{Global}");
 499   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 500   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0->SetZTitle("#chi^{2}/NPointITS");
 501   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0);
 502
 503   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1","PtAllminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 504   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1->SetXTitle("p_{t}^{Global}");
 505   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 506   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1->SetZTitle("#chi^{2}/NPointITS");
 507   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1);
 508
 509   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2","PtAllminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 510   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2->SetXTitle("p_{t}^{Global}");
 511   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 512   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2->SetZTitle("#chi^{2}/NPointITS");
 513   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2);
 514
 515   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3","PtAllminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 516   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3->SetXTitle("p_{t}^{Global}");
 517   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 518   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3->SetZTitle("#chi^{2}/NPointITS");
 519   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3);
 520
 521   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4","PtAllminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 522   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4->SetXTitle("p_{t}^{Global}");
 523   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 524   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4->SetZTitle("#chi^{2}/NPointITS");
 525   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4);
 526
 527   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5 = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5","PtAllminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 528   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5->SetXTitle("p_{t}^{Global}");
 529   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 530   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5->SetZTitle("#chi^{2}/NPointITS");
 531   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5);
 532
 533   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSPD = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSPD","PtAllminPtTPCvsPtAllChi2PerNClusITS_NoSPD",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 534   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSPD->SetXTitle("p_{t}^{Global}");
 535   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSPD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 536   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSPD->SetZTitle("#chi^{2}/NPointITS");
 537   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSPD);
 538
 539   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSDD = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSDD","PtAllminPtTPCvsPtAllChi2PerNClusITS_NoSDD",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 540   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSDD->SetXTitle("p_{t}^{Global}");
 541   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSDD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 542   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSDD->SetZTitle("#chi^{2}/NPointITS");
 543   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSDD);
 544
 545   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSSD = new TH3F("fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSSD","PtAllminPtTPCvsPtAllChi2PerNClusITS_NoSSD",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkChi2PerClusBins,fgkChi2PerClusMin,fgkChi2PerClusMax);
 546   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSSD->SetXTitle("p_{t}^{Global}");
 547   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSSD->SetYTitle("(1/p_{t}^{ITSouter}-1/p_{t}^{TPCinner})/(1/p_{t}^{ITSouter})");
 548   fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSSD->SetZTitle("#chi^{2}/NPointITS");
 549   fHistList->Add(fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSSD);
 550
 551
 552   //ITSrefit
 553   fPtSelITS = new TH1F("fPtSelITSrefit","PtSel",fgkNPtBins, fgkPtMin, fgkPtMax);
 554   fHistListITS->Add(fPtSelITS);
 555
 556   fPtITSminPtTPCvsPtITS = new TH2F("fPtITSminPtTPCvsPtITS","PtITSminPtTPCvsPtITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
 557   fPtITSminPtTPCvsPtITS->SetXTitle("p_{t}^{ITS}");
 558   fPtITSminPtTPCvsPtITS->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{TPC})/(1/p_{t}^{ITS})");
 559   fHistListITS->Add(fPtITSminPtTPCvsPtITS);
 560
 561   fPtITSminPtTPCvsPtITSNPointTPC = new TH3F("fPtITSminPtTPCvsPtITSNPointTPC","PtITSminPtTPCvsPtITSNPointTPC",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,160,0.5,160.5);
 562   fPtITSminPtTPCvsPtITSNPointTPC->SetXTitle("p_{t}^{ITSrefit}");
 563   fPtITSminPtTPCvsPtITSNPointTPC->SetYTitle("(1/p_{t}^{ITSrefit}-1/p_{t}^{TPC})/(1/p_{t}^{ITSrefit})");
 564   fPtITSminPtTPCvsPtITSNPointTPC->SetZTitle("N_{point,TPC}");
 565   fHistListITS->Add(fPtITSminPtTPCvsPtITSNPointTPC);
 566
 567   fPtITSminPtTPCvsPtITSDCAR = new TH3F("fPtITSminPtTPCvsPtITSDCAR","PtITSminPtTPCvsPtITSDCAR",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-0.2,0.2);
 568   fPtITSminPtTPCvsPtITSDCAR->SetXTitle("p_{t}^{ITSrefit}");
 569   fPtITSminPtTPCvsPtITSDCAR->SetYTitle("(1/p_{t}^{ITSrefit}-1/p_{t}^{TPC})/(1/p_{t}^{ITSrefit})");
 570   fPtITSminPtTPCvsPtITSDCAR->SetZTitle("DCA_{R}");
 571   fHistListITS->Add(fPtITSminPtTPCvsPtITSDCAR);
 572
 573   fPtITSminPtTPCvsPtITSDCAZ = new TH3F("fPtITSminPtTPCvsPtITSDCAZ","PtITSminPtTPCvsPtITSDCAZ",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-2.,2.);
 574   fPtITSminPtTPCvsPtITSDCAZ->SetXTitle("p_{t}^{ITSrefit}");
 575   fPtITSminPtTPCvsPtITSDCAZ->SetYTitle("(1/p_{t}^{ITSrefit}-1/p_{t}^{TPC})/(1/p_{t}^{ITSrefit})");
 576   fPtITSminPtTPCvsPtITSDCAZ->SetZTitle("DCA_{Z}");
 577   fHistListITS->Add(fPtITSminPtTPCvsPtITSDCAZ);
 578
 579   fPtITSminPtTPCvsPtITSPhi = new TH3F("fPtITSminPtTPCvsPtITSPhi","PtITSminPtTPCvsPtITSPhi",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkNPhiBins,kMinPhi,kMaxPhi);
 580   fPtITSminPtTPCvsPtITSPhi->SetXTitle("p_{t}^{ITSrefit}");
 581   fPtITSminPtTPCvsPtITSPhi->SetYTitle("(1/p_{t}^{ITSrefit}-1/p_{t}^{TPC})/(1/p_{t}^{ITSrefit})");
 582   fPtITSminPtTPCvsPtITSPhi->SetZTitle("#phi");
 583   fHistListITS->Add(fPtITSminPtTPCvsPtITSPhi);
 584
 585   fPtITSminPtTPCvsPtITSNPointITS = new TH3F("fPtITSminPtTPCvsPtITSNPointITS","PtITSminPtTPCvsPtITSNPointITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,9,-0.5,8.5);
 586   fPtITSminPtTPCvsPtITSNPointITS->SetXTitle("p_{t}^{ITSrefit}");
 587   fPtITSminPtTPCvsPtITSNPointITS->SetYTitle("(1/p_{t}^{ITSrefit}-1/p_{t}^{TPC})/(1/p_{t}^{ITSrefit})");
 588   fPtITSminPtTPCvsPtITSNPointITS->SetZTitle("N_{point,ITS}");
 589   fHistListITS->Add(fPtITSminPtTPCvsPtITSNPointITS);
 590
 591   fPtITSminPtTPCvsPtITSNSigmaToVertex = new TH3F("fPtITSminPtTPCvsPtITSNSigmaToVertex","PtITSminPtTPCvsPtITSNSigmaToVertex",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,40,0.,8.);
 592   fPtITSminPtTPCvsPtITSNSigmaToVertex->SetXTitle("p_{t}^{ITS}");
 593   fPtITSminPtTPCvsPtITSNSigmaToVertex->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{TPC})/(1/p_{t}^{ITS})");
 594   fPtITSminPtTPCvsPtITSNSigmaToVertex->SetZTitle("N#sigma to vertex");
 595   fHistListITS->Add(fPtITSminPtTPCvsPtITSNSigmaToVertex);
 596
 597   fPtITSminPtTPCvsPtITSChi2C = new TH3F("fPtITSminPtTPCvsPtITSChi2C","PtITSminPtTPCvsPtITSChi2C",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,20,0.,10.);
 598   fPtITSminPtTPCvsPtITSChi2C->SetXTitle("p_{t}^{ITS}");
 599   fPtITSminPtTPCvsPtITSChi2C->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{TPC})/(1/p_{t}^{ITS})");
 600   fPtITSminPtTPCvsPtITSChi2C->SetZTitle("Constrained #chi^{2}");
 601   fHistListITS->Add(fPtITSminPtTPCvsPtITSChi2C);
 602
 603   fPtITSminPtTPCvsPtITSRel1PtUncertainty = new TH3F("fPtITSminPtTPCvsPtITSRel1PtUncertainty","PtITSminPtTPCvsPtITSRel1PtUncertainty",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,30,0.,0.3);
 604   fPtITSminPtTPCvsPtITSRel1PtUncertainty->SetXTitle("p_{t}^{ITS}");
 605   fPtITSminPtTPCvsPtITSRel1PtUncertainty->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{TPC})/(1/p_{t}^{ITS})");
 606   fPtITSminPtTPCvsPtITSRel1PtUncertainty->SetZTitle("Rel1PtUncertainty");
 607   fHistListITS->Add(fPtITSminPtTPCvsPtITSRel1PtUncertainty);
 608
 609   fPtITSminPtTPCvsPtITSChi2PerNClusTPC = new TH3F("fPtITSminPtTPCvsPtITSChi2PerNClusTPC","PtITSminPtTPCvsPtITSChi2PerNClusTPC",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,35,0.,3.5);
 610   fPtITSminPtTPCvsPtITSChi2PerNClusTPC->SetXTitle("p_{t}^{ITS}");
 611   fPtITSminPtTPCvsPtITSChi2PerNClusTPC->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{TPC})/(1/p_{t}^{ITS})");
 612   fPtITSminPtTPCvsPtITSChi2PerNClusTPC->SetZTitle("#chi^{2}/NClusTPC");
 613   fHistListITS->Add(fPtITSminPtTPCvsPtITSChi2PerNClusTPC);
 614
 615   fPtITSminPtTPCvsPtITSChi2PerNClusITS = new TH3F("fPtITSminPtTPCvsPtITSChi2PerNClusITS","PtITSminPtTPCvsPtITSChi2PerNClusITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,35,0.,3.5);
 616   fPtITSminPtTPCvsPtITSChi2PerNClusITS->SetXTitle("p_{t}^{ITS}");
 617   fPtITSminPtTPCvsPtITSChi2PerNClusITS->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{TPC})/(1/p_{t}^{ITS})");
 618   fPtITSminPtTPCvsPtITSChi2PerNClusITS->SetZTitle("#chi^{2}/NClusITS");
 619   fHistListITS->Add(fPtITSminPtTPCvsPtITSChi2PerNClusITS);
 620
 621   fPtOuterPtInner = new TH2F("fPtOuterPtInner","fPtOuterPtInner",fgkNPtBins, fgkPtMin,fgkPtMax,fgkNPtBins, fgkPtMin,fgkPtMax);
 622   fPtOuterPtInner->SetXTitle("p_{t}^{inner}");
 623   fPtOuterPtInner->SetYTitle("p_{t}^{outer}");
 624   fHistListITS->Add(fPtOuterPtInner);
 625
 626   fPtRel1PtUncertaintyChi2PerClusTPC = new TH3F("fPtRel1PtUncertaintyChi2PerClusTPC","PtITSminPtTPCvsPtITSRel1PtUncertainty",fgkNPtBins, fgkPtMin,fgkPtMax,30,0.,0.3,35,0.,3.5);
 627   fPtRel1PtUncertaintyChi2PerClusTPC->SetXTitle("p_{t}^{global}");
 628   fPtRel1PtUncertaintyChi2PerClusTPC->SetYTitle("Rel1PtUncertainty");
 629   fPtRel1PtUncertaintyChi2PerClusTPC->SetZTitle("#chi^{2}/N_{clusters}^{TPC}");
 630   fHistListITS->Add(fPtRel1PtUncertaintyChi2PerClusTPC);
 631
 632   fPtAllTPC = new TH1F("fPtAllTPC","PtAll",fgkNPtBins, fgkPtMin, fgkPtMax);
 633   fHistListTPC->Add(fPtAllTPC);
 634   fPtSelTPC = new TH1F("fPtSelTPC","PtSel",fgkNPtBins, fgkPtMin, fgkPtMax);
 635   fHistListTPC->Add(fPtSelTPC);
 636   fPtSelTPCITS = new TH1F("fPtSelTPCITS","PtSel",fgkNPtBins, fgkPtMin, fgkPtMax);
 637   fHistListTPC->Add(fPtSelTPCITS);
 638
 639   TH1::AddDirectory(oldStatus);
 640
 641 }
 642 //________________________________________________________________________
 643 void AliPWG4HighPtQATPConly::Exec(Option_t *) {
 644   // Main loop
 645   // Called for each event
 646   AliDebug(2,Form(">> AliPWG4HighPtQATPConly::Exec \n"));
 647
 648   // All events without selection
 649   fNEventAll->Fill(0.);
 650
 651   if (!fESD) {
 652     AliDebug(2,Form("ERROR: fESD not available"));
 653     // Post output data
 654      PostData(0, fHistList);
 655      PostData(1, fHistListTPC);
 656      PostData(2, fHistListITS);
 657     return;
 658   }
 659
 660   fESD->SetESDfriend(fESDfriend); //Attach the friend to the ESD
 661   if (!fESDfriend) {
 662     AliDebug(2,Form("ERROR: fESDfriend not available"));
 663     // Post output data
 664      PostData(0, fHistList);
 665      PostData(1, fHistListTPC);
 666      PostData(2, fHistListITS);
 667     return;
 668   }
 669
 670   Bool_t isSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
 671   if(!isSelected) { //Select collison candidates
 672     AliDebug(2,Form(" Trigger Selection: event REJECTED ... "));
 673     // Post output data
 674      PostData(0, fHistList);
 675      PostData(1, fHistListTPC);
 676      PostData(2, fHistListITS);
 677     return;
 678   }
 679
 680   //  AliMCEventHandler *eventHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
 681 //   //  AliMCEventHandler* eventHandler = (AliMCEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
 682
 683   AliStack* stack = 0x0;
 684   AliMCEvent* mcEvent = 0x0;
 685
 686   if(fMC) {
 687     mcEvent = fMC;
 688     if (!mcEvent) {
 689       AliDebug(2,Form("ERROR: Could not retrieve MC event"));
 690       PostData(0, fHistList);
 691       PostData(1, fHistListTPC);
 692       PostData(2, fHistListITS);
 693       return;
 694     }
 695
 696     AliDebug(2,Form("MC particles: %d", mcEvent->GetNumberOfTracks()));
 697
 698     stack = mcEvent->Stack();                //Particles Stack
 699
 700     AliDebug(2,Form("MC particles stack: %d", stack->GetNtrack()));
 701   }
 702
 703
 704   const AliESDVertex *vtx = fESD->GetPrimaryVertexTracks();
 705   // Need vertex cut
 706   if (vtx->GetNContributors() < 2) {
 707     // Post output data
 708     PostData(0, fHistList);
 709     PostData(1, fHistListTPC);
 710     PostData(2, fHistListITS);
 711     return;
 712   }
 713
 714   AliDebug(2,Form("Vertex title %s, status %d, nCont %d\n",vtx->GetTitle(), vtx->GetStatus(), vtx->GetNContributors()));
 715   double primVtx[3];
 716   vtx->GetXYZ(primVtx);
 717   //  printf("primVtx: %g  %g  %g \n",primVtx[0],primVtx[1],primVtx[2]);
 718   if(TMath::Sqrt(primVtx[0]*primVtx[0] + primVtx[1]*primVtx[1])>1. || TMath::Abs(primVtx[2]>10.)){
 719     // Post output data
 720     PostData(0, fHistList);
 721     PostData(1, fHistListTPC);
 722     PostData(2, fHistListITS);
 723     return;
 724   }
 725   if(!fESD->GetNumberOfTracks() || fESD->GetNumberOfTracks()<2){
 726     // Post output data
 727     PostData(0, fHistList);
 728     PostData(1, fHistListTPC);
 729     PostData(2, fHistListITS);
 730     return;
 731   }
 732   Int_t nTracks = fESD->GetNumberOfTracks();
 733   AliDebug(2,Form("nTracks %d\n", nTracks));
 734
 735   if(!fTrackCuts) return;
 736
 737   // Selected events for analysis
 738   fNEventSel->Fill(0.);
 739
 740   for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
 741
 742     AliESDtrack *track = fESD->GetTrack(iTrack);
 743     AliExternalTrackParam *trackTPC = (AliExternalTrackParam *)track->GetTPCInnerParam();
 744     if(!track || !trackTPC) continue;
 745     const AliESDfriendTrack* constfriendtrack = track->GetFriendTrack();
 746     if (!constfriendtrack) { continue;}
 747     AliESDfriendTrack friendtrack(*constfriendtrack);
 748
 749     Float_t pt = track->Pt();
 750     Float_t ptTPC = trackTPC->Pt();
 751     Float_t phi = track->Phi();
 752     Float_t dca2D, dcaZ;
 753     track->GetImpactParameters(dca2D,dcaZ);
 754     // Float_t dca2DTPC, dcaZTPC;
 755     //track->GetImpactParametersTPC(dca2DTPC,dcaZTPC);
 756     UChar_t itsMap = track->GetITSClusterMap();
 757     Int_t nPointITS = 0;
 758     for (Int_t i=0; i < 6; i++) {
 759       if (itsMap & (1 << i))
 760         nPointITS ++;
 761     }
 762     double mom[3];
 763     track->GetPxPyPz(mom);
 764     double momTPC[3];
 765     trackTPC->GetPxPyPz(momTPC);
 766     Float_t nSigmaToVertex = fTrackCuts->GetSigmaToVertex(track);// Calculates the number of sigma to the vertex for a track.
 767     Float_t chi2C = track->GetConstrainedChi2();
 768     Float_t relUncertainty1Pt = TMath::Sqrt(TMath::Abs(track->GetSigma1Pt2()))*pt;
 769     Float_t chi2PerClusterTPC = -1.;
 770     Float_t nClustersTPC = track->GetTPCNcls();
 771     if(nClustersTPC!=0.) chi2PerClusterTPC = track->GetTPCchi2()/nClustersTPC;
 772
 773     fPtAll->Fill(pt);
 774     fPtAllTPC->Fill(ptTPC);
 775
 776     if (fTrackCuts->AcceptTrack(track)) {
 777
 778       fPtSel->Fill(pt);
 779       fPtSelTPC->Fill(ptTPC);
 780       if(ptTPC==0. || pt==0.) continue;
 781       fPtAllminPtTPCvsPtAll->Fill(pt,(1./pt-1./ptTPC)/(1./pt) );
 782       fPtAllminPtTPCvsPtAllNPointTPC->Fill(pt,(1./pt-1./ptTPC)/(1./pt),track->GetTPCNcls());
 783       fPtAllminPtTPCvsPtAllDCAR->Fill(pt,(1./pt-1./ptTPC)/(1./pt),dca2D);
 784       fPtAllminPtTPCvsPtAllDCAZ->Fill(pt,(1./pt-1./ptTPC)/(1./pt),dcaZ);
 785       fPtAllminPtTPCvsPtAllPhi->Fill(pt,(1./pt-1./ptTPC)/(1./pt),phi);
 786       fPtAllminPtTPCvsPtAllNPointITS->Fill(pt,(1./pt-1./ptTPC)/(1./pt),nPointITS);
 787       fPtAllminPtTPCvsPtAllNSigmaToVertex->Fill(pt,(1./pt-1./ptTPC)/(1./pt),nSigmaToVertex);
 788       fPtAllminPtTPCvsPtAllChi2C->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2C);
 789       fPtAllminPtTPCvsPtAllRel1PtUncertainty->Fill(pt,(1./pt-1./ptTPC)/(1./pt),relUncertainty1Pt);
 790       fPtAllminPtTPCvsPtAllChi2PerNClusTPC->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2PerClusterTPC);
 791       if(nPointITS>0) fPtAllminPtTPCvsPtAllChi2PerNClusITS->Fill(pt,(1./pt-1./ptTPC)/(1./pt),track->GetITSchi2()/(float)nPointITS);
 792       if(TMath::Abs((1./pt-1./ptTPC)/(1./pt))>0.8) fEtaPhiOutliers->Fill(track->Eta(),phi);
 793       if (friendtrack.GetITSOut()) {
 794         AliExternalTrackParam trackITSouter(*(friendtrack.GetITSOut()));
 795         Float_t ptITSouter = trackITSouter.Pt();
 796         if(ptITSouter==0.) continue;
 797         fPtSelITSouter->Fill(ptITSouter);
 798         fPtITSouterminPtTPCvsPtAll->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter) );
 799         fPtITSouterminPtTPCvsPtAllNPointTPC->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetTPCNcls());
 800         fPtITSouterminPtTPCvsPtAllDCAR->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),dca2D);
 801         fPtITSouterminPtTPCvsPtAllDCAZ->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),dcaZ);
 802         fPtITSouterminPtTPCvsPtAllPhi->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),phi);
 803         fPtITSouterminPtTPCvsPtAllNPointITS->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),nPointITS);
 804         fPtITSouterminPtTPCvsPtAllNSigmaToVertex->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),nSigmaToVertex);
 805         fPtITSouterminPtTPCvsPtAllChi2C->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2C);
 806         fPtITSouterminPtTPCvsPtAllRel1PtUncertainty->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),relUncertainty1Pt);
 807         fPtITSouterminPtTPCvsPtAllChi2PerNClusTPC->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),chi2PerClusterTPC);
 808         if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 809         if(track->HasPointOnITSLayer(0)) {
 810           fPtITSouterminPtTPCvsPtAll_ITSLayer0->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 811           if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer0->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 812         }
 813         if(!track->HasPointOnITSLayer(0) && track->HasPointOnITSLayer(1)) {
 814           fPtITSouterminPtTPCvsPtAll_ITSLayer1->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 815           if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer1->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 816         }
 817         if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1) && track->HasPointOnITSLayer(2)) {
 818           fPtITSouterminPtTPCvsPtAll_ITSLayer2->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 819           if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer2->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 820         }
 821         if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1) && !track->HasPointOnITSLayer(2) && track->HasPointOnITSLayer(3)) {
 822           fPtITSouterminPtTPCvsPtAll_ITSLayer3->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 823           if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer3->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 824         }
 825         if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1) && !track->HasPointOnITSLayer(2) && !track->HasPointOnITSLayer(3) && track->HasPointOnITSLayer(4)) {
 826           fPtITSouterminPtTPCvsPtAll_ITSLayer4->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 827           if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer4->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 828         }
 829         if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1) && !track->HasPointOnITSLayer(2) && !track->HasPointOnITSLayer(3) && !track->HasPointOnITSLayer(4) && track->HasPointOnITSLayer(5)) {
 830           fPtITSouterminPtTPCvsPtAll_ITSLayer5->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 831           if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_ITSLayer5->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 832         }
 833
 834         if(!track->HasPointOnITSLayer(0) && !track->HasPointOnITSLayer(1)) {
 835           fPtITSouterminPtTPCvsPtAll_NoSPD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 836           if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSPD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 837         }
 838         if(!track->HasPointOnITSLayer(2) && !track->HasPointOnITSLayer(3)) {
 839           fPtITSouterminPtTPCvsPtAll_NoSDD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 840           if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSDD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 841         }
 842         if(!track->HasPointOnITSLayer(4) && !track->HasPointOnITSLayer(5)) {
 843           fPtITSouterminPtTPCvsPtAll_NoSSD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter));
 844           if(nPointITS>0) fPtITSouterminPtTPCvsPtAllChi2PerNClusITS_NoSSD->Fill(pt,(1./ptITSouter-1./ptTPC)/(1./ptITSouter),track->GetITSchi2()/nPointITS);
 845         }
 846       }
 847     }//fTrackCuts selection
 848
 849
 850     //ITSrefit selection
 851     if (fTrackCutsITS->AcceptTrack(track)) {
 852
 853       fPtSelITS->Fill(pt);
 854       fPtSelTPCITS->Fill(ptTPC);
 855       fPtITSminPtTPCvsPtITS->Fill(pt,(1./pt-1./ptTPC)/(1./pt) );
 856       fPtITSminPtTPCvsPtITSNPointTPC->Fill(pt,(1./pt-1./ptTPC)/(1./pt),track->GetTPCNcls());
 857       fPtITSminPtTPCvsPtITSDCAR->Fill(pt,(1./pt-1./ptTPC)/(1./pt),dca2D);
 858       fPtITSminPtTPCvsPtITSDCAZ->Fill(pt,(1./pt-1./ptTPC)/(1./pt),dcaZ);
 859       fPtITSminPtTPCvsPtITSPhi->Fill(pt,(pt-ptTPC)/(pt),phi);
 860       fPtITSminPtTPCvsPtITSNPointITS->Fill(pt,(pt-ptTPC)/(pt),nPointITS);
 861       fPtITSminPtTPCvsPtITSNSigmaToVertex->Fill(pt,(1./pt-1./ptTPC)/(1./pt),nSigmaToVertex);
 862       fPtITSminPtTPCvsPtITSChi2C->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2C);
 863       fPtITSminPtTPCvsPtITSRel1PtUncertainty->Fill(pt,(1./pt-1./ptTPC)/(1./pt),relUncertainty1Pt);
 864       //      fPtOuterPtInner->Fill(trackInner->Pt(),trackOuter->Pt());
 865       fPtRel1PtUncertaintyChi2PerClusTPC->Fill(pt,relUncertainty1Pt,chi2PerClusterTPC);
 866       fPtITSminPtTPCvsPtITSChi2PerNClusTPC->Fill(pt,(1./pt-1./ptTPC)/(1./pt),chi2PerClusterTPC);
 867       if(nPointITS>0) fPtITSminPtTPCvsPtITSChi2PerNClusITS->Fill(pt,(1./pt-1./ptTPC)/(1./pt),track->GetITSchi2()/nPointITS);
 868     }//fTrackCutsITS loop
 869
 870   }//ESD track loop
 871
 872   // Post output data
 873   PostData(0, fHistList);
 874   PostData(1, fHistListTPC);
 875   PostData(2, fHistListITS);
 876
 877 }
 878 //________________________________________________________________________
 879 void AliPWG4HighPtQATPConly::Terminate(Option_t *)
 880 {
 881
 882 }
 883
 884 #endif