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       Bool_t bkgrnd1  = kFALSE;
 472       Bool_t sig1     = kFALSE;
 473
 474       Int_t JetClusters = jet->GetNumberOfClusters();
 475       Int_t JetTracks = jet -> GetNumberOfTracks();
 476       fHistnJetTrackvnJetClusters->Fill(JetClusters,JetTracks);
 477      // Initializations and Calculations
 478      Double_t jetptraw = jet->Pt();                             // raw pT of jet
 479      Double_t jetPt = -500;                                     // initialize corr jet pt LOCAL
 480      Double_t jetarea = -500;                                   // initialize jet area
 481      jetarea = jet->Area();                                     // jet area
 482      jetPt = jet->Pt() - jetarea*fRhoVal;                 // semi-corrected pT of jet from GLOBAL rho value
 483       fHistCorJetPt->Fill(jetPt);
 484
 485       if(jet->Pt() > fJetHIpt) {
 486         if(!fTracksCont || !fCaloClustersCont) return kTRUE;
 487
 488         Double_t dEdx = -99;
 489         Double_t EovP = -99;
 490         Float_t DCAxy = -999;
 491         Float_t DCAz = -999;
 492
 493         Double_t deta = 999;
 494         Double_t dphi = 999;
 495         Int_t NumbCluster = -999;
 496         NumbCluster = fCaloClustersCont->GetNClusters();
 497         Double_t JetQA[5] = {Njets, jet->GetNumberOfTracks(), jet->GetNumberOfClusters(),jet->Eta(), jet->Phi()};
 498         fhnJetQA->Fill(JetQA);
 499
 500       //***********************************************
 501       //****************Track Matched to Closest Cluster
 502
 503
 504        for(int iCluster = 0; iCluster <= NumbCluster; iCluster++){
 505           //Get closest track to cluster to track matching!!!!!
 506           //AliVCluster *cluster = fCaloClustersCont->GetNextAcceptedCluster(iCluster);
 507           AliVCluster *cluster = fCaloClustersCont->GetCluster(iCluster);
 508
 509           if(! IsJetCluster(jet, iCluster, kFALSE)) continue;
 510
 511           // while(cluster) {
 512           TLorentzVector nPart;
 513           cluster->GetMomentum(nPart, fVertex);
 514           //fHistClustersPt[fCentBin]->Fill(nPart.Pt());
 515           Double_t fclusE = -999;
 516           fclusE = cluster->E();
 517
 518           Float_t pos[3];
 519           cluster->GetPosition(pos);  // Get cluster position
 520           TVector3 cp(pos);
 521
 522           //Get matched track
 523           AliVTrack *mt = NULL;
 524           //AliESDtrack *mt = NULL;
 525           AliESDtrack *ESDmt = NULL;
 526           AliAODCaloCluster *acl = dynamic_cast<AliAODCaloCluster*>(cluster);
 527           if(acl) {
 528
 529             //mt = static_cast<AliVTrack*>(acl->GetTrackMatched(0));
 530           }
 531           else {
 532
 533             AliESDCaloCluster *ecl = dynamic_cast<AliESDCaloCluster*>(cluster);
 534             Int_t im = ecl->GetTrackMatchedIndex();
 535
 536             if(fTracksCont && im>=0) {
 537               //mt = static_cast<AliVTrack*>(fTracksCont->GetParticle(im));
 538               mt = static_cast<AliVTrack*>(fTracksCont->GetParticle(im));
 539               if(!mt) continue;
 540
 541               ESDmt = static_cast<AliESDtrack*>(mt);
 542               if(!ESDmt) continue;
 543
 544               Double_t pcluster = mt->P();
 545               //Double_t esdp = ESDmt->P();
 546               //Int_t LabelNumb, IDNumb;
 547               //LabelNumb = ESDmt->GetLabel();
 548               //IDNumb= ESDmt -> GetID();
 549
 550               dEdx = mt->GetTPCsignal();
 551               Double_t p = mt->P();
 552                //TPC nSigma's
 553               //nsigpion = fPIDResponse->NumberOfSigmasTPC(mt,AliPID::kPion);
 554               Double_t nSigmaElectron_TPC = fPIDResponse->NumberOfSigmasTPC(mt,AliPID::kElectron);
 555               Double_t nSigmaElectron_TOF = fPIDResponse->NumberOfSigmasTOF(mt,AliPID::kElectron);
 556               dEdx = mt->GetTPCsignal();
 557               ESDmt->GetImpactParameters(DCAxy, DCAz);
 558               EovP        = fclusE/p;
 559                 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()};
 560                 fhnPIDHF->Fill(HF_tracks);    // fill Sparse Histo with trigger entries
 561
 562
 563
 564             }
 565           }
 566
 567           if(mt) {
 568             AliPicoTrack::GetEtaPhiDiff(mt, cluster, dphi, deta);
 569             fHistPtDEtaDPhiClusTrack->Fill(nPart.Pt(),deta,dphi);
 570
 571
 572
 573           }
 574
 575           //cluster = fCaloClustersCont->GetNextAcceptCluster();
 576           //if(! IsJetCluster(jet, cluster, kFALSE)) continue;
 577         //}
 578
 579           /*
 580            Double_t p = mt->P();
 581            Float_t pos[3];
 582            cluster->GetPosition(pos);  // Get cluster position
 583            //AliESDtrack *trackESD = fESD->GetTrack(Ntracks);
 584
 585            //  nSigmaElectron_TPC = fPIDResponse->NumberOfSigmasTPC(mt,AliPID::kElectron);
 586            //  nSigmaElectron_TOF= fPIDResponse->NumberOfSigmasTOF(mt,AliPID::kElectron);
 587            EovP        = fclusE/p;
 588            TVector3 cp(pos);
 589
 590            //if(!fesdTrackCuts->AcceptTrack(mt)) continue;
 591            //dEdx = mt->GetTPCsignal();
 592            //mt->GetImpactParameters(DCAxy, DCAz);
 593            //nSigmaElectron_TPC = fPIDResponse->NumberOfSigmasTPC(trackESD,AliPID::kElectron);
 594            //nSigmaElectron_TOF = fPIDResponse->NumberOfSigmasTOF(trackESD,AliPID::kElectron);
 595
 596
 597            //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()};
 598            //fhnPIDHF->Fill(HF_tracks);    // fill Sparse Histo with trigger entries
 599            */
 600           //cluster = fCaloClustersCont->GetNextAcceptCluster();
 601           //if(! IsJetCluster(jet, cluster, kFALSE)) continue;
 602
 603
 604           //AliESDtrack *ESDacceptedTrack = NULL;
 605         }//loop over cluster
 606
 607       //******************************Cluster Matched To Closest Track
 608       //**************************************************************
 609
 610
 611       Int_t NumbTrackContainer = -999;
 612       NumbTrackContainer = fTracksCont->GetNParticles();
 613       for(int iTracks = 0; iTracks <= NumbTrackContainer; iTracks++){
 614         AliVTrack *AcceptedTrack =static_cast<AliVTrack*>(fTracksCont->GetParticle(iTracks));
 615         if(!AcceptedTrack){
 616           AliError(Form("Couldn't get AliVTrack Container %d\n", iTracks));
 617           continue;
 618         }
 619         if(!IsJetTrack(jet,iTracks,kFALSE))continue;
 620         //Get matched cluster
 621         Int_t emc1 = AcceptedTrack->GetEMCALcluster();
 622
 623         Double_t acceptTrackP = AcceptedTrack->P();
 624         Double_t acceptTrackPt = AcceptedTrack->Pt();
 625         Double_t acceptTrackEta = AcceptedTrack->Eta();
 626         Double_t acceptTrackPhi = AcceptedTrack->Phi();
 627         Double_t nSigmaElectron_TPC_at = fPIDResponse->NumberOfSigmasTPC(AcceptedTrack,AliPID::kElectron);
 628         Double_t nSigmaElectron_TOF_at = fPIDResponse->NumberOfSigmasTOF(AcceptedTrack,AliPID::kElectron);
 629
 630
 631         AliESDtrack *ESDacceptedTrack = static_cast<AliESDtrack*>(AcceptedTrack);
 632
 633         if(!ESDacceptedTrack){
 634           AliError(Form("Couldn't get AliESDTrack %d\n", iTracks));
 635           continue;
 636         }
 637         //Double_t DCAxy_at, DCAz_at;
 638         Double_t dEdxat = AcceptedTrack->GetTPCsignal();
 639         //ESDacceptedTrack->GetImpactParameters(DCAxy_at, DCAz_at);
 640
 641
 642         if(fCaloClustersCont && emc1>=0) {
 643           AliVCluster *clusMatch = fCaloClustersCont->GetCluster(emc1);
 644           if(!clusMatch){
 645             AliError(Form("Couldn't get matched AliVCluster %d\n", emc1));
 646             continue;
 647           }
 648
 649
 650
 651           Double_t mClusterE = clusMatch->E();
 652           Float_t pos_mc[3];
 653           clusMatch->GetPosition(pos_mc);  // Get cluster position
 654           TVector3 mcp(pos_mc);
 655           Double_t EovP_mc = -999;
 656           EovP_mc = mClusterE/acceptTrackP;
 657           if(EovP_mc < 0.2){
 658             bkgrnd1 = kTRUE;      //Hadron Background
 659           }
 660           if(0.8 < EovP_mc < 1.2){
 661             if(-1.5<nSigmaElectron_TPC_at<5.0){
 662               if(4.0<acceptTrackPt<10.0){
 663                 sig1 = kTRUE;                    //Electron Candidate
 664               }
 665             }
 666           }
 667
 668           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()};
 669           fhnPIDHFTtoC->Fill(HF_tracks2);    // fill Sparse Histo with trigger entries
 670         }
 671         //AcceptedTrack = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
 672
 673       } //loop over tracks for matching to closest cluster
 674
 675
 676
 677
 678     } // highest pt jet cut
 679       /*
 680       Int_t tag = -999;
 681       if(bkgrnd1 == kTRUE) {
 682         AliEmcalJet::EFlavourTag tag=AliEmcalJet::kBckgrd1;
 683         jet->AddFlavourTag(tag);
 684       }
 685       if(sig1 == kTRUE && !bkgrnd1){
 686         AliEmcalJet::EFlavourTag tag=AliEmcalJet::kSig1;
 687         jet->AddFlavourTag(tag);
 688       }
 689        */
 690   } // LOOP over JETS in event
 691
 692
 693
 694   if(fGlobalQA == 1) CheckClusTrackMatchingQA();
 695
 696   return kTRUE;
 697
 698 }
 699 //________________________________________________________________________
 700 void AliAnalysisTaskEmcalJetHF::Terminate(Option_t *)
 701 {
 702   cout<<"###########################"<<endl;
 703   cout<<"####   Task Finished   ####"<<endl;
 704   cout<<"###########################"<<endl;
 705   cout<<"###########################"<<endl;
 706 } // end of terminate
 707
 708
 709 //________________________________________________________________________
 710 void AliAnalysisTaskEmcalJetHF::CheckClusTrackMatchingQA()
 711 {
 712
 713   if(!fTracksCont || !fCaloClustersCont) return;
 714
 715   Int_t trkcounter = 0;
 716   Int_t cluscounter = 0;
 717   Double_t deta = 999;
 718   Double_t dphi = 999;
 719
 720   //Get closest cluster to track
 721   AliVTrack *track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle(0));
 722   while(track) {
 723     //if(!track) continue;
 724     AliESDtrack *ESDtrackQA1 = static_cast<AliESDtrack*>(track);
 725     if(!ESDtrackQA1) continue;
 726     if(!fPIDResponse) continue;
 727     Double_t pQA1 = track->P();
 728     Double_t nSigmaElectron_TPC_QA1 = fPIDResponse->NumberOfSigmasTPC(ESDtrackQA1,AliPID::kElectron);
 729     Double_t nSigmaElectron_TOF_QA1 = fPIDResponse->NumberOfSigmasTOF(ESDtrackQA1,AliPID::kElectron);
 730     Double_t dEdxQA1 = ESDtrackQA1->GetTPCsignal();
 731     //Get matched cluster
 732     Int_t emc1 = track->GetEMCALcluster();
 733     if(fCaloClustersCont && emc1>=0) {
 734       AliVCluster *clusMatch = fCaloClustersCont->GetCluster(emc1);
 735       //if(!clusMatch) continue;
 736       if(clusMatch) {
 737         Double_t ClusterE_QA1 = clusMatch->E();
 738         Double_t EovPQA1 = ClusterE_QA1/pQA1;
 739         Float_t pos_mc1[3];
 740         clusMatch->GetPosition(pos_mc1);  // Get cluster position
 741         TVector3 mc1(pos_mc1);
 742         fHistnSigElecPt->Fill(nSigmaElectron_TPC_QA1,track->Pt());
 743         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()};
 744         fhnTrackClusterQA->Fill(HF_tracks3);
 745         AliPicoTrack::GetEtaPhiDiff(track, clusMatch, dphi, deta);
 746         fHistPtDEtaDPhiTrackClus->Fill(track->Pt(),deta,dphi);
 747         cluscounter++;
 748       }//clus matching
 749
 750      }//matched cluster
 751
 752     track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
 753     trkcounter++;
 754   }//track loop
 755  /*
 756   //Get closest track to cluster
 757   AliVCluster *cluster = fCaloClustersCont->GetNextAcceptCluster(0);
 758   while(cluster) {
 759     if(!cluster) continue;
 760
 761     Double_t ClusterE_QA2 = cluster->E();
 762     //Double_t EovPQA1 = ClusterE_QA1/pQA1;
 763     Float_t pos_mc2[3];
 764     cluster->GetPosition(pos_mc2);  // Get cluster position
 765     TVector3 mc2(pos_mc2);
 766
 767     TLorentzVector nPart;
 768     cluster->GetMomentum(nPart, fVertex);
 769
 770     //Get matched track
 771     AliVTrack *mt = NULL;
 772     AliAODCaloCluster *acl = dynamic_cast<AliAODCaloCluster*>(cluster);
 773     if(!acl) continue;
 774     if(acl) {
 775       if(acl->GetNTracksMatched()>1)
 776       mt = static_cast<AliVTrack*>(acl->GetTrackMatched(0));
 777       if(!mt) continue;
 778       AliESDtrack *ESDtrackQA2 = static_cast<AliESDtrack*>(mt);
 779       if(!ESDtrackQA2) continue;
 780       Double_t nSigmaElectron_TPC_QA2 = fPIDResponse->NumberOfSigmasTPC(ESDtrackQA1,AliPID::kElectron);
 781       Double_t nSigmaElectron_TOF_QA2 = fPIDResponse->NumberOfSigmasTOF(ESDtrackQA1,AliPID::kElectron);
 782       Double_t dEdxQA1 = ESDtrackQA2->GetTPCsignal();
 783       Double_t EovPQA2 = -999;
 784       Double_t pQA2 = mt->P();
 785       EovPQA2 = ClusterE_QA2/pQA2;
 786
 787       //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()};
 788       //fhnClusterTrackQA->Fill(HF_tracks4);
 789     }
 790     else {
 791       AliESDCaloCluster *ecl = dynamic_cast<AliESDCaloCluster*>(cluster);
 792       if(!ecl) continue;
 793       Int_t im = ecl->GetTrackMatchedIndex();
 794       if(fTracksCont && im>=0) {
 795         mt = static_cast<AliVTrack*>(fTracksCont->GetParticle(im));
 796         if(!mt) continue
 797       }
 798     }
 799     AliPicoTrack::GetEtaPhiDiff(mt, cluster, dphi, deta);
 800     fHistPtDEtaDPhiClusTrack->Fill(nPart.Pt(),deta,dphi);
 801     cluster = fCaloClustersCont->GetNextAcceptCluster();
 802   }
 803   }
 804 */
 805 /*
 806   //Get closest track to cluster
 807   AliVCluster *cluster = fCaloClustersCont->GetNextAcceptCluster(0);
 808   while(cluster) {
 809     if(!cluster){
 810       AliError(Form("Couldn't get CtoT AliCluster Container"));
 811       continue;
 812     }
 813     Double_t ClusterE_QA2 = cluster->E();
 814     Float_t pos_mc2[3];
 815     cluster->GetPosition(pos_mc2);  // Get cluster position
 816     TVector3 mc2(pos_mc2);
 817     TLorentzVector nPart;
 818     cluster->GetMomentum(nPart, fVertex);
 819     //Get matched track
 820     AliVTrack *mt = NULL;
 821     AliESDCaloCluster *ecl = dynamic_cast<AliESDCaloCluster*>(cluster);
 822     if(!ecl){
 823       AliError(Form("Couldn't get CtoT AliESDCluster Container %d\n"));
 824       continue;
 825     }
 826     Int_t im = ecl->GetTrackMatchedIndex();
 827     if(fTracksCont && im>=0) {
 828       //mt = static_cast<AliVTrack*>(fTracksCont->GetParticle(im));
 829       //if(!mt){
 830         //AliError(Form("Couldn't get CT AliVTrack Container %d\n",im));
 831         //continue;
 832      // }
 833       //AliPicoTrack::GetEtaPhiDiff(mt, cluster, dphi, deta);
 834       fHistPtDEtaDPhiClusTrack->Fill(nPart.Pt(),deta,dphi);
 835       AliESDtrack *ESDtrackQA2 = static_cast<AliESDtrack*>(mt);
 836       if(!ESDtrackQA2){
 837         AliError(Form("Couldn't get CT AliESDTrack Container %d\n"));
 838         continue;
 839       }
 840       Double_t nSigmaElectron_TPC_QA2 = fPIDResponse->NumberOfSigmasTPC(ESDtrackQA2,AliPID::kElectron);
 841       Double_t nSigmaElectron_TOF_QA2 = fPIDResponse->NumberOfSigmasTOF(ESDtrackQA2,AliPID::kElectron);
 842       Double_t dEdxQA1 = ESDtrackQA2->GetTPCsignal();
 843       Double_t EovPQA2 = -999;
 844       Double_t pQA2 = mt->P();
 845       EovPQA2 = ClusterE_QA2/pQA2;
 846
 847
 848     }
 849     //cluster = fCaloClustersCont->GetNextAcceptCluster();
 850     cluster = static_cast<AliVCluster*>(fCaloClustersCont->GetNextAcceptCluster());
 851   }
 852 */
 853 }
 854
 855
 856 //________________________________________________________________________
 857 Int_t AliAnalysisTaskEmcalJetHF::AcceptMyJet(AliEmcalJet *jet) {
 858   //applies all jet cuts except pt
 859   if ((jet->Phi()<fPhimin)||(jet->Phi()>fPhimax)) return 0;
 860   if ((jet->Eta()<fEtamin)||(jet->Eta()>fEtamax)) return 0;
 861   if (jet->Area()<fAreacut) return 0;
 862   // prevents 0 area jets from sneaking by when area cut == 0
 863   if (jet->Area()==0) return 0;
 864   //exclude jets with extremely high pt tracks which are likely misreconstructed
 865   if(jet->MaxTrackPt()>100) return 0;
 866
 867   //passed all above cuts
 868   return 1;
 869 }
 870
 871 //________________________________________________________________________
 872 Int_t AliAnalysisTaskEmcalJetHF::GetCentBin(Double_t cent) const
 873 {  // Get centrality bin.
 874
 875   Int_t centbin = -1;
 876   if (cent>=0 && cent<10)
 877     centbin = 0;
 878   else if (cent>=10 && cent<20)
 879     centbin = 1;
 880   else if (cent>=20 && cent<30)
 881     centbin = 2;
 882   else if (cent>=30 && cent<40)
 883     centbin = 3;
 884   else if (cent>=40 && cent<50)
 885     centbin = 4;
 886   else if (cent>=50 && cent<90)
 887     centbin = 5;
 888   return centbin;
 889 }
 890
 891 //________________________________________________________________________________
 892 /*
 893 void AliAnalysisTaskEmcalJetHF::FlagFlavour(AliEmcalJet *jet){
 894
 895   AliEmcalJet::EFlavourTag tag=AliEmcalJet::kDStar;
 896   if (fCandidateType==kD0toKpi) tag=AliEmcalJet::kD0;
 897   if (fIsDInJet) jet->AddFlavourTag(tag);
 898
 899   return;
 900
 901 }
 902 */
 903 //____________________________________________________________________________________________
 904 THnSparse* AliAnalysisTaskEmcalJetHF::NewTHnSparseDHF(const char* name, UInt_t entries)
 905 {
 906   // generate new THnSparseD PID, axes are defined in GetDimParams()
 907   Int_t count = 0;
 908   UInt_t tmp = entries;
 909   while(tmp!=0){
 910     count++;
 911     tmp = tmp &~ -tmp;  // clear lowest bit
 912   }
 913
 914   TString hnTitle(name);
 915   const Int_t dim = count;
 916   Int_t nbins[dim];
 917   Double_t xmin[dim];
 918   Double_t xmax[dim];
 919
 920   Int_t i=0;
 921   Int_t c=0;
 922   while(c<dim && i<32){
 923     if(entries&(1<<i)){
 924
 925       TString label("");
 926       GetDimParamsHF(i, label, nbins[c], xmin[c], xmax[c]);
 927       hnTitle += Form(";%s",label.Data());
 928       c++;
 929     }
 930
 931     i++;
 932   }
 933   hnTitle += ";";
 934
 935   return new THnSparseD(name, hnTitle.Data(), dim, nbins, xmin, xmax);
 936 } // end of NewTHnSparseF PID
 937
 938 THnSparse* AliAnalysisTaskEmcalJetHF::NewTHnSparseDJetQA(const char* name, UInt_t entries)
 939 {
 940   // generate new THnSparseD JetQA, axes are defined in GetDimParamsJetQA()
 941   Int_t count = 0;
 942   UInt_t tmp = entries;
 943   while(tmp!=0){
 944     count++;
 945     tmp = tmp &~ -tmp;  // clear lowest bit
 946   }
 947
 948   TString hnTitle(name);
 949   const Int_t dim = count;
 950   Int_t nbins[dim];
 951   Double_t xmin[dim];
 952   Double_t xmax[dim];
 953
 954   Int_t i=0;
 955   Int_t c=0;
 956   while(c<dim && i<32){
 957     if(entries&(1<<i)){
 958
 959       TString label("");
 960       GetDimParamsJetQA(i, label, nbins[c], xmin[c], xmax[c]);
 961       hnTitle += Form(";%s",label.Data());
 962       c++;
 963     }
 964
 965     i++;
 966   }
 967   hnTitle += ";";
 968
 969   return new THnSparseD(name, hnTitle.Data(), dim, nbins, xmin, xmax);
 970 } // end of NewTHnSparseF JetQA
 971
 972
 973 void AliAnalysisTaskEmcalJetHF::GetDimParamsHF(Int_t iEntry, TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax)
 974 {
 975   // stores label and binning of axis for THnSparse
 976   const Double_t pi = TMath::Pi();
 977
 978   switch(iEntry){
 979
 980   case 0:
 981     label = "V0 centrality (%)";
 982     nbins = 10;
 983     xmin = 0.;
 984     xmax = 100.;
 985     break;
 986
 987   case 1:
 988     label = "Track p_{T}";
 989     nbins = 300;
 990     xmin = 0.;
 991     xmax = 75.;
 992     break;
 993
 994   case 2:
 995     label = "Track p";
 996     nbins = 300;
 997     xmin = 0.;
 998     xmax = 75.;
 999     break;
1000
1001   case 3:
1002     label = "Track Eta";
1003     nbins = 48;
1004     xmin = -1.2;
1005     xmax = 1.2;
1006     break;
1007
1008   case 4:
1009     label = "Track Phi";
1010     nbins = 72;
1011     xmin = 0;
1012     xmax = 2*pi;
1013     break;
1014
1015   case 5:
1016     label = "E/p of track";
1017     nbins = 400;
1018     xmin = 0;
1019     xmax = 4.0;
1020     break;
1021
1022  case 6:
1023     label = "DCA xy";
1024     nbins = 20;
1025     xmin = -10;
1026     xmax =  10;
1027     break;
1028
1029   case 7:
1030     label = "DCA z";
1031     nbins = 20;
1032     xmin = -10;
1033     xmax = 10;
1034     break;
1035
1036   case 8:
1037     label = "dEdX of track - TPC";
1038     nbins = 300;
1039     xmin = 0;
1040     xmax = 300;
1041     break;
1042
1043   case 9:
1044     label = "nSigma electron TPC";
1045     nbins = 50;
1046     xmin = -5;
1047     xmax = 5;
1048     break;
1049
1050    case 10:
1051     label = "nSigma electron TOF";
1052     nbins = 50;
1053     xmin = -5;
1054     xmax = 5;
1055     break;
1056
1057    case 11:
1058     label = "nSigma electron Emcal";
1059     nbins = 50;
1060     xmin = -5;
1061     xmax = 5;
1062     break;
1063
1064   case 12:
1065     label = "Jet pT";
1066     nbins = 40;
1067     xmin  = 0;
1068     xmax  = 200;
1069     break;
1070
1071   case 13:
1072     label = "Jet Phi";
1073     nbins = 72;
1074     xmin = 0;
1075     xmax = 2*pi;
1076     break;
1077
1078   case 14:
1079     label = "Jet Eta";
1080     nbins = 24;
1081     xmin = -1.2;
1082     xmax = 1.2;
1083     break;
1084
1085   case 15:
1086     label = "Cluster Energy";
1087     nbins = 150;
1088     xmin = 0;
1089     xmax = 15;
1090     break;
1091
1092   case 16:
1093     label = "Cluster Eta";
1094     nbins = 24;
1095     xmin = -1.2;
1096     xmax =  1.2;
1097     break;
1098
1099   case 17:
1100     label = "Cluster Phi";
1101     nbins = 72;
1102     xmin = 0;
1103     xmax = 2*pi;
1104     break;
1105
1106
1107
1108   } // end of switch
1109 } // end of getting dim-params
1110
1111 void AliAnalysisTaskEmcalJetHF::GetDimParamsJetQA(Int_t iEntry, TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax)
1112 {
1113   // stores label and binning of axis for THnSparse
1114   const Double_t pi = TMath::Pi();
1115
1116   switch(iEntry){
1117
1118     case 0:
1119       label = "number of Jets in Event";
1120       nbins = 100;
1121       xmin = 0.;
1122       xmax = 100.;
1123       break;
1124
1125     case 1:
1126       label = "number of Clusters in a Jet";
1127       nbins = 100;
1128       xmin = 0.;
1129       xmax = 100.;
1130       break;
1131
1132     case 2:
1133       label = "number of Tracks in a Jet";
1134       nbins = 100;
1135       xmin = 0.;
1136       xmax = 100.;
1137       break;
1138
1139     case 3:
1140       label = "Jet Eta";
1141       nbins = 24;
1142       xmin = -1.2;
1143       xmax = 1.2;
1144       break;
1145
1146     case 4:
1147       label = "Jet Phi";
1148       nbins = 72;
1149       xmin = 0;
1150       xmax = 2*pi;
1151       break;
1152
1153     case 5:
1154       label = "Cluster Energy";
1155       nbins = 150;
1156       xmin = 0;
1157       xmax = 15;
1158       break;
1159
1160     case 6:
1161       label = "Cluster Eta";
1162       nbins = 24;
1163       xmin = -1.2;
1164       xmax =  1.2;
1165       break;
1166
1167     case 7:
1168       label = "Cluster Phi";
1169       nbins = 72;
1170       xmin = 0;
1171       xmax = 2*pi;
1172       break;
1173
1174     case 8:
1175       label = "Is EMCalCluster";
1176       nbins = 2;
1177       xmin = 0;
1178       xmax = 2;
1179       break;
1180
1181     case 9:
1182       label = "Number of Matched Tracks to Cluster";
1183       nbins = 60;
1184       xmin = 0;
1185       xmax = 60;
1186       break;
1187
1188     case 10:
1189       label = "Track Pt";
1190       nbins = 300;
1191       xmin = 0;
1192       xmax = 75;
1193       break;
1194
1195     case 11:
1196       label = "Track Eta";
1197       nbins = 24;
1198       xmin = -1.2;
1199       xmax = 1.2;
1200       break;
1201
1202     case 12:
1203       label= "Track Phi";
1204       nbins = 72;
1205       xmin = 0;
1206       xmax = 2*pi;
1207       break;
1208
1209     case 13:
1210       label="Is Track EMCal";
1211       nbins = 2;
1212       xmin = 0;
1213       xmax = 2;
1214       break;
1215
1216     case 14:
1217       label = "Get Track EMCal Cluster";
1218       nbins = 100;
1219       xmin = 0;
1220       xmax = 100;
1221       break;
1222
1223     case 15:
1224       label = "Track Matched Phi";
1225       nbins = 72;
1226       xmin = 0;
1227       xmax = 2*pi;
1228
1229
1230
1231
1232   } // end of switch
1233 } // end of getting dim-params
1234
1235
1236