]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetHF.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' of https://git.cern.ch/reps/AliRoot
[u/mrichter/AliRoot.git] / PWGJE / FlavourJetTasks / AliAnalysisTaskEmcalJetHF.cxx
CommitLineData
5e5a2b89 1//
91b7e743 2// Author: A Castro (UTK)
3// Last Modified: August 11, 2014
5e5a2b89 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"
91b7e743 36#include "AliLog.h"
37#include "AliJetContainer.h"
38#include "AliParticleContainer.h"
39#include "AliClusterContainer.h"
5e5a2b89 40#include "AliEmcalParticle.h"
91b7e743 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"
5e5a2b89 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"
91b7e743 55#include "AliAODTrack.h"
56#include "AliESDtrack.h"
5e5a2b89 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
70ClassImp(AliAnalysisTaskEmcalJetHF)
71
72//________________________________________________________________________
73AliAnalysisTaskEmcalJetHF::AliAnalysisTaskEmcalJetHF() :
74 AliAnalysisTaskEmcalJet("heavyF",kFALSE),
75 event(0),
76 fillHist(0),
91b7e743 77 fEventTrigEMCALL1Gamma1(0),
78 fEventTrigEMCALL1Gamma2(0),
79 fGlobalQA(0),
80 fInputEvent(0x0),
5e5a2b89 81 fCuts(0),
47d82e4b 82 fPhimin(-10), fPhimax(10),
83 fEtamin(-0.9), fEtamax(0.9),
84 fAreacut(0.0),
91b7e743 85 fJetHIpt(20.0),
5e5a2b89 86 fTrackPtCut(2.0),
87 fTrackEta(0.9),
08f52641 88 fTrkQAcut(0),
91b7e743 89 fesdTrackCuts(0),
5e5a2b89 90 fPIDResponse(0x0), fTPCResponse(),
91 fEsdtrackCutsITSTPC(),
92 fEsdtrackCutsTPC(),
93 fEsdtrackCutsITS(),
91b7e743 94 fJetsCont(0), fTracksCont(0), fCaloClustersCont(0), fTracksJetCont(0), fCaloClustersJetCont(0),
5e5a2b89 95 fESD(0), fAOD(0),
96 fHistRhovsCent(0),
97 fHistJetPhi(0),
98 fHistCorJetPt(0), fHistJetPt(0),
91b7e743 99 fHistHighJetPt(0),
5e5a2b89 100 fHistnSigElecPt(0),
5e5a2b89 101 fHistnJetTrackvnJetClusters(0),
91b7e743 102 fHistPtDEtaDPhiTrackClus(0),
103 fHistPtDEtaDPhiClusTrack(0),
104 fhnPIDHF(0x0), fhnJetQA(0x0), fhnClusterTrackQA(0x0), fhnTrackClusterQA(0x0), fhnPIDHFTtoC(0x0)
5e5a2b89 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//________________________________________________________________________
121AliAnalysisTaskEmcalJetHF::AliAnalysisTaskEmcalJetHF(const char *name) :
122 AliAnalysisTaskEmcalJet(name,kTRUE),
123 event(0),
124 fillHist(0),
91b7e743 125 fEventTrigEMCALL1Gamma1(0),
126 fEventTrigEMCALL1Gamma2(0),
127 fGlobalQA(0),
128 fInputEvent(0x0),
5e5a2b89 129 fCuts(0),
47d82e4b 130 fPhimin(-10), fPhimax(10),
131 fEtamin(-0.9), fEtamax(0.9),
132 fAreacut(0.0),
91b7e743 133 fJetHIpt(20.0),
5e5a2b89 134 fTrackPtCut(2.0),
135 fTrackEta(0.9),
08f52641 136 fTrkQAcut(0),
91b7e743 137 fesdTrackCuts(0),
5e5a2b89 138 fPIDResponse(0x0), fTPCResponse(),
139 fEsdtrackCutsITSTPC(),
140 fEsdtrackCutsTPC(),
141 fEsdtrackCutsITS(),
91b7e743 142 fJetsCont(0), fTracksCont(0), fCaloClustersCont(0), fTracksJetCont(0), fCaloClustersJetCont(0),
5e5a2b89 143 fESD(0), fAOD(0),
144 fHistRhovsCent(0),
145 fHistJetPhi(0),
146 fHistCorJetPt(0), fHistJetPt(0),
91b7e743 147 fHistHighJetPt(0),
5e5a2b89 148 fHistnSigElecPt(0),
5e5a2b89 149 fHistnJetTrackvnJetClusters(0),
91b7e743 150 fHistPtDEtaDPhiTrackClus(0),
151 fHistPtDEtaDPhiClusTrack(0),
152 fhnPIDHF(0x0), fhnJetQA(0x0), fhnClusterTrackQA(0x0), fhnTrackClusterQA(0x0), fhnPIDHFTtoC(0x0)
5e5a2b89 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//_______________________________________________________________________
169AliAnalysisTaskEmcalJetHF::~AliAnalysisTaskEmcalJetHF()
170{
171 // destructor
172 //
173 if (fOutput) {
174 delete fOutput;
175 fOutput = 0;
176 }
177}
178
179//________________________________________________________________________
180void AliAnalysisTaskEmcalJetHF::UserCreateOutputObjects()
181{
182 if (! fCreateHisto)
183 return;
184 AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
185
91b7e743 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}
195fTracksCont->SetClassName("AliVTrack");
196fCaloClustersCont->SetClassName("AliVCluster");
5e5a2b89 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;
91b7e743 204 TString histname;
5e5a2b89 205
5e5a2b89 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);
5e5a2b89 209 fHistnSigElecPt = new TH2F("nsig_v_pt(TPC)","nsig_v_pt(TPC)",200,0,100,100,-10,10);
5e5a2b89 210 fHistnJetTrackvnJetClusters = new TH2F("NumbJetTracksvJetClusters","NumbJetTracksvJetClusters",21,0,20,21,0,20);
91b7e743 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
5e5a2b89 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);
5e5a2b89 261 fOutput->Add(fHistnSigElecPt);
5e5a2b89 262 fOutput->Add(fHistnJetTrackvnJetClusters);
91b7e743 263 fOutput->Add(fHistHighJetPt);
5e5a2b89 264 }//Fill Histograms
265
5e5a2b89 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");
91b7e743 272 return;
5e5a2b89 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");
91b7e743 281 return;
5e5a2b89 282 }
08f52641 283 // ****************************************************************************************
284 UInt_t bitcoded = 0; // bit coded, see GetDimParamsPID() below
91b7e743 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);
08f52641 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
91b7e743 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);
08f52641 295
296 UInt_t bitcoded3 = 0; // bit coded, see GetDimParamsPID() below
91b7e743 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);
08f52641 303
5e5a2b89 304 cout << "_______________Created Sparse__________________" << endl;
08f52641 305
5e5a2b89 306 fOutput->Add(fhnPIDHF);
08f52641 307 fOutput->Add(fhnJetQA);
91b7e743 308 fOutput->Add(fhnClusterTrackQA);
309 fOutput->Add(fhnTrackClusterQA);
310 fOutput->Add(fhnPIDHFTtoC);
5e5a2b89 311
312 PostData(1, fOutput);
91b7e743 313
5e5a2b89 314}
315
316//________________________________________________________
317void AliAnalysisTaskEmcalJetHF::ExecOnce()
318{
91b7e743 319 // Initialize the analysis
5e5a2b89 320 AliAnalysisTaskEmcalJet::ExecOnce();
91b7e743 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
5e5a2b89 326
327} // end of ExecOnce
328
329//________________________________________________________________________
330Bool_t AliAnalysisTaskEmcalJetHF::Run()
331{
332 // check to see if we have any tracks
333 if (!fTracks) return kTRUE;
334 if (!fJets) return kTRUE;
91b7e743 335
08f52641 336 // what kind of event do we have: AOD or ESD?
47d82e4b 337 Bool_t useAOD;
08f52641 338 if (dynamic_cast<AliAODEvent*>(InputEvent())) useAOD = kTRUE;
339 else useAOD = kFALSE;
340
91b7e743 341 fEventTrigEMCALL1Gamma1 = kFALSE;
342 fEventTrigEMCALL1Gamma2 = kFALSE;
343
08f52641 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;
5e5a2b89 350 }
5e5a2b89 351 }
91b7e743 352
5e5a2b89 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 }
5e5a2b89 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;
91b7e743 394 //TClonesArray *tracks = 0;
395 //TClonesArray *clusters = 0;
396 //TClonesArray * clusterList = 0;
397
5e5a2b89 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;
91b7e743 403 } // verify existence of jets
08f52641 404
91b7e743 405 event++;
406 //cout<<"Event #: "<<event<<" Number of Clusters: "<<fCaloClustersCont->GetNClusters()<<" Number of Tracks: "<<fTracksCont->GetNParticles()<<endl;
08f52641 407
91b7e743 408 // Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
47d82e4b 409
47d82e4b 410
5e5a2b89 411 // get number of jets and tracks
412 const Int_t Njets = jets->GetEntries();
5e5a2b89 413 if(Njets<1) return kTRUE;
47d82e4b 414
91b7e743 415 if (fTracksCont) {
416 AliVTrack *track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle(0));
417 while(track) {
418 track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
5e5a2b89 419 }
91b7e743 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();
5e5a2b89 427 }
91b7e743 428 }
08f52641 429
47d82e4b 430 // Start Jet Analysis
5e5a2b89 431 // initialize jet parameters
432 Int_t ijethi=-1;
433 Double_t highestjetpt=0.0;
91b7e743 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;
5e5a2b89 443
08f52641 444
91b7e743 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;
08f52641 462
91b7e743 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;
5e5a2b89 467
91b7e743 468 //AliEmcalJet::EFlavourTag tag=AliEmcalJet::kDStar;
469 //jet->AddFlavourTag(tag);
47d82e4b 470
0d436d87 471 //MV: removed to avoid compiler warnings
472 // Bool_t bkgrnd1 = kFALSE;
473 // Bool_t sig1 = kFALSE;
91b7e743 474
475 Int_t JetClusters = jet->GetNumberOfClusters();
476 Int_t JetTracks = jet -> GetNumberOfTracks();
477 fHistnJetTrackvnJetClusters->Fill(JetClusters,JetTracks);
5e5a2b89 478 // Initializations and Calculations
5e5a2b89 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
91b7e743 484 fHistCorJetPt->Fill(jetPt);
485
47d82e4b 486 if(jet->Pt() > fJetHIpt) {
91b7e743 487 if(!fTracksCont || !fCaloClustersCont) return kTRUE;
5e5a2b89 488
91b7e743 489 Double_t dEdx = -99;
490 Double_t EovP = -99;
491 Float_t DCAxy = -999;
492 Float_t DCAz = -999;
5e5a2b89 493
91b7e743 494 Double_t deta = 999;
495 Double_t dphi = 999;
496 Int_t NumbCluster = -999;
497 NumbCluster = fCaloClustersCont->GetNClusters();
f53815f2 498 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()};
91b7e743 499 fhnJetQA->Fill(JetQA);
08f52641 500
91b7e743 501 //***********************************************
502 //****************Track Matched to Closest Cluster
5e5a2b89 503
5e5a2b89 504
91b7e743 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
5e5a2b89 519 Float_t pos[3];
91b7e743 520 cluster->GetPosition(pos); // Get cluster position
5e5a2b89 521 TVector3 cp(pos);
91b7e743 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) {
5e5a2b89 529
91b7e743 530 //mt = static_cast<AliVTrack*>(acl->GetTrackMatched(0));
531 }
532 else {
08f52641 533
91b7e743 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;
5e5a2b89 541
91b7e743 542 ESDmt = static_cast<AliESDtrack*>(mt);
543 if(!ESDmt) continue;
5e5a2b89 544
91b7e743 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);
5e5a2b89 559 EovP = fclusE/p;
91b7e743 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 }
08f52641 567
91b7e743 568 if(mt) {
569 AliPicoTrack::GetEtaPhiDiff(mt, cluster, dphi, deta);
570 fHistPtDEtaDPhiClusTrack->Fill(nPart.Pt(),deta,dphi);
571
572
573
574 }
5e5a2b89 575
91b7e743 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 //**************************************************************
5e5a2b89 610
91b7e743 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
5e5a2b89 650
91b7e743 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;
0d436d87 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 // }
91b7e743 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 */
5e5a2b89 699 } // LOOP over JETS in event
700
91b7e743 701
702
703 if(fGlobalQA == 1) CheckClusTrackMatchingQA();
704
5e5a2b89 705 return kTRUE;
91b7e743 706
5e5a2b89 707}
708//________________________________________________________________________
709void AliAnalysisTaskEmcalJetHF::Terminate(Option_t *)
710{
711 cout<<"###########################"<<endl;
712 cout<<"#### Task Finished ####"<<endl;
713 cout<<"###########################"<<endl;
714 cout<<"###########################"<<endl;
715} // end of terminate
716
91b7e743 717
718//________________________________________________________________________
719void 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
47d82e4b 865//________________________________________________________________________
866Int_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
5e5a2b89 880//________________________________________________________________________
881Int_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;
91b7e743 898}
899
900//________________________________________________________________________________
901/*
902void 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//____________________________________________________________________________________________
5e5a2b89 913THnSparse* 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);
08f52641 945} // end of NewTHnSparseF PID
946
947THnSparse* 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
5e5a2b89 981
982void 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}";
91b7e743 998 nbins = 300;
5e5a2b89 999 xmin = 0.;
1000 xmax = 75.;
1001 break;
1002
1003 case 2:
1004 label = "Track p";
91b7e743 1005 nbins = 300;
5e5a2b89 1006 xmin = 0.;
1007 xmax = 75.;
1008 break;
1009
1010 case 3:
1011 label = "Track Eta";
91b7e743 1012 nbins = 48;
1013 xmin = -1.2;
1014 xmax = 1.2;
5e5a2b89 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;
91b7e743 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
5e5a2b89 1115
1116
91b7e743 1117 } // end of switch
08f52641 1118} // end of getting dim-params
1119
1120void 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";
91b7e743 1129 nbins = 100;
08f52641 1130 xmin = 0.;
91b7e743 1131 xmax = 100.;
08f52641 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";
91b7e743 1164 nbins = 150;
08f52641 1165 xmin = 0;
91b7e743 1166 xmax = 15;
08f52641 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";
91b7e743 1199 nbins = 300;
08f52641 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
5e5a2b89 1244
1245