PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetHF.cxx

   1 //
   2 // Author: A Castro (UTK)
   3 // Last Modified: August 11, 2014
   4
   5 #include "AliAnalysisTaskEmcalJetHF.h"
   6
   7 // general ROOT includes
   8 #include <TCanvas.h>
   9 #include <TChain.h>
  10 #include <TClonesArray.h>
  11 #include <TH1F.h>
  12 #include <TH2F.h>
  13 #include <TH3F.h>
  14 #include <THnSparse.h>
  15 #include <TList.h>
  16 #include <TLorentzVector.h>
  17 #include <TParameter.h>
  18 #include <TParticle.h>
  19 #include <TTree.h>
  20 #include <TVector3.h>
  21 #include <TObjArray.h>
  22
  23 // AliROOT includes
  24 #include "AliAODEvent.h"
  25 #include "AliESDEvent.h"
  26 #include "AliAnalysisManager.h"
  27 #include "AliAnalysisTask.h"
  28 #include "AliCentrality.h"
  29 #include "AliEmcalJet.h"
  30 #include "AliAODJet.h"
  31 #include "AliVCluster.h"
  32 #include "AliVTrack.h"
  33 #include <AliVEvent.h>
  34 #include <AliVParticle.h>
  35 #include "AliRhoParameter.h"
  36 #include "AliLog.h"
  37 #include "AliJetContainer.h"
  38 #include "AliParticleContainer.h"
  39 #include "AliClusterContainer.h"
  40 #include "AliEmcalParticle.h"
  41 #include "AliESDCaloCluster.h"
  42 #include <AliESDtrackCuts.h>
  43 #include "AliPID.h"
  44 #include "AliTPCdEdxInfo.h"
  45 //#include "AliCaloTrackESDReader.h"
  46 //#include "AliCaloTrackAODReader.h"
  47 //#include "AliCaloTrackReader.h"
  48
  49 // event handler (and pico's) includes
  50 #include <AliInputEventHandler.h>
  51 #include <AliVEventHandler.h>
  52 #include "AliESDInputHandler.h"
  53 #include "AliPicoTrack.h"
  54 #include "AliEventPoolManager.h"
  55 #include "AliAODTrack.h"
  56 #include "AliESDtrack.h"
  57
  58 // PID includes
  59 #include "AliPIDResponse.h"
  60 #include "AliTPCPIDResponse.h"
  61 #include "AliESDpid.h"
  62
  63 #include <AliInputEventHandler.h>
  64 #include <AliVEventHandler.h>
  65
  66 // magnetic field includes
  67 #include "TGeoGlobalMagField.h"
  68 #include "AliMagF.h"
  69
  70 using std::cout;
  71 using std::endl;
  72
  73 ClassImp(AliAnalysisTaskEmcalJetHF)
  74
  75 //________________________________________________________________________
  76 AliAnalysisTaskEmcalJetHF::AliAnalysisTaskEmcalJetHF() :
  77   AliAnalysisTaskEmcalJet("heavyF",kFALSE),
  78   event(0),
  79   fillHist(0),
  80   fEventTrigEMCALL1Gamma1(0),
  81   fEventTrigEMCALL1Gamma2(0),
  82   fGlobalQA(0),
  83   fInputEvent(0x0),
  84   fCuts(0),
  85   fPhimin(-10), fPhimax(10),
  86   fEtamin(-0.9), fEtamax(0.9),
  87   fAreacut(0.0),
  88   fJetHIpt(20.0),
  89   fTrackPtCut(2.0),
  90   fTrackEta(0.9),
  91   fTrkQAcut(0),
  92   fesdTrackCuts(0),
  93   fPIDResponse(0x0), fTPCResponse(),
  94   fEsdtrackCutsITSTPC(),
  95   fEsdtrackCutsTPC(),
  96   fEsdtrackCutsITS(),
  97   fJetsCont(0), fTracksCont(0), fCaloClustersCont(0), fTracksJetCont(0), fCaloClustersJetCont(0),
  98   fESD(0), fAOD(0),
  99   fHistRhovsCent(0),
 100   fHistJetPhi(0),
 101   fHistCorJetPt(0), fHistJetPt(0),
 102   fHistHighJetPt(0),
 103   fHistnSigElecPt(0),
 104   fHistnJetTrackvnJetClusters(0),
 105   fHistPtDEtaDPhiTrackClus(0),
 106   fHistPtDEtaDPhiClusTrack(0),
 107   fhnPIDHF(0x0), fhnJetQA(0x0), fhnClusterTrackQA(0x0), fhnTrackClusterQA(0x0), fhnPIDHFTtoC(0x0)
 108 {
 109   // Default constructor.
 110   for (Int_t i = 0;i<6;++i){
 111     fHistJetPtvsTrackPt[i]      = 0;
 112     fHistTrackPt[i]             = 0;
 113     fHistEP0[i]                 = 0;
 114     fHistEP0A[i]                = 0;
 115     fHistEP0C[i]                = 0;
 116     fHistEPAvsC[i]              = 0;
 117   }
 118
 119   SetMakeGeneralHistograms(kTRUE);
 120
 121 }
 122
 123 //________________________________________________________________________
 124 AliAnalysisTaskEmcalJetHF::AliAnalysisTaskEmcalJetHF(const char *name) :
 125   AliAnalysisTaskEmcalJet(name,kTRUE),
 126   event(0),
 127   fillHist(0),
 128   fEventTrigEMCALL1Gamma1(0),
 129   fEventTrigEMCALL1Gamma2(0),
 130   fGlobalQA(0),
 131   fInputEvent(0x0),
 132   fCuts(0),
 133   fPhimin(-10), fPhimax(10),
 134   fEtamin(-0.9), fEtamax(0.9),
 135   fAreacut(0.0),
 136   fJetHIpt(20.0),
 137   fTrackPtCut(2.0),
 138   fTrackEta(0.9),
 139   fTrkQAcut(0),
 140   fesdTrackCuts(0),
 141   fPIDResponse(0x0), fTPCResponse(),
 142   fEsdtrackCutsITSTPC(),
 143   fEsdtrackCutsTPC(),
 144   fEsdtrackCutsITS(),
 145   fJetsCont(0), fTracksCont(0), fCaloClustersCont(0), fTracksJetCont(0), fCaloClustersJetCont(0),
 146   fESD(0), fAOD(0),
 147   fHistRhovsCent(0),
 148   fHistJetPhi(0),
 149   fHistCorJetPt(0), fHistJetPt(0),
 150   fHistHighJetPt(0),
 151   fHistnSigElecPt(0),
 152   fHistnJetTrackvnJetClusters(0),
 153   fHistPtDEtaDPhiTrackClus(0),
 154   fHistPtDEtaDPhiClusTrack(0),
 155   fhnPIDHF(0x0), fhnJetQA(0x0), fhnClusterTrackQA(0x0), fhnTrackClusterQA(0x0), fhnPIDHFTtoC(0x0)
 156 {
 157   for (Int_t i = 0;i<6;++i){
 158     fHistJetPtvsTrackPt[i]      = 0;
 159     fHistTrackPt[i]             = 0;
 160     fHistEP0[i]                 = 0;
 161     fHistEP0A[i]                = 0;
 162     fHistEP0C[i]                = 0;
 163     fHistEPAvsC[i]              = 0;
 164    }
 165    SetMakeGeneralHistograms(kTRUE);
 166
 167    DefineInput(0,TChain::Class());
 168    DefineOutput(1, TList::Class());
 169 }
 170
 171 //_______________________________________________________________________
 172 AliAnalysisTaskEmcalJetHF::~AliAnalysisTaskEmcalJetHF()
 173 {
 174   // destructor
 175   //
 176   if (fOutput) {
 177     delete fOutput;
 178     fOutput = 0;
 179   }
 180 }
 181
 182 //________________________________________________________________________
 183 void AliAnalysisTaskEmcalJetHF::UserCreateOutputObjects()
 184 {
 185   if (! fCreateHisto)
 186     return;
 187   AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
 188
 189   //fJetsCont           = GetJetContainer(0);
 190   if(fJetsCont) { //get particles and clusters connected to jets
 191     fTracksJetCont       = fJetsCont->GetParticleContainer();
 192     fCaloClustersJetCont = fJetsCont->GetClusterContainer();
 193   }
 194  else {        //no jets, just analysis tracks and clusters
 195   fTracksCont       = GetParticleContainer(0);
 196   fCaloClustersCont = GetClusterContainer(0);
 197 }
 198 fTracksCont->SetClassName("AliVTrack");
 199 fCaloClustersCont->SetClassName("AliVCluster");
 200
 201   fHistJetPhi                = new TH1F("NjetvsPhi", "NjetvsPhi", 288,-2*TMath::Pi(),2*TMath::Pi());
 202   fHistJetPt                 = new TH1F("NjetvsJetPt", "NjetvsJetPt", 300, 0, 300);
 203   fOutput->Add(fHistJetPhi);
 204   fOutput->Add(fHistJetPt);
 205
 206   fillHist = 1;
 207   TString histname;
 208
 209   if(fillHist>0){
 210   fHistRhovsCent              = new TH2F("RhovsCent", "RhovsCent", 100, 0.0, 100.0, 400, 0, 400);
 211   fHistCorJetPt                     = new TH1F("NjetvsCorrJetPt", "NjetvsCorrJetPt", 300, -100, 200);
 212   fHistnSigElecPt             = new TH2F("nsig_v_pt(TPC)","nsig_v_pt(TPC)",200,0,100,100,-10,10);
 213   fHistnJetTrackvnJetClusters = new TH2F("NumbJetTracksvJetClusters","NumbJetTracksvJetClusters",21,0,20,21,0,20);
 214   fHistHighJetPt              = new TH1F("HighestPtJetPerEvent","HighJetPt",300,0,150);
 215
 216   histname = "fHistPtDEtaDPhiTrackClus";
 217   fHistPtDEtaDPhiTrackClus = new TH3F(histname.Data(),Form("%s;#it{p}_{T}^{track};#Delta#eta;#Delta#varphi",histname.Data()),100,0.,100.,100,-0.1,0.1,100,-0.1,0.1);
 218   fOutput->Add(fHistPtDEtaDPhiTrackClus);
 219
 220   histname = "fHistPtDEtaDPhiClusTrack";
 221   fHistPtDEtaDPhiClusTrack = new TH3F(histname.Data(),Form("%s;#it{p}_{T}^{clus};#Delta#eta;#Delta#varphi",histname.Data()),100,0.,100.,100,-0.1,0.1,100,-0.1,0.1);
 222   fOutput->Add(fHistPtDEtaDPhiClusTrack);
 223
 224   // PT bins used to be (2000, -100, 300)
 225   TString name;
 226   TString title;
 227
 228   // creating centrality dependent histos that don't involve Global Rho
 229   for (Int_t i = 0;i<6;++i){
 230     name = TString(Form("JetPtvsTrackPt_%i",i));
 231     title = TString(Form("Jet pT vs Leading Track pT cent bin %i",i));
 232     fHistJetPtvsTrackPt[i] = new TH2F(name,title, 500, -100, 400, 100,0,100);
 233     fOutput->Add(fHistJetPtvsTrackPt[i]);
 234
 235     name = TString(Form("TrackPt_%i",i));
 236     title = TString(Form("Track pT cent bin %i",i));
 237     fHistTrackPt[i] = new TH1F(name,title,400,0,200);
 238     fOutput->Add(fHistTrackPt[i]);
 239
 240     name = TString(Form("EP0_%i",i));
 241     title = TString(Form("EP VZero cent bin %i",i));
 242     fHistEP0[i] = new TH1F(name,title,144,-TMath::Pi(),TMath::Pi());
 243     fOutput->Add(fHistEP0[i]);
 244
 245     name = TString(Form("EP0A_%i",i));
 246     title = TString(Form("EP VZero cent bin %i",i));
 247     fHistEP0A[i] = new TH1F(name,title,144,-TMath::Pi(),TMath::Pi());
 248     fOutput->Add(fHistEP0A[i]);
 249
 250     name = TString(Form("EP0C_%i",i));
 251     title = TString(Form("EP VZero cent bin %i",i));
 252     fHistEP0C[i] = new TH1F(name,title,144,-TMath::Pi(),TMath::Pi());
 253     fOutput->Add(fHistEP0C[i]);
 254
 255     name = TString(Form("EPAvsC_%i",i));
 256     title = TString(Form("EP VZero cent bin %i",i));
 257     fHistEPAvsC[i] = new TH2F(name,title,144,-TMath::Pi(),TMath::Pi(),100,-TMath::Pi(),TMath::Pi());
 258     fOutput->Add(fHistEPAvsC[i]);
 259
 260   }
 261
 262   fOutput->Add(fHistRhovsCent);
 263   fOutput->Add(fHistCorJetPt);
 264   fOutput->Add(fHistnSigElecPt);
 265   fOutput->Add(fHistnJetTrackvnJetClusters);
 266   fOutput->Add(fHistHighJetPt);
 267   }//Fill Histograms
 268
 269   // ****************************** PID *****************************************************
 270   // set up PID handler
 271   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 272   AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 273   if(!inputHandler) {
 274     AliFatal("Input handler needed");
 275     return;
 276   }
 277
 278   // PID response object
 279   //fPIDResponse = (AliPIDResponse*)inputHandler->GetPIDResponse();
 280   //  inputHandler->CreatePIDResponse(fIsMC);         // needed to create object, why though?
 281   fPIDResponse = inputHandler->GetPIDResponse();
 282   if (!fPIDResponse) {
 283     AliError("PIDResponse object was not created");
 284     return;
 285   }
 286   // ****************************************************************************************
 287   UInt_t bitcoded = 0;  // bit coded, see GetDimParamsPID() below
 288   bitcoded = 1<<0 | 1<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<6 | 1<<7 | 1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12 | 1<<13| 1<<14 | 1<<15 | 1<<16 | 1<<17;
 289   fhnPIDHF = NewTHnSparseDHF("fhnPIDHFCtoT", bitcoded);
 290
 291   UInt_t bitcoded1 = 0;  // bit coded, see GetDimParamsPID() below
 292   bitcoded1 = 1<<0 | 1<<1 | 1<<2 | 1<<3 | 1<<4;
 293   fhnJetQA = NewTHnSparseDJetQA("fhnJetQA", bitcoded1);
 294
 295   UInt_t bitcoded2 = 0;  // bit coded, see GetDimParamsPID() below
 296   bitcoded2 = 1<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<8 | 1<<9 | 1<<10 | 1<<15 | 1<<16 | 1<<17;
 297   fhnClusterTrackQA = NewTHnSparseDHF("fhnClusterTrackQA", bitcoded2);
 298
 299   UInt_t bitcoded3 = 0;  // bit coded, see GetDimParamsPID() below
 300   bitcoded3 = 1<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<8 | 1<<9 | 1<<10 | 1<<15 | 1<<16 | 1<<17;
 301   fhnTrackClusterQA = NewTHnSparseDHF("fhnTrackClusterQA", bitcoded3);
 302
 303   UInt_t bitcoded7 = 0;  // bit coded, see GetDimParamsPID() below
 304   bitcoded7 = 1<<0 | 1<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<6 | 1<<7 | 1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12 | 1<<13| 1<<14 | 1<<15 | 1<<16 | 1<<17;
 305   fhnPIDHFTtoC = NewTHnSparseDHF("fhnPIDHFTtoC", bitcoded7);
 306
 307   cout << "_______________Created Sparse__________________" << endl;
 308
 309   fOutput->Add(fhnPIDHF);
 310   fOutput->Add(fhnJetQA);
 311   fOutput->Add(fhnClusterTrackQA);
 312   fOutput->Add(fhnTrackClusterQA);
 313   fOutput->Add(fhnPIDHFTtoC);
 314
 315   PostData(1, fOutput);
 316
 317 }
 318
 319 //________________________________________________________
 320 void AliAnalysisTaskEmcalJetHF::ExecOnce()
 321 {
 322   //  Initialize the analysis
 323   AliAnalysisTaskEmcalJet::ExecOnce();
 324
 325   if (fJetsCont && fJetsCont->GetArray() == 0) fJetsCont = 0;
 326   if (fTracksCont && fTracksCont->GetArray() == 0) fTracksCont = 0;
 327   if (fCaloClustersCont && fCaloClustersCont->GetArray() == 0) fCaloClustersCont = 0;
 328
 329
 330 } // end of ExecOnce
 331
 332 //________________________________________________________________________
 333 Bool_t AliAnalysisTaskEmcalJetHF::Run()
 334 {
 335   // check to see if we have any tracks
 336   if (!fTracks)  return kTRUE;
 337   if (!fJets)  return kTRUE;
 338
 339   // what kind of event do we have: AOD or ESD?
 340   Bool_t useAOD;
 341   if (dynamic_cast<AliAODEvent*>(InputEvent())) useAOD = kTRUE;
 342   else useAOD = kFALSE;
 343
 344   fEventTrigEMCALL1Gamma1 = kFALSE;
 345   fEventTrigEMCALL1Gamma2 = kFALSE;
 346
 347   // if we have ESD event, set up ESD object
 348   if(!useAOD){
 349     fESD = dynamic_cast<AliESDEvent*>(InputEvent());
 350     if (!fESD) {
 351       AliError(Form("ERROR: fESD not available\n"));
 352       return kTRUE;
 353     }
 354   }
 355
 356   // if we have AOD event, set up AOD object
 357   if(useAOD){
 358     fAOD = dynamic_cast<AliAODEvent*>(InputEvent());
 359     if(!fAOD) {
 360       AliError(Form("ERROR: fAOD not available\n"));
 361       return kTRUE;
 362     }
 363   }
 364
 365   // get magnetic field info for DCA
 366   Double_t  MagF = fESD->GetMagneticField();
 367   Double_t MagSign = 1.0;
 368   if(MagF<0)MagSign = -1.0;
 369   // set magnetic field
 370   if (!TGeoGlobalMagField::Instance()->GetField()) {
 371     AliMagF* field = new AliMagF("Maps","Maps", MagSign, MagSign, AliMagF::k5kG);
 372     TGeoGlobalMagField::Instance()->SetField(field);
 373   }
 374
 375   // get centrality bin
 376   Int_t centbin = GetCentBin(fCent);
 377   //for pp analyses we will just use the first centrality bin
 378   if (centbin == -1)  centbin = 0;
 379
 380   // get vertex information
 381   Double_t fvertex[3]={0,0,0};
 382   InputEvent()->GetPrimaryVertex()->GetXYZ(fvertex);
 383   //Double_t zVtx=fvertex[2];
 384
 385   // create pointer to list of input event
 386   TList *list = InputEvent()->GetList();
 387   if(!list) {
 388     AliError(Form("ERROR: list not attached\n"));
 389     return kTRUE;
 390   }
 391
 392   // background density
 393   fRhoVal = fRho->GetVal();
 394
 395   // initialize TClonesArray pointers to jets and tracks
 396   TClonesArray *jets = 0;
 397   //TClonesArray *tracks = 0;
 398   //TClonesArray *clusters = 0;
 399   //TClonesArray * clusterList = 0;
 400
 401   // get Jets object
 402   jets = dynamic_cast<TClonesArray*>(list->FindObject(fJets));
 403   if(!jets){
 404     AliError(Form("Pointer to jets %s == 0", fJets->GetName()));
 405     return kTRUE;
 406   } // verify existence of jets
 407
 408   event++;
 409   //cout<<"Event #: "<<event<<"  Number of Clusters: "<<fCaloClustersCont->GetNClusters()<<"  Number of Tracks: "<<fTracksCont->GetNParticles()<<endl;
 410
 411  // Int_t   nclusters   = fInputEvent->GetNumberOfCaloClusters();
 412
 413
 414   // get number of jets and tracks
 415   const Int_t Njets = jets->GetEntries();
 416   if(Njets<1)     return kTRUE;
 417
 418   if (fTracksCont) {
 419     AliVTrack *track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle(0));
 420     while(track) {
 421       track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
 422     }
 423   }
 424   if (fCaloClustersCont) {
 425     AliVCluster *cluster = fCaloClustersCont->GetNextAcceptCluster(0);
 426     while(cluster) {
 427       TLorentzVector nPart;
 428       cluster->GetMomentum(nPart, fVertex);
 429       cluster = fCaloClustersCont->GetNextAcceptCluster();
 430     }
 431   }
 432
 433     //  Start Jet Analysis
 434     // initialize jet parameters
 435     Int_t ijethi=-1;
 436     Double_t highestjetpt=0.0;
 437
 438   // loop over jets in an event - to find highest jet pT and apply some cuts && JetQA Sparse
 439   for (Int_t ijet = 0; ijet < Njets; ijet++){
 440     // get our jets
 441     AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(ijet));
 442     if (!jet) continue;
 443
 444     // apply jet cuts
 445     if(!AcceptMyJet(jet)) continue;
 446
 447
 448
 449     if(highestjetpt<jet->Pt()){
 450       ijethi=ijet;
 451       highestjetpt=jet->Pt();
 452     }
 453   } // end of looping over jets
 454
 455     fHistHighJetPt->Fill(ijethi);
 456  // **********************************************************************
 457  //                JET LOOP
 458  // **********************************************************************
 459
 460     // loop over jets in the event and make appropriate cuts
 461     for (Int_t iJets = 0; iJets < Njets; ++iJets) {
 462       AliEmcalJet *jet = static_cast<AliEmcalJet*>(fJets->At(iJets));
 463       if (!jet)  // see if we have a jet
 464         continue;
 465
 466       // phi of jet, constrained to 1.6 < Phi < 2.94
 467       float jetphi = jet->Phi();      // phi of jet
 468       // apply jet cuts
 469       if(!AcceptMyJet(jet)) continue;
 470
 471       //AliEmcalJet::EFlavourTag tag=AliEmcalJet::kDStar;
 472       //jet->AddFlavourTag(tag);
 473
 474       //MV: removed to avoid compiler warnings
 475       //      Bool_t bkgrnd1  = kFALSE;
 476       // Bool_t sig1     = kFALSE;
 477
 478       Int_t JetClusters = jet->GetNumberOfClusters();
 479       Int_t JetTracks = jet -> GetNumberOfTracks();
 480       fHistnJetTrackvnJetClusters->Fill(JetClusters,JetTracks);
 481      // Initializations and Calculations
 482      Double_t jetptraw = jet->Pt();                             // raw pT of jet
 483      Double_t jetPt = -500;                                     // initialize corr jet pt LOCAL
 484      Double_t jetarea = -500;                                   // initialize jet area
 485      jetarea = jet->Area();                                     // jet area
 486      jetPt = jet->Pt() - jetarea*fRhoVal;                 // semi-corrected pT of jet from GLOBAL rho value
 487       fHistCorJetPt->Fill(jetPt);
 488
 489       if(jet->Pt() > fJetHIpt) {
 490         if(!fTracksCont || !fCaloClustersCont) return kTRUE;
 491
 492         Double_t dEdx = -99;
 493         Double_t EovP = -99;
 494         Float_t DCAxy = -999;
 495         Float_t DCAz = -999;
 496
 497         Double_t deta = 999;
 498         Double_t dphi = 999;
 499         Int_t NumbCluster = -999;
 500         NumbCluster = fCaloClustersCont->GetNClusters();
 501         Double_t JetQA[5] = {static_cast<Double_t>(Njets), static_cast<Double_t>(jet->GetNumberOfTracks()), static_cast<Double_t>(jet->GetNumberOfClusters()),jet->Eta(), jet->Phi()};
 502         fhnJetQA->Fill(JetQA);
 503
 504       //***********************************************
 505       //****************Track Matched to Closest Cluster
 506
 507
 508        for(int iCluster = 0; iCluster <= NumbCluster; iCluster++){
 509           //Get closest track to cluster to track matching!!!!!
 510           //AliVCluster *cluster = fCaloClustersCont->GetNextAcceptedCluster(iCluster);
 511           AliVCluster *cluster = fCaloClustersCont->GetCluster(iCluster);
 512
 513           if(! IsJetCluster(jet, iCluster, kFALSE)) continue;
 514
 515           // while(cluster) {
 516           TLorentzVector nPart;
 517           cluster->GetMomentum(nPart, fVertex);
 518           //fHistClustersPt[fCentBin]->Fill(nPart.Pt());
 519           Double_t fclusE = -999;
 520           fclusE = cluster->E();
 521
 522           Float_t pos[3];
 523           cluster->GetPosition(pos);  // Get cluster position
 524           TVector3 cp(pos);
 525
 526           //Get matched track
 527           AliVTrack *mt = NULL;
 528           //AliESDtrack *mt = NULL;
 529           AliESDtrack *ESDmt = NULL;
 530           AliAODCaloCluster *acl = dynamic_cast<AliAODCaloCluster*>(cluster);
 531           if(acl) {
 532
 533             //mt = static_cast<AliVTrack*>(acl->GetTrackMatched(0));
 534           }
 535           else {
 536
 537             AliESDCaloCluster *ecl = dynamic_cast<AliESDCaloCluster*>(cluster);
 538             Int_t im = ecl->GetTrackMatchedIndex();
 539
 540             if(fTracksCont && im>=0) {
 541               //mt = static_cast<AliVTrack*>(fTracksCont->GetParticle(im));
 542               mt = static_cast<AliVTrack*>(fTracksCont->GetParticle(im));
 543               if(!mt) continue;
 544
 545               ESDmt = static_cast<AliESDtrack*>(mt);
 546               if(!ESDmt) continue;
 547
 548               Double_t pcluster = mt->P();
 549               //Double_t esdp = ESDmt->P();
 550               //Int_t LabelNumb, IDNumb;
 551               //LabelNumb = ESDmt->GetLabel();
 552               //IDNumb= ESDmt -> GetID();
 553
 554               dEdx = mt->GetTPCsignal();
 555               Double_t p = mt->P();
 556                //TPC nSigma's
 557               //nsigpion = fPIDResponse->NumberOfSigmasTPC(mt,AliPID::kPion);
 558               Double_t nSigmaElectron_TPC = fPIDResponse->NumberOfSigmasTPC(mt,AliPID::kElectron);
 559               Double_t nSigmaElectron_TOF = fPIDResponse->NumberOfSigmasTOF(mt,AliPID::kElectron);
 560               dEdx = mt->GetTPCsignal();
 561               ESDmt->GetImpactParameters(DCAxy, DCAz);
 562               EovP        = fclusE/p;
 563                 Double_t HF_tracks[18] = {fCent, mt->Pt(), pcluster ,mt->Eta(), mt->Phi(), EovP, DCAxy, DCAz, dEdx,nSigmaElectron_TPC, nSigmaElectron_TOF,0 /*nSigmaElectron_EMCAL*/, jetptraw, jetphi, jet->Eta(),fclusE,cp.PseudoRapidity(),cp.Phi()};
 564                 fhnPIDHF->Fill(HF_tracks);    // fill Sparse Histo with trigger entries
 565
 566
 567
 568             }
 569           }
 570
 571           if(mt) {
 572             AliPicoTrack::GetEtaPhiDiff(mt, cluster, dphi, deta);
 573             fHistPtDEtaDPhiClusTrack->Fill(nPart.Pt(),deta,dphi);
 574
 575
 576
 577           }
 578
 579           //cluster = fCaloClustersCont->GetNextAcceptCluster();
 580           //if(! IsJetCluster(jet, cluster, kFALSE)) continue;
 581         //}
 582
 583           /*
 584            Double_t p = mt->P();
 585            Float_t pos[3];
 586            cluster->GetPosition(pos);  // Get cluster position
 587            //AliESDtrack *trackESD = fESD->GetTrack(Ntracks);
 588
 589            //  nSigmaElectron_TPC = fPIDResponse->NumberOfSigmasTPC(mt,AliPID::kElectron);
 590            //  nSigmaElectron_TOF= fPIDResponse->NumberOfSigmasTOF(mt,AliPID::kElectron);
 591            EovP        = fclusE/p;
 592            TVector3 cp(pos);
 593
 594            //if(!fesdTrackCuts->AcceptTrack(mt)) continue;
 595            //dEdx = mt->GetTPCsignal();
 596            //mt->GetImpactParameters(DCAxy, DCAz);
 597            //nSigmaElectron_TPC = fPIDResponse->NumberOfSigmasTPC(trackESD,AliPID::kElectron);
 598            //nSigmaElectron_TOF = fPIDResponse->NumberOfSigmasTOF(trackESD,AliPID::kElectron);
 599
 600
 601            //Double_t HF_tracks[18] = {fCent, mt->Pt(), mt->P() ,mt->Eta(), mt->Phi(), EovP, DCAxy, DCAz, dEdx, nSigmaElectron_TPC, nSigmaElectron_TOF, nSigmaElectron_EMCAL, jet->Pt(), jet->Phi(), jet->Eta(),fclusE,cp.PseudoRapidity(),cp.Phi()};
 602            //fhnPIDHF->Fill(HF_tracks);    // fill Sparse Histo with trigger entries
 603            */
 604           //cluster = fCaloClustersCont->GetNextAcceptCluster();
 605           //if(! IsJetCluster(jet, cluster, kFALSE)) continue;
 606
 607
 608           //AliESDtrack *ESDacceptedTrack = NULL;
 609         }//loop over cluster
 610
 611       //******************************Cluster Matched To Closest Track
 612       //**************************************************************
 613
 614
 615       Int_t NumbTrackContainer = -999;
 616       NumbTrackContainer = fTracksCont->GetNParticles();
 617       for(int iTracks = 0; iTracks <= NumbTrackContainer; iTracks++){
 618         AliVTrack *AcceptedTrack =static_cast<AliVTrack*>(fTracksCont->GetParticle(iTracks));
 619         if(!AcceptedTrack){
 620           AliError(Form("Couldn't get AliVTrack Container %d\n", iTracks));
 621           continue;
 622         }
 623         if(!IsJetTrack(jet,iTracks,kFALSE))continue;
 624         //Get matched cluster
 625         Int_t emc1 = AcceptedTrack->GetEMCALcluster();
 626
 627         Double_t acceptTrackP = AcceptedTrack->P();
 628         Double_t acceptTrackPt = AcceptedTrack->Pt();
 629         Double_t acceptTrackEta = AcceptedTrack->Eta();
 630         Double_t acceptTrackPhi = AcceptedTrack->Phi();
 631         Double_t nSigmaElectron_TPC_at = fPIDResponse->NumberOfSigmasTPC(AcceptedTrack,AliPID::kElectron);
 632         Double_t nSigmaElectron_TOF_at = fPIDResponse->NumberOfSigmasTOF(AcceptedTrack,AliPID::kElectron);
 633
 634
 635         AliESDtrack *ESDacceptedTrack = static_cast<AliESDtrack*>(AcceptedTrack);
 636
 637         if(!ESDacceptedTrack){
 638           AliError(Form("Couldn't get AliESDTrack %d\n", iTracks));
 639           continue;
 640         }
 641         //Double_t DCAxy_at, DCAz_at;
 642         Double_t dEdxat = AcceptedTrack->GetTPCsignal();
 643         //ESDacceptedTrack->GetImpactParameters(DCAxy_at, DCAz_at);
 644
 645
 646         if(fCaloClustersCont && emc1>=0) {
 647           AliVCluster *clusMatch = fCaloClustersCont->GetCluster(emc1);
 648           if(!clusMatch){
 649             AliError(Form("Couldn't get matched AliVCluster %d\n", emc1));
 650             continue;
 651           }
 652
 653
 654
 655           Double_t mClusterE = clusMatch->E();
 656           Float_t pos_mc[3];
 657           clusMatch->GetPosition(pos_mc);  // Get cluster position
 658           TVector3 mcp(pos_mc);
 659           Double_t EovP_mc = -999;
 660           EovP_mc = mClusterE/acceptTrackP;
 661           //MV: removed to avoid compiler warnings
 662           // if(EovP_mc < 0.2){
 663           //   bkgrnd1 = kTRUE;      //Hadron Background
 664           // }
 665
 666           //Code without meaning:
 667           //if(0.8 < EovP_mc < 1.2){
 668           //            if(-1.5<nSigmaElectron_TPC_at<5.0){
 669           //              if(4.0<acceptTrackPt<10.0){
 670
 671           //Corrected code:
 672           // if(EovP_mc >0.8 && EovP_mc<1.2){
 673           //   if(nSigmaElectron_TPC_at>-1.5 && nSigmaElectron_TPC_at<5.0){
 674           //     if(acceptTrackPt>4.0 && acceptTrackPt<10.0){
 675           //       sig1 = kTRUE;                    //Electron Candidate
 676           //     }
 677           //   }
 678           // }
 679
 680           Double_t HF_tracks2[18] = {fCent, acceptTrackPt, acceptTrackP ,acceptTrackEta, acceptTrackPhi, EovP_mc, 0, 0, dEdxat,nSigmaElectron_TPC_at, nSigmaElectron_TOF_at,0 , jetPt, jet->Phi(), jet->Eta(),mClusterE,mcp.PseudoRapidity(),mcp.Phi()};
 681           fhnPIDHFTtoC->Fill(HF_tracks2);    // fill Sparse Histo with trigger entries
 682         }
 683         //AcceptedTrack = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
 684
 685       } //loop over tracks for matching to closest cluster
 686
 687
 688
 689
 690     } // highest pt jet cut
 691       /*
 692       Int_t tag = -999;
 693       if(bkgrnd1 == kTRUE) {
 694         AliEmcalJet::EFlavourTag tag=AliEmcalJet::kBckgrd1;
 695         jet->AddFlavourTag(tag);
 696       }
 697       if(sig1 == kTRUE && !bkgrnd1){
 698         AliEmcalJet::EFlavourTag tag=AliEmcalJet::kSig1;
 699         jet->AddFlavourTag(tag);
 700       }
 701        */
 702   } // LOOP over JETS in event
 703
 704
 705
 706   if(fGlobalQA == 1) CheckClusTrackMatchingQA();
 707
 708   return kTRUE;
 709
 710 }
 711 //________________________________________________________________________
 712 void AliAnalysisTaskEmcalJetHF::Terminate(Option_t *)
 713 {
 714   cout<<"###########################"<<endl;
 715   cout<<"####   Task Finished   ####"<<endl;
 716   cout<<"###########################"<<endl;
 717   cout<<"###########################"<<endl;
 718 } // end of terminate
 719
 720
 721 //________________________________________________________________________
 722 void AliAnalysisTaskEmcalJetHF::CheckClusTrackMatchingQA()
 723 {
 724
 725   if(!fTracksCont || !fCaloClustersCont) return;
 726
 727   Int_t trkcounter = 0;
 728   Int_t cluscounter = 0;
 729   Double_t deta = 999;
 730   Double_t dphi = 999;
 731
 732   //Get closest cluster to track
 733   AliVTrack *track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle(0));
 734   while(track) {
 735     //if(!track) continue;
 736     AliESDtrack *ESDtrackQA1 = static_cast<AliESDtrack*>(track);
 737     if(!ESDtrackQA1) continue;
 738     if(!fPIDResponse) continue;
 739     Double_t pQA1 = track->P();
 740     Double_t nSigmaElectron_TPC_QA1 = fPIDResponse->NumberOfSigmasTPC(ESDtrackQA1,AliPID::kElectron);
 741     Double_t nSigmaElectron_TOF_QA1 = fPIDResponse->NumberOfSigmasTOF(ESDtrackQA1,AliPID::kElectron);
 742     Double_t dEdxQA1 = ESDtrackQA1->GetTPCsignal();
 743     //Get matched cluster
 744     Int_t emc1 = track->GetEMCALcluster();
 745     if(fCaloClustersCont && emc1>=0) {
 746       AliVCluster *clusMatch = fCaloClustersCont->GetCluster(emc1);
 747       //if(!clusMatch) continue;
 748       if(clusMatch) {
 749         Double_t ClusterE_QA1 = clusMatch->E();
 750         Double_t EovPQA1 = ClusterE_QA1/pQA1;
 751         Float_t pos_mc1[3];
 752         clusMatch->GetPosition(pos_mc1);  // Get cluster position
 753         TVector3 mc1(pos_mc1);
 754         fHistnSigElecPt->Fill(nSigmaElectron_TPC_QA1,track->Pt());
 755         Double_t HF_tracks3[11] = {track->Pt(), track->P() , track->Eta(), track->Phi(), EovPQA1, dEdxQA1 ,nSigmaElectron_TPC_QA1, nSigmaElectron_TOF_QA1, clusMatch->E(), mc1.PseudoRapidity(),mc1.Phi()};
 756         fhnTrackClusterQA->Fill(HF_tracks3);
 757         AliPicoTrack::GetEtaPhiDiff(track, clusMatch, dphi, deta);
 758         fHistPtDEtaDPhiTrackClus->Fill(track->Pt(),deta,dphi);
 759         cluscounter++;
 760       }//clus matching
 761
 762      }//matched cluster
 763
 764     track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
 765     trkcounter++;
 766   }//track loop
 767  /*
 768   //Get closest track to cluster
 769   AliVCluster *cluster = fCaloClustersCont->GetNextAcceptCluster(0);
 770   while(cluster) {
 771     if(!cluster) continue;
 772
 773     Double_t ClusterE_QA2 = cluster->E();
 774     //Double_t EovPQA1 = ClusterE_QA1/pQA1;
 775     Float_t pos_mc2[3];
 776     cluster->GetPosition(pos_mc2);  // Get cluster position
 777     TVector3 mc2(pos_mc2);
 778
 779     TLorentzVector nPart;
 780     cluster->GetMomentum(nPart, fVertex);
 781
 782     //Get matched track
 783     AliVTrack *mt = NULL;
 784     AliAODCaloCluster *acl = dynamic_cast<AliAODCaloCluster*>(cluster);
 785     if(!acl) continue;
 786     if(acl) {
 787       if(acl->GetNTracksMatched()>1)
 788       mt = static_cast<AliVTrack*>(acl->GetTrackMatched(0));
 789       if(!mt) continue;
 790       AliESDtrack *ESDtrackQA2 = static_cast<AliESDtrack*>(mt);
 791       if(!ESDtrackQA2) continue;
 792       Double_t nSigmaElectron_TPC_QA2 = fPIDResponse->NumberOfSigmasTPC(ESDtrackQA1,AliPID::kElectron);
 793       Double_t nSigmaElectron_TOF_QA2 = fPIDResponse->NumberOfSigmasTOF(ESDtrackQA1,AliPID::kElectron);
 794       Double_t dEdxQA1 = ESDtrackQA2->GetTPCsignal();
 795       Double_t EovPQA2 = -999;
 796       Double_t pQA2 = mt->P();
 797       EovPQA2 = ClusterE_QA2/pQA2;
 798
 799       //Double_t HF_tracks4[11] = {mt->Pt(), mt->P() , mt->Eta(), mt->Phi(), EovPQA2, dEdxQA2 ,nSigmaElectron_TPC_QA2, nSigmaElectron_TOF_QA2, mc2.PseudoRapidity(),mc2.Phi()};
 800       //fhnClusterTrackQA->Fill(HF_tracks4);
 801     }
 802     else {
 803       AliESDCaloCluster *ecl = dynamic_cast<AliESDCaloCluster*>(cluster);
 804       if(!ecl) continue;
 805       Int_t im = ecl->GetTrackMatchedIndex();
 806       if(fTracksCont && im>=0) {
 807         mt = static_cast<AliVTrack*>(fTracksCont->GetParticle(im));
 808         if(!mt) continue
 809       }
 810     }
 811     AliPicoTrack::GetEtaPhiDiff(mt, cluster, dphi, deta);
 812     fHistPtDEtaDPhiClusTrack->Fill(nPart.Pt(),deta,dphi);
 813     cluster = fCaloClustersCont->GetNextAcceptCluster();
 814   }
 815   }
 816 */
 817 /*
 818   //Get closest track to cluster
 819   AliVCluster *cluster = fCaloClustersCont->GetNextAcceptCluster(0);
 820   while(cluster) {
 821     if(!cluster){
 822       AliError(Form("Couldn't get CtoT AliCluster Container"));
 823       continue;
 824     }
 825     Double_t ClusterE_QA2 = cluster->E();
 826     Float_t pos_mc2[3];
 827     cluster->GetPosition(pos_mc2);  // Get cluster position
 828     TVector3 mc2(pos_mc2);
 829     TLorentzVector nPart;
 830     cluster->GetMomentum(nPart, fVertex);
 831     //Get matched track
 832     AliVTrack *mt = NULL;
 833     AliESDCaloCluster *ecl = dynamic_cast<AliESDCaloCluster*>(cluster);
 834     if(!ecl){
 835       AliError(Form("Couldn't get CtoT AliESDCluster Container %d\n"));
 836       continue;
 837     }
 838     Int_t im = ecl->GetTrackMatchedIndex();
 839     if(fTracksCont && im>=0) {
 840       //mt = static_cast<AliVTrack*>(fTracksCont->GetParticle(im));
 841       //if(!mt){
 842         //AliError(Form("Couldn't get CT AliVTrack Container %d\n",im));
 843         //continue;
 844      // }
 845       //AliPicoTrack::GetEtaPhiDiff(mt, cluster, dphi, deta);
 846       fHistPtDEtaDPhiClusTrack->Fill(nPart.Pt(),deta,dphi);
 847       AliESDtrack *ESDtrackQA2 = static_cast<AliESDtrack*>(mt);
 848       if(!ESDtrackQA2){
 849         AliError(Form("Couldn't get CT AliESDTrack Container %d\n"));
 850         continue;
 851       }
 852       Double_t nSigmaElectron_TPC_QA2 = fPIDResponse->NumberOfSigmasTPC(ESDtrackQA2,AliPID::kElectron);
 853       Double_t nSigmaElectron_TOF_QA2 = fPIDResponse->NumberOfSigmasTOF(ESDtrackQA2,AliPID::kElectron);
 854       Double_t dEdxQA1 = ESDtrackQA2->GetTPCsignal();
 855       Double_t EovPQA2 = -999;
 856       Double_t pQA2 = mt->P();
 857       EovPQA2 = ClusterE_QA2/pQA2;
 858
 859
 860     }
 861     //cluster = fCaloClustersCont->GetNextAcceptCluster();
 862     cluster = static_cast<AliVCluster*>(fCaloClustersCont->GetNextAcceptCluster());
 863   }
 864 */
 865 }
 866
 867
 868 //________________________________________________________________________
 869 Int_t AliAnalysisTaskEmcalJetHF::AcceptMyJet(AliEmcalJet *jet) {
 870   //applies all jet cuts except pt
 871   if ((jet->Phi()<fPhimin)||(jet->Phi()>fPhimax)) return 0;
 872   if ((jet->Eta()<fEtamin)||(jet->Eta()>fEtamax)) return 0;
 873   if (jet->Area()<fAreacut) return 0;
 874   // prevents 0 area jets from sneaking by when area cut == 0
 875   if (jet->Area()==0) return 0;
 876   //exclude jets with extremely high pt tracks which are likely misreconstructed
 877   if(jet->MaxTrackPt()>100) return 0;
 878
 879   //passed all above cuts
 880   return 1;
 881 }
 882
 883 //________________________________________________________________________
 884 Int_t AliAnalysisTaskEmcalJetHF::GetCentBin(Double_t cent) const
 885 {  // Get centrality bin.
 886
 887   Int_t centbin = -1;
 888   if (cent>=0 && cent<10)
 889     centbin = 0;
 890   else if (cent>=10 && cent<20)
 891     centbin = 1;
 892   else if (cent>=20 && cent<30)
 893     centbin = 2;
 894   else if (cent>=30 && cent<40)
 895     centbin = 3;
 896   else if (cent>=40 && cent<50)
 897     centbin = 4;
 898   else if (cent>=50 && cent<90)
 899     centbin = 5;
 900   return centbin;
 901 }
 902
 903 //________________________________________________________________________________
 904 /*
 905 void AliAnalysisTaskEmcalJetHF::FlagFlavour(AliEmcalJet *jet){
 906
 907   AliEmcalJet::EFlavourTag tag=AliEmcalJet::kDStar;
 908   if (fCandidateType==kD0toKpi) tag=AliEmcalJet::kD0;
 909   if (fIsDInJet) jet->AddFlavourTag(tag);
 910
 911   return;
 912
 913 }
 914 */
 915 //____________________________________________________________________________________________
 916 THnSparse* AliAnalysisTaskEmcalJetHF::NewTHnSparseDHF(const char* name, UInt_t entries)
 917 {
 918   // generate new THnSparseD PID, axes are defined in GetDimParams()
 919   Int_t count = 0;
 920   UInt_t tmp = entries;
 921   while(tmp!=0){
 922     count++;
 923     tmp = tmp &~ -tmp;  // clear lowest bit
 924   }
 925
 926   TString hnTitle(name);
 927   const Int_t dim = count;
 928   Int_t nbins[dim];
 929   Double_t xmin[dim];
 930   Double_t xmax[dim];
 931
 932   Int_t i=0;
 933   Int_t c=0;
 934   while(c<dim && i<32){
 935     if(entries&(1<<i)){
 936
 937       TString label("");
 938       GetDimParamsHF(i, label, nbins[c], xmin[c], xmax[c]);
 939       hnTitle += Form(";%s",label.Data());
 940       c++;
 941     }
 942
 943     i++;
 944   }
 945   hnTitle += ";";
 946
 947   return new THnSparseD(name, hnTitle.Data(), dim, nbins, xmin, xmax);
 948 } // end of NewTHnSparseF PID
 949
 950 THnSparse* AliAnalysisTaskEmcalJetHF::NewTHnSparseDJetQA(const char* name, UInt_t entries)
 951 {
 952   // generate new THnSparseD JetQA, axes are defined in GetDimParamsJetQA()
 953   Int_t count = 0;
 954   UInt_t tmp = entries;
 955   while(tmp!=0){
 956     count++;
 957     tmp = tmp &~ -tmp;  // clear lowest bit
 958   }
 959
 960   TString hnTitle(name);
 961   const Int_t dim = count;
 962   Int_t nbins[dim];
 963   Double_t xmin[dim];
 964   Double_t xmax[dim];
 965
 966   Int_t i=0;
 967   Int_t c=0;
 968   while(c<dim && i<32){
 969     if(entries&(1<<i)){
 970
 971       TString label("");
 972       GetDimParamsJetQA(i, label, nbins[c], xmin[c], xmax[c]);
 973       hnTitle += Form(";%s",label.Data());
 974       c++;
 975     }
 976
 977     i++;
 978   }
 979   hnTitle += ";";
 980
 981   return new THnSparseD(name, hnTitle.Data(), dim, nbins, xmin, xmax);
 982 } // end of NewTHnSparseF JetQA
 983
 984
 985 void AliAnalysisTaskEmcalJetHF::GetDimParamsHF(Int_t iEntry, TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax)
 986 {
 987   // stores label and binning of axis for THnSparse
 988   const Double_t pi = TMath::Pi();
 989
 990   switch(iEntry){
 991
 992   case 0:
 993     label = "V0 centrality (%)";
 994     nbins = 10;
 995     xmin = 0.;
 996     xmax = 100.;
 997     break;
 998
 999   case 1:
1000     label = "Track p_{T}";
1001     nbins = 300;
1002     xmin = 0.;
1003     xmax = 75.;
1004     break;
1005
1006   case 2:
1007     label = "Track p";
1008     nbins = 300;
1009     xmin = 0.;
1010     xmax = 75.;
1011     break;
1012
1013   case 3:
1014     label = "Track Eta";
1015     nbins = 48;
1016     xmin = -1.2;
1017     xmax = 1.2;
1018     break;
1019
1020   case 4:
1021     label = "Track Phi";
1022     nbins = 72;
1023     xmin = 0;
1024     xmax = 2*pi;
1025     break;
1026
1027   case 5:
1028     label = "E/p of track";
1029     nbins = 400;
1030     xmin = 0;
1031     xmax = 4.0;
1032     break;
1033
1034  case 6:
1035     label = "DCA xy";
1036     nbins = 20;
1037     xmin = -10;
1038     xmax =  10;
1039     break;
1040
1041   case 7:
1042     label = "DCA z";
1043     nbins = 20;
1044     xmin = -10;
1045     xmax = 10;
1046     break;
1047
1048   case 8:
1049     label = "dEdX of track - TPC";
1050     nbins = 300;
1051     xmin = 0;
1052     xmax = 300;
1053     break;
1054
1055   case 9:
1056     label = "nSigma electron TPC";
1057     nbins = 50;
1058     xmin = -5;
1059     xmax = 5;
1060     break;
1061
1062    case 10:
1063     label = "nSigma electron TOF";
1064     nbins = 50;
1065     xmin = -5;
1066     xmax = 5;
1067     break;
1068
1069    case 11:
1070     label = "nSigma electron Emcal";
1071     nbins = 50;
1072     xmin = -5;
1073     xmax = 5;
1074     break;
1075
1076   case 12:
1077     label = "Jet pT";
1078     nbins = 40;
1079     xmin  = 0;
1080     xmax  = 200;
1081     break;
1082
1083   case 13:
1084     label = "Jet Phi";
1085     nbins = 72;
1086     xmin = 0;
1087     xmax = 2*pi;
1088     break;
1089
1090   case 14:
1091     label = "Jet Eta";
1092     nbins = 24;
1093     xmin = -1.2;
1094     xmax = 1.2;
1095     break;
1096
1097   case 15:
1098     label = "Cluster Energy";
1099     nbins = 150;
1100     xmin = 0;
1101     xmax = 15;
1102     break;
1103
1104   case 16:
1105     label = "Cluster Eta";
1106     nbins = 24;
1107     xmin = -1.2;
1108     xmax =  1.2;
1109     break;
1110
1111   case 17:
1112     label = "Cluster Phi";
1113     nbins = 72;
1114     xmin = 0;
1115     xmax = 2*pi;
1116     break;
1117
1118
1119
1120   } // end of switch
1121 } // end of getting dim-params
1122
1123 void AliAnalysisTaskEmcalJetHF::GetDimParamsJetQA(Int_t iEntry, TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax)
1124 {
1125   // stores label and binning of axis for THnSparse
1126   const Double_t pi = TMath::Pi();
1127
1128   switch(iEntry){
1129
1130     case 0:
1131       label = "number of Jets in Event";
1132       nbins = 100;
1133       xmin = 0.;
1134       xmax = 100.;
1135       break;
1136
1137     case 1:
1138       label = "number of Clusters in a Jet";
1139       nbins = 100;
1140       xmin = 0.;
1141       xmax = 100.;
1142       break;
1143
1144     case 2:
1145       label = "number of Tracks in a Jet";
1146       nbins = 100;
1147       xmin = 0.;
1148       xmax = 100.;
1149       break;
1150
1151     case 3:
1152       label = "Jet Eta";
1153       nbins = 24;
1154       xmin = -1.2;
1155       xmax = 1.2;
1156       break;
1157
1158     case 4:
1159       label = "Jet Phi";
1160       nbins = 72;
1161       xmin = 0;
1162       xmax = 2*pi;
1163       break;
1164
1165     case 5:
1166       label = "Cluster Energy";
1167       nbins = 150;
1168       xmin = 0;
1169       xmax = 15;
1170       break;
1171
1172     case 6:
1173       label = "Cluster Eta";
1174       nbins = 24;
1175       xmin = -1.2;
1176       xmax =  1.2;
1177       break;
1178
1179     case 7:
1180       label = "Cluster Phi";
1181       nbins = 72;
1182       xmin = 0;
1183       xmax = 2*pi;
1184       break;
1185
1186     case 8:
1187       label = "Is EMCalCluster";
1188       nbins = 2;
1189       xmin = 0;
1190       xmax = 2;
1191       break;
1192
1193     case 9:
1194       label = "Number of Matched Tracks to Cluster";
1195       nbins = 60;
1196       xmin = 0;
1197       xmax = 60;
1198       break;
1199
1200     case 10:
1201       label = "Track Pt";
1202       nbins = 300;
1203       xmin = 0;
1204       xmax = 75;
1205       break;
1206
1207     case 11:
1208       label = "Track Eta";
1209       nbins = 24;
1210       xmin = -1.2;
1211       xmax = 1.2;
1212       break;
1213
1214     case 12:
1215       label= "Track Phi";
1216       nbins = 72;
1217       xmin = 0;
1218       xmax = 2*pi;
1219       break;
1220
1221     case 13:
1222       label="Is Track EMCal";
1223       nbins = 2;
1224       xmin = 0;
1225       xmax = 2;
1226       break;
1227
1228     case 14:
1229       label = "Get Track EMCal Cluster";
1230       nbins = 100;
1231       xmin = 0;
1232       xmax = 100;
1233       break;
1234
1235     case 15:
1236       label = "Track Matched Phi";
1237       nbins = 72;
1238       xmin = 0;
1239       xmax = 2*pi;
1240
1241
1242
1243
1244   } // end of switch
1245 } // end of getting dim-params
1246
1247
1248