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