]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetHMEC.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
changes from mconnors
[u/mrichter/AliRoot.git] / PWGGA / EMCALJetTasks / UserTasks / AliAnalysisTaskEmcalJetHMEC.cxx
CommitLineData
7f71d351 1// $Id$
5b38fc6d 2
1af24178 3//////////
4//Measure Jet-hadron correlations
5//Does event Mixing using AliEventPoolManager
6/////////
7
5b38fc6d 8#include "AliAnalysisTaskEmcalJetHMEC.h"
9
1101e468 10#include "TChain.h"
11#include "TTree.h"
12#include "TList.h"
13#include "TH1F.h"
14#include "TH2F.h"
15#include "THnSparse.h"
16#include "TCanvas.h"
17#include <TClonesArray.h>
18#include <TParticle.h>
19#include "AliVTrack.h"
20#include "TParameter.h"
21
22#include "AliAODEvent.h"
23#include "AliAnalysisTask.h"
24#include "AliAnalysisManager.h"
25
26#include "AliESDEvent.h"
27#include "AliESDInputHandler.h"
28#include "AliESDCaloCluster.h"
29#include "AliESDVertex.h"
30#include "AliCentrality.h"
31#include "AliAODJet.h"
32#include "AliEmcalJet.h"
33#include "AliESDtrackCuts.h"
1101e468 34
5b38fc6d 35#include "TVector3.h"
36#include "AliPicoTrack.h"
55f64c2f 37#include "AliEventPoolManager.h"
5b38fc6d 38
1101e468 39ClassImp(AliAnalysisTaskEmcalJetHMEC)
40
41//________________________________________________________________________
42AliAnalysisTaskEmcalJetHMEC::AliAnalysisTaskEmcalJetHMEC() :
43 AliAnalysisTaskSE(),
44 fTracksName("tracks"),
45 fJetsName("jets"),
46 fPhimin(-10),
47 fPhimax(10),
48 fEtamin(-0.9),
49 fEtamax(0.9),
50 fAreacut(0.0),
1af24178 51 fDoEventMixing(0),
52 fMixingTracks(50000),
1101e468 53 fESD(0),
55f64c2f 54 fPoolMgr(0x0),
55 fOutputList(0),
1101e468 56 fHistTrackPt(0),
57 fHistCentrality(0),
58 fHistJetEtaPhi(0),
59 fHistTrackEtaPhi(0),
1af24178 60 fHistJetHEtaPhi(0),
61 fhnMixedEvents(0x0)
1101e468 62{
63 // Default Constructor
64
65 for(Int_t icent = 0; icent<6; ++icent){
66 fHistJetPt[icent]=0;
81941f29 67 fHistJetPtBias[icent]=0;
68 fHistJetPtTT[icent]=0;
55f64c2f 69 for(Int_t iptjet = 0; iptjet<5; ++iptjet){
1101e468 70 for(Int_t ieta = 0; ieta<3; ++ieta){
71 fHistJetH[icent][iptjet][ieta]=0;
72 fHistJetHBias[icent][iptjet][ieta]=0;
81941f29 73 fHistJetHTT[icent][iptjet][ieta]=0;
74
1101e468 75 }
76 }
77 }
78
79}
80//________________________________________________________________________
81AliAnalysisTaskEmcalJetHMEC::AliAnalysisTaskEmcalJetHMEC(const char *name) :
82 AliAnalysisTaskSE(name),
83 fTracksName("tracks"),
84 fJetsName("jets"),
85 fPhimin(-10),
86 fPhimax(10),
87 fEtamin(-0.9),
88 fEtamax(0.9),
89 fAreacut(0.0),
55f64c2f 90 fDoEventMixing(0),
91 fMixingTracks(50000),
1101e468 92 fESD(0),
55f64c2f 93 fPoolMgr(0x0),
1101e468 94 fOutputList(0),
95 fHistTrackPt(0),
96 fHistCentrality(0),
97 fHistJetEtaPhi(0),
98 fHistTrackEtaPhi(0),
55f64c2f 99 fHistJetHEtaPhi(0),
55f64c2f 100 fhnMixedEvents(0x0)
1101e468 101{
102 // Constructor
103 for(Int_t icent = 0; icent<6; ++icent){
104 fHistJetPt[icent]=0;
105 fHistJetPtBias[icent]=0;
81941f29 106 fHistJetPtTT[icent]=0;
107 for(Int_t iptjet = 0; iptjet<5; ++iptjet){
1101e468 108 for(Int_t ieta = 0; ieta<3; ++ieta){
109 fHistJetH[icent][iptjet][ieta]=0;
110 fHistJetHBias[icent][iptjet][ieta]=0;
81941f29 111 fHistJetHTT[icent][iptjet][ieta]=0;
1101e468 112 }
113 }
114 }
115
55f64c2f 116
1101e468 117 DefineInput(0, TChain::Class());
118 DefineOutput(1, TList::Class());
119
120}
121
122//________________________________________________________________________
123void AliAnalysisTaskEmcalJetHMEC::UserCreateOutputObjects()
124{
125 // Called once
126
127
128 AliVEventHandler* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
129 if (!handler) {
130 AliError("Input handler not available!");
131 return;
132 }
133
134 OpenFile(1);
135 fOutputList = new TList();
136 fOutputList->SetOwner();
137
1101e468 138
55f64c2f 139
140 // Create histograms
1101e468 141 fHistTrackPt = new TH1F("fHistTrackPt", "P_{T} distribution", 1000, 0.0, 100.0);
142
143
144
145 fHistCentrality = new TH1F("fHistCentrality","centrality",100,0,100);
146
147 fHistJetEtaPhi = new TH2F("fHistJetEtaPhi","Jet eta-phi",900,-1.8,1.8,640,-3.2,3.2);
148 fHistTrackEtaPhi = new TH2F("fHistTrackEtaPhi","Track eta-phi",900,-1.8,1.8,640,-3.2,3.2);
149 fHistJetHEtaPhi = new TH2F("fHistJetHEtaPhi","Jet-Hadron deta-dphi",900,-1.8,1.8,640,-1.6,4.8);
150
151 char name[200];
152
153
154 for(Int_t icent = 0; icent<6; ++icent){
155 sprintf(name,"fHistJetPt_%i",icent);
156 fHistJetPt[icent] = new TH1F(name,name,200,0,200);
157 fOutputList->Add(fHistJetPt[icent]);
158
159 sprintf(name,"fHistJetPtBias_%i",icent);
160 fHistJetPtBias[icent] = new TH1F(name,name,200,0,200);
161 fOutputList->Add(fHistJetPtBias[icent]);
162
81941f29 163 sprintf(name,"fHistJetPtTT_%i",icent);
164 fHistJetPtTT[icent] = new TH1F(name,name,200,0,200);
165 fOutputList->Add(fHistJetPtTT[icent]);
166
167 for(Int_t iptjet = 0; iptjet<5; ++iptjet){
1101e468 168 for(Int_t ieta = 0; ieta<3; ++ieta){
169 sprintf(name,"fHistJetH_%i_%i_%i",icent,iptjet,ieta);
170 fHistJetH[icent][iptjet][ieta]=new TH2F(name,name,64,-0.5*TMath::Pi(),1.5*TMath::Pi(),300,0,30);
171 fOutputList->Add(fHistJetH[icent][iptjet][ieta]);
172
173 sprintf(name,"fHistJetHBias_%i_%i_%i",icent,iptjet,ieta);
174 fHistJetHBias[icent][iptjet][ieta]=new TH2F(name,name,64,-0.5*TMath::Pi(),1.5*TMath::Pi(),300,0,30);
175 fOutputList->Add(fHistJetHBias[icent][iptjet][ieta]);
176
81941f29 177 sprintf(name,"fHistJetHTT_%i_%i_%i",icent,iptjet,ieta);
178 fHistJetHTT[icent][iptjet][ieta]=new TH2F(name,name,64,-0.5*TMath::Pi(),1.5*TMath::Pi(),300,0,30);
179 fOutputList->Add(fHistJetHTT[icent][iptjet][ieta]);
180
1101e468 181 }
182 }
183 }
184
55f64c2f 185 if(fDoEventMixing){
186 UInt_t cifras = 0; // bit coded, see GetDimParams() below
187 cifras = 1<<0 | 1<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<7;
188 fhnMixedEvents = NewTHnSparseF("fhnMixedEvents", cifras);
189 }
190
1af24178 191 fhnMixedEvents->Sumw2();
1101e468 192
193 fOutputList->Add(fHistTrackPt);
194 fOutputList->Add(fHistCentrality);
195 fOutputList->Add(fHistJetEtaPhi);
196 fOutputList->Add(fHistTrackEtaPhi);
197 fOutputList->Add(fHistJetHEtaPhi);
1af24178 198 fOutputList->Add(fhnMixedEvents);
1101e468 199
200
201 PostData(1, fOutputList);
202
55f64c2f 203
204 //Event Mixing
205 Int_t trackDepth = fMixingTracks;
206 Int_t poolsize = 1000; // Maximum number of events, ignored in the present implemented of AliEventPoolManager
207
208 Int_t nZvtxBins = 7+1+7;
209 // bins for second buffer are shifted by 100 cm
210 Double_t vertexBins[] = { -7, -5, -3, -1, 1, 3, 5, 7, 93, 95, 97, 99, 101, 103, 105, 107 };
211 Double_t* zvtxbin = vertexBins;
212
213 Int_t nCentralityBins = 100;
214 Double_t centralityBins[nCentralityBins];
215 for(Int_t ic=0; ic<nCentralityBins; ic++){
216 centralityBins[ic]=1.0*ic;
217 }
55f64c2f 218
219 fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBins, centralityBins, nZvtxBins, zvtxbin);
220
221
222
1101e468 223}
224
225//________________________________________________________________________
226
227Double_t AliAnalysisTaskEmcalJetHMEC:: RelativePhi(Double_t mphi,Double_t vphi) {
228
229
230 if (vphi < -1*TMath::Pi()) vphi += (2*TMath::Pi());
231 else if (vphi > TMath::Pi()) vphi -= (2*TMath::Pi());
232 if (mphi < -1*TMath::Pi()) mphi += (2*TMath::Pi());
233 else if (mphi > TMath::Pi()) mphi -= (2*TMath::Pi());
234 Double_t dphi = vphi-mphi;
235 if (dphi < -1*TMath::Pi()) dphi += (2*TMath::Pi());
236 else if (dphi > TMath::Pi()) dphi -= (2*TMath::Pi());
237
238 return dphi;//dphi in [-Pi, Pi]
239}
240
241
242//________________________________________________________________________
243Int_t AliAnalysisTaskEmcalJetHMEC::GetCentBin(Double_t cent) const
244{
245 // Get centrality bin.
246
247 Int_t centbin = -1;
248 if (cent>=0 && cent<10)
249 centbin = 0;
250 else if (cent>=10 && cent<20)
251 centbin = 1;
252 else if (cent>=20 && cent<30)
253 centbin = 2;
254 else if (cent>=30 && cent<40)
255 centbin = 3;
256 else if (cent>=40 && cent<50)
257 centbin = 4;
258 else if (cent>=50 && cent<90)
259 centbin = 5;
260 return centbin;
261}
262
263
264//________________________________________________________________________
265Int_t AliAnalysisTaskEmcalJetHMEC::GetEtaBin(Double_t eta) const
266{
267 // Get eta bin for histos.
268
269 Int_t etabin = -1;
270 if (TMath::Abs(eta)<=0.4)
271 etabin = 0;
272 else if (TMath::Abs(eta)>0.4 && TMath::Abs(eta)<0.8)
273 etabin = 1;
274 else if (TMath::Abs(eta)>=0.8)
275 etabin = 2;
276 return etabin;
277}
278//________________________________________________________________________
81941f29 279Int_t AliAnalysisTaskEmcalJetHMEC::GetpTjetBin(Double_t pt) const
1101e468 280{
81941f29 281 // Get jet pt bin for histos.
282
283 Int_t ptbin = -1;
284 if (pt>=10 && pt<15)
285 ptbin = 0;
286 else if (pt>=15 && pt<20)
287 ptbin = 1;
288 else if (pt>=20 && pt<25)
289 ptbin = 2;
290 else if (pt>=25 && pt<30)
291 ptbin = 3;
292 else if (pt>=30)
293 ptbin = 4;
294
295
296 return ptbin;
1101e468 297}
298
299
300//________________________________________________________________________
301void AliAnalysisTaskEmcalJetHMEC::UserExec(Option_t *)
302{
303
304
305 // Main loop called for each event
306 // esd or aod mode
307 Bool_t esdMode = kTRUE;
308 if (dynamic_cast<AliAODEvent*>(InputEvent()))
309 esdMode = kFALSE;
310
311
312 if (esdMode) {
313 // optimization in case autobranch loading is off
314 AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
315 if (fTracksName == "Tracks")
316 am->LoadBranch("Tracks");
317 }
318
319
320 //get centrality
321 TList *list = InputEvent()->GetList();
322 AliCentrality *centrality = InputEvent()->GetCentrality() ;
323 Double_t fcent=-1;
324 if(centrality)
325 fcent = centrality->GetCentralityPercentile("V0M");
326 else
327 fcent=99;//probably pp data
328
329 if (fcent<0) {
330 AliError(Form("Centrality negative: %f", fcent));
331 return;
332 }
333
334
335 fHistCentrality->Fill(fcent);
336 Int_t centbin = GetCentBin(fcent);
337
1af24178 338 if(centbin<0)
339 return;
340
1101e468 341 TClonesArray *jets = 0;
342 TClonesArray *tracks = 0;
343
344 tracks = dynamic_cast<TClonesArray*>(list->FindObject(fTracksName));
345 if (!tracks) {
346 AliError(Form("Pointer to tracks %s == 0", fTracksName.Data() ));
347 return;
348 }
349 const Int_t Ntracks=tracks->GetEntries();
350
351 jets= dynamic_cast<TClonesArray*>(list->FindObject(fJetsName));
352 const Int_t Njets = jets->GetEntries();
353
81941f29 354 //Leticia's loop to find hardest track
355
356 Int_t iTT=-1;
357 Double_t ptmax=-10;
358
359 for (Int_t iTracks = 0; iTracks < Ntracks; iTracks++)
360 {
361 AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
362 if (!track) {
363 printf("ERROR: Could not receive track %d\n", iTracks);
364 continue;
365 }
366
367 if(TMath::Abs(track->Eta())>0.9) continue;
368 if(track->Pt()<0.15)continue;
369 //iCount++;
370 if(track->Pt()>ptmax){
371 ptmax=track->Pt();
372 iTT=iTracks;
373 }
374 }
1101e468 375
376
81941f29 377 Int_t ijethi=-1;
378
379 Double_t highestjetpt=0.0;
380
381 Int_t passedTTcut=0;
1101e468 382
383 for (Int_t ijet = 0; ijet < Njets; ijet++)
384 {
81941f29 385
1101e468 386 AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(ijet));
387
388 if (!jet)
389 continue;
390
391 //pt,eta,phi,centrality
392 float jetphi = jet->Phi();
393 if (jetphi>TMath::Pi())
394 jetphi = jetphi-2*TMath::Pi();
395
396 if ((jet->Phi()<fPhimin)||(jet->Phi()>fPhimax))
397 continue;
398 if ((jet->Eta()<fEtamin)||(jet->Eta()>fEtamax))
399 continue;
400 //fHistAreavsRawPt[centbin]->Fill(jet->Pt(),jet->Area());
401 if (jet->Area()<fAreacut)
402 continue;
403 //prevents 0 area jets from sneaking by when area cut == 0
404 if (jet->Area()==0)
405 continue;
406
1101e468 407 Double_t jetPt = jet->Pt();
408
59d5ae99 409 if(highestjetpt<jetPt){
410 ijethi=ijet;
411 highestjetpt=jetPt;
412 }
413
414 }
415
416
417
418 //Only look at the highest pT jet in the event
419
420 if(ijethi>-1){
421 AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(ijethi));
422
55f64c2f 423 Double_t jetphi = jet->Phi();
59d5ae99 424 Double_t jetPt = jet->Pt();
55f64c2f 425 Double_t jeteta=jet->Eta();
1101e468 426
427 fHistJetPt[centbin]->Fill(jet->Pt());
428
81941f29 429 if ((jet->MaxTrackPt()>6) || (jet->MaxClusterPt()>6))
430 fHistJetPtBias[centbin]->Fill(jet->Pt());
431
432
1101e468 433 fHistJetEtaPhi->Fill(jet->Eta(),jetphi);
434
435 //fHistDeltaPtvsArea->Fill(jetPt,jet->Area());
436
81941f29 437 if(iTT>0){
438 AliVTrack* TT = static_cast<AliVTrack*>(tracks->At(iTT));
439 if(TMath::Abs(jetphi-TT->Phi()-TMath::Pi())<0.6) passedTTcut=1;
440 else passedTTcut=0;
441 }
1101e468 442
81941f29 443 if(passedTTcut)
444 fHistJetPtTT[centbin]->Fill(jet->Pt());
59d5ae99 445
81941f29 446
447 if (highestjetpt>10) {
81941f29 448
81941f29 449 for (Int_t iTracks = 0; iTracks < Ntracks; iTracks++)
450 {
451 AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
452 if (!track) {
453 printf("ERROR: Could not receive track %d\n", iTracks);
454 continue;
455 }
456
1101e468 457 if(TMath::Abs(track->Eta())>0.9) continue;
458
459 fHistTrackPt->Fill(track->Pt());
460
81941f29 461 if (track->Pt()<0.15)
1101e468 462 continue;
463
464 Double_t trackphi = track->Phi();
465 if (trackphi > TMath::Pi())
466 trackphi = trackphi-2*TMath::Pi();
467
468 Double_t tracketa=track->Eta();
55f64c2f 469
1101e468 470 Double_t deta=tracketa-jeteta;
471 Int_t ieta=GetEtaBin(deta);
472
473 //Jet pt, track pt, dPhi,deta,fcent
474 Double_t dphijh = RelativePhi(jetphi,trackphi);
475 if (dphijh < -0.5*TMath::Pi())
476 dphijh= dphijh+ 2*TMath::Pi();
477
478 Int_t iptjet=-1;
479 iptjet=GetpTjetBin(jetPt);
480
481 fHistJetH[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());
482 fHistJetHEtaPhi->Fill(deta,dphijh);
483 fHistTrackEtaPhi->Fill(tracketa,trackphi);
81941f29 484 if ((jet->MaxTrackPt()>6) || (jet->MaxClusterPt()>6))
1101e468 485 fHistJetHBias[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());
81941f29 486
487 if(passedTTcut)
59d5ae99 488 fHistJetHTT[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());
1101e468 489
1101e468 490
491 } //track loop
59d5ae99 492 }//jet pt cut
55f64c2f 493
1af24178 494 }//jet index > -1
55f64c2f 495
1af24178 496
497 //Prepare to do event mixing
498
55f64c2f 499 // create a list of reduced objects. This speeds up processing and reduces memory consumption for the event pool
500 TObjArray* tracksClone = CloneAndReduceTrackList(tracks);
501 //delete tracks;
502
503 Double_t fvertex[3]={0,0,0};
504 InputEvent()->GetPrimaryVertex()->GetXYZ(fvertex);
505 Double_t zVtx=fvertex[3];
506
507 if(fDoEventMixing>0){
508
509 // event mixing
510
511 // 1. First get an event pool corresponding in mult (cent) and
512 // zvertex to the current event. Once initialized, the pool
513 // should contain nMix (reduced) events. This routine does not
514 // pre-scan the chain. The first several events of every chain
515 // will be skipped until the needed pools are filled to the
516 // specified depth. If the pool categories are not too rare, this
517 // should not be a problem. If they are rare, you could lose
518 // statistics.
519
520 // 2. Collect the whole pool's content of tracks into one TObjArray
521 // (bgTracks), which is effectively a single background super-event.
522
523 // 3. The reduced and bgTracks arrays must both be passed into
524 // FillCorrelations(). Also nMix should be passed in, so a weight
525 // of 1./nMix can be applied.
526
527
528
529
530
531 AliEventPool* pool = fPoolMgr->GetEventPool(fcent, zVtx);
55f64c2f 532
533 if (!pool)
534 AliFatal(Form("No pool found for centrality = %f, zVtx = %f", fcent, zVtx));
535
536
1af24178 537 //check for a trigger jet
538 if(ijethi>-1){
539
540 if (pool->IsReady() || pool->NTracksInPool() > fMixingTracks / 10 || pool->GetCurrentNEvents() >= 5)
541 {
542
543 AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(ijethi));
544
545 Double_t jetphi = jet->Phi();
546 Double_t jetPt = jet->Pt();
547 Double_t jeteta=jet->Eta();
548
549
550 Int_t nMix = pool->GetCurrentNEvents();
551
552
553 // Fill mixed-event histos here
554 for (Int_t jMix=0; jMix<nMix; jMix++)
555 {
556 TObjArray* bgTracks = pool->GetEvent(jMix);
557 const Int_t Nbgtrks = bgTracks->GetEntries();
558 for(Int_t ibg=0; ibg<Nbgtrks; ibg++){
559 AliPicoTrack *part = static_cast<AliPicoTrack*>(bgTracks->At(ibg));
560 if(!part) continue;
561
562 Double_t DPhi = jetphi - part->Phi();
563 Double_t DEta = jeteta - part->Eta();
564 Double_t DR=TMath::Sqrt(DPhi*DPhi+DEta*DEta);
565 if(DPhi<-0.5*TMath::Pi()) DPhi+=2.*TMath::Pi();
566 if(DPhi>3./2.*TMath::Pi()) DPhi-=2.*TMath::Pi();
567 Double_t triggerEntries[7] = {fcent,jetPt,part->Pt(),DR,DEta,DPhi,0.0};
568 fhnMixedEvents->Fill(triggerEntries,1./nMix);
569 }
570
571 }
55f64c2f 572 }
55f64c2f 573 }
55f64c2f 574
1af24178 575 //update pool if jet in event or not
576 pool->UpdatePool(tracksClone);
577
59d5ae99 578 }
579
1af24178 580
581
582
583
1101e468 584 PostData(1, fOutputList);
585}
586
587//________________________________________________________________________
588void AliAnalysisTaskEmcalJetHMEC::Terminate(Option_t *)
589{
590 //just terminate
591
592}
593
55f64c2f 594THnSparse* AliAnalysisTaskEmcalJetHMEC::NewTHnSparseF(const char* name, UInt_t entries)
595{
596 // generate new THnSparseF, axes are defined in GetDimParams()
597
598 Int_t count = 0;
599 UInt_t tmp = entries;
600 while(tmp!=0){
601 count++;
602 tmp = tmp &~ -tmp; // clear lowest bit
603 }
604
605 TString hnTitle(name);
606 const Int_t dim = count;
607 Int_t nbins[dim];
608 Double_t xmin[dim];
609 Double_t xmax[dim];
610
611 Int_t i=0;
612 Int_t c=0;
613 while(c<dim && i<32){
614 if(entries&(1<<i)){
615
616 TString label("");
617 GetDimParams(i, label, nbins[c], xmin[c], xmax[c]);
618 hnTitle += Form(";%s",label.Data());
619 c++;
620 }
621
622 i++;
623 }
624 hnTitle += ";";
625
626 return new THnSparseF(name, hnTitle.Data(), dim, nbins, xmin, xmax);
627}
628
629void AliAnalysisTaskEmcalJetHMEC::GetDimParams(Int_t iEntry, TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax)
630{
631 // stores label and binning of axis for THnSparse
632
633 const Double_t pi = TMath::Pi();
634
635 switch(iEntry){
636
637 case 0:
638 label = "V0 centrality (%)";
639
640 nbins = 10;
641 xmin = 0.;
642 xmax = 100.;
643 break;
644
645
646 case 1:
647 label = "corrected jet pt";
648 nbins = 20;
649 xmin = 0.;
650 xmax = 200.;
651 break;
652
653
654 case 2:
655 label = "track pT";
656
657 nbins = 100;
658 xmin = 0.;
659 xmax = 10;
660 break;
661
662
663 case 3:
664 label = "deltaR";
665 nbins = 15;
666 xmin = 0.;
667 xmax = 1.5;
668 break;
669
670
671
672 case 4:
673 label = "deltaEta";
674 nbins = 8;
675 xmin = -1.6;
676 xmax = 1.6;
677 break;
678
679
680 case 5:
681 label = "deltaPhi";
5b38fc6d 682 nbins = 64;
55f64c2f 683 xmin = -0.5*pi;
684 xmax = 1.5*pi;
685 break;
686
687
688
689 case 6:
690 label = "leading track";
691 nbins = 13;
692 xmin = 0;
693 xmax = 50;
694 break;
695
696 case 7:
697
698 label = "trigger track";
699 nbins =10;
700 xmin = 0;
701 xmax = 50;
702 break;
703
704
705
706
707 }
708
709}
710
711
712//_________________________________________________
713// From CF event mixing code PhiCorrelations
714TObjArray* AliAnalysisTaskEmcalJetHMEC::CloneAndReduceTrackList(TObjArray* tracks)
715{
716 // clones a track list by using AliDPhiBasicParticle which uses much less memory (used for event mixing)
717
718 TObjArray* tracksClone = new TObjArray;
719 tracksClone->SetOwner(kTRUE);
720
721 for (Int_t i=0; i<tracks->GetEntriesFast(); i++)
722 {
723 AliVParticle* particle = (AliVParticle*) tracks->At(i);
5b38fc6d 724 tracksClone->Add(new AliPicoTrack(particle->Pt(), particle->Eta(), particle->Phi(), particle->Charge(), 0, 0, 0, 0));
55f64c2f 725 }
726
727 return tracksClone;
728}
729
730
1101e468 731