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