1 // **************************************************************************************
3 // * Task for Jet properties and jet shape analysis in PWG4 Jet Task Force Train for pp *
5 // **************************************************************************************
8 /**************************************************************************
9 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
11 * Author: The ALICE Off-line Project. *
12 * Contributors are mentioned in the code where appropriate. *
14 * Permission to use, copy, modify and distribute this software and its *
15 * documentation strictly for non-commercial purposes is hereby granted *
16 * without fee, provided that the above copyright notice appears in all *
17 * copies and that both the copyright notice and this permission notice *
18 * appear in the supporting documentation. The authors make no claims *
19 * about the suitability of this software for any purpose. It is *
20 * provided "as is" without express or implied warranty. *
21 **************************************************************************/
30 #include "THnSparse.h"
36 #include "AliAODInputHandler.h"
37 #include "AliAODHandler.h"
38 #include "AliESDEvent.h"
39 #include "AliAODMCParticle.h"
40 #include "AliAODJet.h"
41 #include "AliGenPythiaEventHeader.h"
42 #include "AliGenHijingEventHeader.h"
43 #include "AliInputEventHandler.h"
45 #include "AliAnalysisHelperJetTasks.h"
46 #include "AliAnalysisManager.h"
47 #include "AliAnalysisTaskSE.h"
48 #include "AliVParticle.h"
49 #include "AliAODTrack.h"
50 #include "AliVEvent.h"
53 #include "AliAnalysisTaskJetProperties.h"
55 ClassImp(AliAnalysisTaskJetProperties)
57 //_________________________________________________________________________________//
59 AliAnalysisTaskJetProperties::AliAnalysisTaskJetProperties()
67 ,fTrackType(kTrackAOD)
70 ,fUseAODInputJets(kTRUE)
72 ,fUsePhysicsSelection(kTRUE)
89 ,fh1VertexNContributors(0)
111 ,fh2NtracksLeadingJet(0)
112 ,fProNtracksLeadingJet(0)
124 ,fh1PtSumInJetConeUE(0)
125 ,fh2NtracksLeadingJetUE(0)
126 ,fProNtracksLeadingJetUE(0)
128 ,fProDelR80pcNchUE(0)
133 ,fh3PtDelRNchSumUE(0)
135 ,fProDiffJetShapeUE(0)
136 ,fProIntJetShapeUE(0)
146 for(Int_t ii=0; ii<13; ii++){
148 fh2CorrPt1Pt2[ii] = NULL;
149 fh2CorrZ1Z2[ii] = NULL;
150 fh2CorrKsi1Ksi2[ii] = NULL;
151 fh2CorrjT1jT2[ii] = NULL;
154 fProDelRNchSum[ii] = NULL;
155 fProDelRPtSum[ii] = NULL;
156 fProDiffJetShapeA[ii] = NULL;
157 fProIntJetShapeA[ii] = NULL;
159 fProDelRNchSumUE[ii] = NULL;
160 fProDelRPtSumUE[ii] = NULL;
161 fProDiffJetShapeAUE[ii] = NULL;
162 fProIntJetShapeAUE[ii] = NULL;
164 // default constructor
166 //_________________________________________________________________________________//
168 AliAnalysisTaskJetProperties::AliAnalysisTaskJetProperties(const char *name)
169 : AliAnalysisTaskSE(name)
176 ,fTrackType(kTrackAOD)
179 ,fUseAODInputJets(kTRUE)
181 ,fUsePhysicsSelection(kTRUE)
198 ,fh1VertexNContributors(0)
220 ,fh2NtracksLeadingJet(0)
221 ,fProNtracksLeadingJet(0)
233 ,fh1PtSumInJetConeUE(0)
234 ,fh2NtracksLeadingJetUE(0)
235 ,fProNtracksLeadingJetUE(0)
237 ,fProDelR80pcNchUE(0)
242 ,fh3PtDelRNchSumUE(0)
244 ,fProDiffJetShapeUE(0)
245 ,fProIntJetShapeUE(0)
254 for(Int_t ii=0; ii<13; ii++){
256 fh2CorrPt1Pt2[ii] = NULL;
257 fh2CorrZ1Z2[ii] = NULL;
258 fh2CorrKsi1Ksi2[ii] = NULL;
259 fh2CorrjT1jT2[ii] = NULL;
262 fProDelRNchSum[ii] = NULL;
263 fProDelRPtSum[ii] = NULL;
264 fProDiffJetShapeA[ii] = NULL;
265 fProIntJetShapeA[ii] = NULL;
267 fProDelRNchSumUE[ii] = NULL;
268 fProDelRPtSumUE[ii] = NULL;
269 fProDiffJetShapeAUE[ii] = NULL;
270 fProIntJetShapeAUE[ii] = NULL;
273 DefineOutput(1,TList::Class());
275 //_________________________________________________________________________________//
277 AliAnalysisTaskJetProperties::~AliAnalysisTaskJetProperties()
280 if(fJetList) delete fJetList;
281 if(fTrackList) delete fTrackList;
282 if(fTrackListUE) delete fTrackListUE;
283 if(fTrackListJet) delete fTrackListJet;
285 //_________________________________________________________________________________//
287 Bool_t AliAnalysisTaskJetProperties::Notify()
290 // Implemented Notify() to read the cross sections
291 // and number of trials from pyxsec.root
292 // (taken from AliAnalysisTaskJetSpectrum2)
294 if(fDebug > 1) Printf("AliAnalysisTaskJetProperties::Notify()");
296 TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
297 Float_t xsection = 0;
302 TFile *curfile = tree->GetCurrentFile();
304 Error("Notify","No current file");
307 if(!fh1Xsec||!fh1Trials){
308 Printf("%s%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
311 AliAnalysisHelperJetTasks::PythiaInfoFromFile(curfile->GetName(),xsection,ftrials);
312 fh1Xsec->Fill("<#sigma>",xsection);
313 // construct a poor man average trials
314 Float_t nEntries = (Float_t)tree->GetTree()->GetEntries();
315 if(ftrials>=nEntries && nEntries>0.)fAvgTrials = ftrials/nEntries;
319 //_________________________________________________________________________________//
321 void AliAnalysisTaskJetProperties::UserCreateOutputObjects()
323 //(Here, event selection part is taken from AliAnalysisTaskFramentationFunction)
324 // create output objects
325 if(fDebug > 1) Printf("AliAnalysisTaskJetProperties::UserCreateOutputObjects()");
327 // create list of tracks and jets
328 fJetList = new TList();
329 fJetList->SetOwner(kFALSE);
330 fTrackList = new TList();
331 fTrackList->SetOwner(kFALSE);
332 fTrackListUE = new TList();
333 fTrackListUE->SetOwner(kFALSE);
334 fTrackListJet = new TList();
335 fTrackListJet->SetOwner(kFALSE);
337 // Create histograms / output container
339 fCommonHistList = new TList();
340 fCommonHistList->SetOwner();
342 Bool_t oldStatus = TH1::AddDirectoryStatus();
343 TH1::AddDirectory(kFALSE);
344 // Histograms/TProfiles
345 fh1EvtSelection = new TH1F("fh1EvtSelection", "Event Selection", 6, -0.5, 5.5);
346 fh1EvtSelection->GetXaxis()->SetBinLabel(1,"ACCEPTED");
347 fh1EvtSelection->GetXaxis()->SetBinLabel(2,"event selection: rejected");
348 fh1EvtSelection->GetXaxis()->SetBinLabel(3,"event class: rejected");
349 fh1EvtSelection->GetXaxis()->SetBinLabel(4,"vertex Ncontr: rejected");
350 fh1EvtSelection->GetXaxis()->SetBinLabel(5,"vertex z: rejected");
351 fh1EvtSelection->GetXaxis()->SetBinLabel(6,"pile up: rejected");
354 fh1VertexNContributors = new TH1F("fh1VertexNContributors", "Vertex N contributors", 2500,-.5, 2499.5);
355 fh1VertexZ = new TH1F("fh1VertexZ", "Vertex z distribution", 30, -15., 15.);
356 fh1Xsec = new TProfile("fh1Xsec","xsec from pyxsec.root",1,0,1);
357 fh1Xsec->GetXaxis()->SetBinLabel(1,"<#sigma>");
358 fh1Trials = new TH1F("fh1Trials","trials from pyxsec.root",1,0,1);
359 fh1Trials->GetXaxis()->SetBinLabel(1,"#sum{ntrials}");
360 fh1PtHard = new TH1F("fh1PtHard","PYTHIA Pt hard;p_{T,hard}",350,-.5,349.5);
361 fh1PtHardTrials = new TH1F("fh1PtHardTrials","PYTHIA Pt hard weight with trials;p_{T,hard}",350,-.5,349.5);
364 Int_t kNbinsPtSlice=20; Float_t xMinPtSlice=0.0; Float_t xMaxPtSlice=100.0;
365 Int_t kNbinsEta=40; Float_t xMinEta=-2.0; Float_t xMaxEta=2.0;
366 Int_t kNbinsPhi=90; Float_t xMinPhi=0.0; Float_t xMaxPhi=TMath::TwoPi();
367 Int_t kNbinsPt=250; Float_t xMinPt=0.0; Float_t xMaxPt=250.0;
368 Int_t kNbinsNtracks=50; Float_t xMinNtracks=0.0; Float_t xMaxNtracks=50.0;
369 Int_t kNbinsFF=200; Float_t xMinFF=-0.05; Float_t xMaxFF=1.95;
370 Int_t kNbinsKsi=80; Float_t xMinKsi=0.; Float_t xMaxKsi = 8.0;
371 Int_t kNbinsDelR1D=50; Float_t xMinDelR1D=0.0; Float_t xMaxDelR1D=1.0;
372 Int_t kNbinsjT=100; Float_t xMinjT=0.0; Float_t xMaxjT=10.0;
374 fh2EtaJet = new TH2F("EtaJet","EtaJet",
375 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
376 kNbinsEta, xMinEta, xMaxEta);
377 fh2PhiJet = new TH2F("PhiJet","PhiJet",
378 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
379 kNbinsPhi, xMinPhi, xMaxPhi);
380 fh2PtJet = new TH2F("PtJet","PtJet",
381 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
382 kNbinsPt, xMinPt, xMaxPt);
383 fh1PtJet = new TH1F("PtJet1D","PtJet1D",
384 kNbinsPt, xMinPt, xMaxPt);
385 fh2NtracksJet = new TH2F("NtracksJet","NtracksJet",
386 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
387 kNbinsNtracks, xMinNtracks, xMaxNtracks);
388 fProNtracksJet = new TProfile("AvgNoOfTracksJet","AvgNoOfTracksJet",
389 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
390 xMinNtracks, xMaxNtracks);
391 fh2EtaTrack = new TH2F("EtaTrack","EtaTrack",
392 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
393 kNbinsEta, xMinEta, xMaxEta);
394 fh2PhiTrack = new TH2F("PhiTrack","PhiTrack",
395 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
396 kNbinsPhi, xMinPhi, xMaxPhi);
397 fh2PtTrack = new TH2F("PtTrack","PtTrack",
398 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
399 2*kNbinsPt, xMinPt, xMaxPt);
400 fh2FF = new TH2F("FF","FF",
401 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
402 kNbinsFF, xMinFF, xMaxFF);
403 fh2Ksi = new TH2F("Ksi","Ksi",
404 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
405 kNbinsKsi, xMinKsi, xMaxKsi);
406 fh2DelEta = new TH2F("DelEta","DelEta",
407 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
408 kNbinsEta, xMinEta, xMaxEta);
409 fh2DelPhi = new TH2F("DelPhi","DelPhi",
410 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
411 kNbinsPhi, xMinPhi, xMaxPhi);
412 fh2DelR = new TH2F("DelR","DelR",
413 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
414 kNbinsDelR1D, xMinDelR1D, xMaxDelR1D);
418 Int_t kNbinsDelR=100; Float_t xMinDelR=0.0; Float_t xMaxDelR=1.0;
419 Int_t kNbinsPtSliceJS=100; Float_t xMinPtSliceJS=0.0; Float_t xMaxPtSliceJS=250.0;
421 fh1PtLeadingJet = new TH1F("PtLeadingJet","PtLeadingJet",
422 kNbinsPt, xMinPt, xMaxPt);
423 fh2NtracksLeadingJet = new TH2F("NtracksLeadingJet","NtracksLeadingJet",
424 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
425 kNbinsNtracks, xMinNtracks, xMaxNtracks);
426 fProNtracksLeadingJet = new TProfile("AvgNoOfTracksLeadingJet","AvgNoOfTracksLeadingJet",
427 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
428 xMinNtracks, xMaxNtracks);
429 fh2DelR80pcNch = new TH2F("delR80pcNch","delR80pcNch",
430 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
431 kNbinsDelR, xMinDelR, xMaxDelR);
432 fProDelR80pcNch = new TProfile("AvgdelR80pcNch","AvgdelR80pcNch",
433 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
435 fh2DelR80pcPt = new TH2F("delR80pcPt","delR80pcPt",
436 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
437 kNbinsDelR, xMinDelR, xMaxDelR);
438 fProDelR80pcPt = new TProfile("AvgdelR80pcPt","AvgdelR80pcPt",
439 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
441 fh2AreaCh = new TH2F("Area","Area",
442 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
443 72, 0.0, TMath::Pi());
444 fProAreaCh = new TProfile("AvgArea","AvgArea",
445 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
447 fh3PtDelRNchSum = new TH3F("PtDelRNchSum","PtDelRNchSum",
448 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
449 kNbinsDelR1D, xMinDelR1D, xMaxDelR1D,
450 kNbinsNtracks, xMinNtracks, xMaxNtracks);
451 fh3PtDelRPtSum = new TH3F("PtDelRPtSum","PtDelRPtSum",
452 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
453 kNbinsDelR1D, xMinDelR1D, xMaxDelR1D,
454 kNbinsPt, xMinPt, xMaxPt);
455 fProDiffJetShape = new TProfile("DiffJetShape","DiffJetShape",
456 10,0.0,1.0,0.0,250.0);
457 fProIntJetShape = new TProfile("IntJetShape","IntJetShape",
458 10,0.0,1.0,0.0,250.0);
461 fh1PtSumInJetConeUE = new TH1F("PtSumInJetConeUE","PtSumInJetConeUE",
463 fh2NtracksLeadingJetUE = new TH2F("NtracksLeadingJetUE","NtracksLeadingJetUE",
464 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
465 kNbinsNtracks, xMinNtracks, xMaxNtracks);
466 fProNtracksLeadingJetUE = new TProfile("AvgNoOfTracksLeadingJetUE","AvgNoOfTracksLeadingJetUE",
467 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
468 xMinNtracks, xMaxNtracks);
469 fh2DelR80pcNchUE = new TH2F("delR80pcNchUE","delR80pcNchUE",
470 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
471 kNbinsDelR, xMinDelR, xMaxDelR);
472 fProDelR80pcNchUE = new TProfile("AvgdelR80pcNchUE","AvgdelR80pcNchUE",
473 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
475 fh2DelR80pcPtUE = new TH2F("delR80pcPtUE","delR80pcPtUE",
476 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
477 kNbinsDelR, xMinDelR, xMaxDelR);
478 fProDelR80pcPtUE = new TProfile("AvgdelR80pcPtUE","AvgdelR80pcPtUE",
479 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
481 fh2AreaChUE = new TH2F("AreaUE","AreaUE",
482 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
483 72, 0.0, TMath::Pi());
484 fProAreaChUE = new TProfile("AvgAreaUE","AvgAreaUE",
485 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
487 fh3PtDelRNchSumUE = new TH3F("PtDelRNchSumUE","PtDelRNchSumUE",
488 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
489 kNbinsDelR1D, xMinDelR1D, xMaxDelR1D,
490 kNbinsNtracks, xMinNtracks, xMaxNtracks);
491 fh3PtDelRPtSumUE = new TH3F("PtDelRPtSumUE","PtDelRPtSumUE",
492 kNbinsPtSliceJS, xMinPtSliceJS, xMaxPtSliceJS,
493 kNbinsDelR1D, xMinDelR1D, xMaxDelR1D,
494 kNbinsPt, xMinPt, xMaxPt);
495 fProDiffJetShapeUE = new TProfile("DiffJetShapeUE","DiffJetShapeUE",
496 10,0.0,1.0,0.0,250.0);
497 fProIntJetShapeUE = new TProfile("IntJetShapeUE","IntJetShapeUE",
498 10,0.0,1.0,0.0,250.0);
501 fh1CorrJetPt = new TH1F("JetPtCorr","JetPtCorr",
502 kNbinsPt, xMinPt, xMaxPt);
503 fh2CorrPtTrack1 = new TH2F("TrackPtCorr", "TrackPtCorr",
504 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
505 2*kNbinsPt, xMinPt, xMaxPt);
506 fh2CorrFF1 = new TH2F("FFCorr","FFCorr",
507 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
508 kNbinsFF, xMinFF, xMaxFF);
509 fh2CorrKsi1 = new TH2F("KsiCorr","KsiCorr",
510 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
511 kNbinsKsi, xMinKsi, xMaxKsi);
512 fh2CorrjT1 = new TH2F("jTCorr","jTCorr",
513 kNbinsPtSlice, xMinPtSlice, xMaxPtSlice,
514 kNbinsjT, xMinjT, xMaxjT);
516 fh1JetPtvsTrkSum = new TH1F("diffJetPt_TrkPtSum","diffJetPt_TrkPtSum",
519 for(Int_t ii=0; ii<13; ii++){
520 if(ii==0)title = "_JetPt20to25";
521 if(ii==1)title = "_JetPt25to30";
522 if(ii==2)title = "_JetPt20to30";
524 if(ii==3)title = "_JetPt30to35";
525 if(ii==4)title = "_JetPt35to40";
526 if(ii==5)title = "_JetPt30to40";
528 if(ii==6)title = "_JetPt40to50";
529 if(ii==7)title = "_JetPt50to60";
530 if(ii==8)title = "_JetPt40to60";
532 if(ii==9) title = "_JetPt60to70";
533 if(ii==10)title = "_JetPt70to80";
534 if(ii==11)title = "_JetPt60to80";
536 if(ii==12)title = "_JetPt80to100";
537 fProDelRNchSum[ii] = new TProfile(Form("AvgNchSumDelR%s",title.Data()),Form("AvgNchSumDelR%s",title.Data()),
538 kNbinsDelR1D, xMinDelR1D, xMaxDelR1D,
539 xMinNtracks, xMaxNtracks);
541 fProDelRPtSum[ii] = new TProfile(Form("AvgPtSumDelR%s",title.Data()),Form("AvgPtSumDelR%s",title.Data()),
542 kNbinsDelR1D, xMinDelR1D, xMaxDelR1D,
544 fProDelRNchSum[ii] ->GetXaxis()->SetTitle("R");
545 fProDelRNchSum[ii] ->GetYaxis()->SetTitle("<NchSum>");
546 fProDelRPtSum[ii] ->GetXaxis()->SetTitle("R");
547 fProDelRPtSum[ii] ->GetYaxis()->SetTitle("<PtSum>");
549 fProDiffJetShapeA[ii] = new TProfile(Form("DiffJetShape%s",title.Data()),Form("DiffJetShape%s",title.Data()),
550 10,0.0,1.0,0.0,250.0);
551 fProIntJetShapeA[ii] = new TProfile(Form("IntJetShape%s",title.Data()),Form("IntJetShape%s",title.Data()),
552 10,0.0,1.0,0.0,250.0);
554 fProDiffJetShapeA[ii]->GetXaxis()->SetTitle("R");
555 fProDiffJetShapeA[ii]->GetYaxis()->SetTitle("Diff jet shape");
556 fProIntJetShapeA[ii]->GetXaxis()->SetTitle("R");
557 fProIntJetShapeA[ii]->GetYaxis()->SetTitle("Integrated jet shape");
559 fCommonHistList->Add(fProDelRNchSum[ii]);
560 fCommonHistList->Add(fProDelRPtSum[ii]);
561 fCommonHistList->Add(fProDiffJetShapeA[ii]);
562 fCommonHistList->Add(fProIntJetShapeA[ii]);
564 fProDelRNchSumUE[ii] = new TProfile(Form("AvgNchSumDelR%sUE",title.Data()),Form("AvgNchSumDelR%sUE",title.Data()),
565 kNbinsDelR1D, xMinDelR1D, xMaxDelR1D,
566 xMinNtracks, xMaxNtracks);
568 fProDelRPtSumUE[ii] = new TProfile(Form("AvgPtSumDelR%sUE",title.Data()),Form("AvgPtSumDelR%sUE",title.Data()),
569 kNbinsDelR1D, xMinDelR1D, xMaxDelR1D,
571 fProDelRNchSumUE[ii] ->GetXaxis()->SetTitle("R");
572 fProDelRNchSumUE[ii] ->GetYaxis()->SetTitle("<N_{ch}^{Sum,UE}>");
573 fProDelRPtSumUE[ii] ->GetXaxis()->SetTitle("R");
574 fProDelRPtSumUE[ii] ->GetYaxis()->SetTitle("<p_{T}^{sum, UE}>");
576 fProDiffJetShapeAUE[ii] = new TProfile(Form("DiffJetShape%sUE",title.Data()),Form("DiffJetShape%sUE",title.Data()),
577 10,0.0,1.0,0.0,250.0);
578 fProIntJetShapeAUE[ii] = new TProfile(Form("IntJetShape%sUE",title.Data()),Form("IntJetShape%sUE",title.Data()),
579 10,0.0,1.0,0.0,250.0);
581 fProDiffJetShapeAUE[ii]->GetXaxis()->SetTitle("R");
582 fProDiffJetShapeAUE[ii]->GetYaxis()->SetTitle("Diff jet shape UE");
583 fProIntJetShapeAUE[ii]->GetXaxis()->SetTitle("R");
584 fProIntJetShapeAUE[ii]->GetYaxis()->SetTitle("Integrated jet shape UE");
586 fCommonHistList->Add(fProDelRNchSumUE[ii]);
587 fCommonHistList->Add(fProDelRPtSumUE[ii]);
588 fCommonHistList->Add(fProDiffJetShapeAUE[ii]);
589 fCommonHistList->Add(fProIntJetShapeAUE[ii]);
592 fh2EtaJet ->GetXaxis()->SetTitle("JetPt"); fh2EtaJet ->GetYaxis()->SetTitle("JetEta");
593 fh2PhiJet ->GetXaxis()->SetTitle("JetPt"); fh2PhiJet ->GetYaxis()->SetTitle("JetPhi");
594 fh2PtJet ->GetXaxis()->SetTitle("JetPt"); fh2PtJet ->GetYaxis()->SetTitle("JetPt");
595 fh1PtJet ->GetXaxis()->SetTitle("JetPt"); fh1PtJet ->GetYaxis()->SetTitle("#jets");
596 fh2NtracksJet ->GetXaxis()->SetTitle("JetPt"); fh2NtracksJet ->GetYaxis()->SetTitle("#tracks");
597 fProNtracksJet->GetXaxis()->SetTitle("JetPt"); fProNtracksJet->GetYaxis()->SetTitle("AgvNtracks");
598 fh2EtaTrack ->GetXaxis()->SetTitle("JetPt"); fh2EtaTrack ->GetYaxis()->SetTitle("TrackEta");
599 fh2PhiTrack ->GetXaxis()->SetTitle("JetPt"); fh2PhiTrack ->GetYaxis()->SetTitle("TrackPhi");
600 fh2PtTrack ->GetXaxis()->SetTitle("JetPt"); fh2PtTrack ->GetYaxis()->SetTitle("TrackPt");
601 fh2FF ->GetXaxis()->SetTitle("JetPt"); fh2FF ->GetYaxis()->SetTitle("FF");
602 fh2Ksi ->GetXaxis()->SetTitle("JetPt"); fh2Ksi ->GetYaxis()->SetTitle("Ksi");
603 fh2DelEta ->GetXaxis()->SetTitle("JetPt"); fh2DelEta ->GetYaxis()->SetTitle("DelEta");
604 fh2DelPhi ->GetXaxis()->SetTitle("JetPt"); fh2DelPhi ->GetYaxis()->SetTitle("DelPhi");
605 fh2DelR ->GetXaxis()->SetTitle("JetPt"); fh2DelR ->GetYaxis()->SetTitle("DelR");
607 fh1PtLeadingJet ->GetXaxis()->SetTitle("JetPt"); fh1PtLeadingJet ->GetYaxis()->SetTitle("#leading jets");
608 fh2NtracksLeadingJet ->GetXaxis()->SetTitle("JetPt"); fh2NtracksLeadingJet ->GetYaxis()->SetTitle("#tracks leading jet");
609 fProNtracksLeadingJet ->GetXaxis()->SetTitle("JetPt"); fProNtracksLeadingJet ->GetYaxis()->SetTitle("AvgNtracks leading jet");
610 fh2DelR80pcNch ->GetXaxis()->SetTitle("JetPt"); fh2DelR80pcNch ->GetYaxis()->SetTitle("R containing 80% of tracks");
611 fProDelR80pcNch ->GetXaxis()->SetTitle("JetPt"); fProDelR80pcNch ->GetYaxis()->SetTitle("<R> containing 80% of tracks");
612 fh2DelR80pcPt ->GetXaxis()->SetTitle("JetPt"); fh2DelR80pcPt ->GetYaxis()->SetTitle("R containing 80% of pT");
613 fProDelR80pcPt ->GetXaxis()->SetTitle("JetPt"); fProDelR80pcPt ->GetYaxis()->SetTitle("<R> containing 80% of pT");
614 fh2AreaCh ->GetXaxis()->SetTitle("JetPt"); fh2AreaCh ->GetYaxis()->SetTitle("Jet area");
615 fProAreaCh ->GetXaxis()->SetTitle("JetPt"); fProAreaCh ->GetYaxis()->SetTitle("<jet area>");
616 fh3PtDelRNchSum ->GetXaxis()->SetTitle("JetPt"); fh3PtDelRNchSum ->GetYaxis()->SetTitle("R"); fh3PtDelRNchSum->GetZaxis()->SetTitle("NchSum");
617 fh3PtDelRPtSum ->GetXaxis()->SetTitle("JetPt"); fh3PtDelRPtSum ->GetYaxis()->SetTitle("R"); fh3PtDelRPtSum ->GetZaxis()->SetTitle("PtSum");
618 fProDiffJetShape->GetXaxis()->SetTitle("R");
619 fProDiffJetShape->GetYaxis()->SetTitle("Diff jet shape");
620 fProIntJetShape->GetXaxis()->SetTitle("R");
621 fProIntJetShape->GetYaxis()->SetTitle("Integrated jet shape");
623 fh1PtSumInJetConeUE ->GetXaxis()->SetTitle("p_{T}^{sum, UE}(in cone R)"); fh1PtSumInJetConeUE ->GetYaxis()->SetTitle("#leading jets");
624 fh2NtracksLeadingJetUE ->GetXaxis()->SetTitle("JetPt"); fh2NtracksLeadingJetUE ->GetYaxis()->SetTitle("#tracks UE");
625 fProNtracksLeadingJetUE ->GetXaxis()->SetTitle("JetPt"); fProNtracksLeadingJetUE ->GetYaxis()->SetTitle("AvgNtracks UE");
626 fh2DelR80pcNchUE ->GetXaxis()->SetTitle("JetPt"); fh2DelR80pcNchUE ->GetYaxis()->SetTitle("R containing 80% of tracks");
627 fProDelR80pcNchUE ->GetXaxis()->SetTitle("JetPt"); fProDelR80pcNchUE ->GetYaxis()->SetTitle("<R> containing 80% of tracks");
628 fh2DelR80pcPtUE ->GetXaxis()->SetTitle("JetPt"); fh2DelR80pcPtUE ->GetYaxis()->SetTitle("R containing 80% of pT");
629 fProDelR80pcPtUE ->GetXaxis()->SetTitle("JetPt"); fProDelR80pcPtUE ->GetYaxis()->SetTitle("<R> containing 80% of pT");
630 fh2AreaChUE ->GetXaxis()->SetTitle("JetPt"); fh2AreaChUE ->GetYaxis()->SetTitle("UE area");
631 fProAreaChUE ->GetXaxis()->SetTitle("JetPt"); fProAreaChUE ->GetYaxis()->SetTitle("<UE area>");
632 fh3PtDelRNchSumUE ->GetXaxis()->SetTitle("JetPt"); fh3PtDelRNchSumUE ->GetYaxis()->SetTitle("R"); fh3PtDelRNchSumUE->GetZaxis()->SetTitle("NchSumUE");
633 fh3PtDelRPtSumUE ->GetXaxis()->SetTitle("JetPt"); fh3PtDelRPtSumUE ->GetYaxis()->SetTitle("R"); fh3PtDelRPtSumUE ->GetZaxis()->SetTitle("PtSumUE");
634 fProDiffJetShapeUE->GetXaxis()->SetTitle("R");
635 fProDiffJetShapeUE->GetYaxis()->SetTitle("Diff jet shape UE");
636 fProIntJetShapeUE->GetXaxis()->SetTitle("R");
637 fProIntJetShapeUE->GetYaxis()->SetTitle("Integrated jet shape UE");
639 fh1CorrJetPt ->GetXaxis()->SetTitle("JetPt"); fh1CorrJetPt ->GetYaxis()->SetTitle("#jets");
640 fh2CorrPtTrack1 ->GetXaxis()->SetTitle("JetPt"); fh2CorrPtTrack1 ->GetYaxis()->SetTitle("pt_track");
641 fh2CorrFF1 ->GetXaxis()->SetTitle("JetPt"); fh2CorrFF1 ->GetYaxis()->SetTitle("z_track");
642 fh2CorrKsi1 ->GetXaxis()->SetTitle("JetPt"); fh2CorrKsi1 ->GetYaxis()->SetTitle("ksi_track");
643 fh2CorrjT1 ->GetXaxis()->SetTitle("JetPt"); fh2CorrjT1 ->GetYaxis()->SetTitle("jt_track");
644 fh1JetPtvsTrkSum->GetXaxis()->SetTitle("JetPt-TrkPtSum");
646 fCommonHistList->Add(fh1EvtSelection);
647 fCommonHistList->Add(fh1VertexNContributors);
648 fCommonHistList->Add(fh1VertexZ);
649 fCommonHistList->Add(fh1Xsec);
650 fCommonHistList->Add(fh1Trials);
651 fCommonHistList->Add(fh1PtHard);
652 fCommonHistList->Add(fh1PtHardTrials);
653 fCommonHistList->Add(fh2EtaJet);
654 fCommonHistList->Add(fh2PhiJet);
655 fCommonHistList->Add(fh2PtJet);
656 fCommonHistList->Add(fh1PtJet);
657 fCommonHistList->Add(fh2NtracksJet);
658 fCommonHistList->Add(fProNtracksJet);
659 fCommonHistList->Add(fh2EtaTrack);
660 fCommonHistList->Add(fh2PhiTrack);
661 fCommonHistList->Add(fh2PtTrack);
662 fCommonHistList->Add(fh2FF);
663 fCommonHistList->Add(fh2Ksi);
664 fCommonHistList->Add(fh2DelEta);
665 fCommonHistList->Add(fh2DelPhi);
666 fCommonHistList->Add(fh2DelR);
668 fCommonHistList->Add(fh1PtLeadingJet);
669 fCommonHistList->Add(fh2NtracksLeadingJet);
670 fCommonHistList->Add(fProNtracksLeadingJet);
671 fCommonHistList->Add(fh2DelR80pcNch);
672 fCommonHistList->Add(fProDelR80pcNch);
673 fCommonHistList->Add(fh2DelR80pcPt);
674 fCommonHistList->Add(fProDelR80pcPt);
675 fCommonHistList->Add(fh2AreaCh);
676 fCommonHistList->Add(fProAreaCh);
677 fCommonHistList->Add(fh3PtDelRNchSum);
678 fCommonHistList->Add(fh3PtDelRPtSum);
679 fCommonHistList->Add(fProDiffJetShape);
680 fCommonHistList->Add(fProIntJetShape);
682 fCommonHistList->Add(fh1PtSumInJetConeUE);
683 fCommonHistList->Add(fh2NtracksLeadingJetUE);
684 fCommonHistList->Add(fProNtracksLeadingJetUE);
685 fCommonHistList->Add(fh2DelR80pcNchUE);
686 fCommonHistList->Add(fProDelR80pcNchUE);
687 fCommonHistList->Add(fh2DelR80pcPtUE);
688 fCommonHistList->Add(fProDelR80pcPtUE);
689 fCommonHistList->Add(fh2AreaChUE);
690 fCommonHistList->Add(fProAreaChUE);
691 fCommonHistList->Add(fh3PtDelRNchSumUE);
692 fCommonHistList->Add(fh3PtDelRPtSumUE);
693 fCommonHistList->Add(fProDiffJetShapeUE);
694 fCommonHistList->Add(fProIntJetShapeUE);
696 fCommonHistList->Add(fh1CorrJetPt);
697 fCommonHistList->Add(fh2CorrPtTrack1);
698 fCommonHistList->Add(fh2CorrFF1);
699 fCommonHistList->Add(fh2CorrKsi1);
700 fCommonHistList->Add(fh2CorrjT1);
701 fCommonHistList->Add(fh1JetPtvsTrkSum);
706 for(Int_t jj=0; jj<6; jj++){
707 if(jj == 0)titleCorr = "_JetPt10to20";
708 if(jj == 1)titleCorr = "_JetPt20to30";
709 if(jj == 2)titleCorr = "_JetPt30to40";
710 if(jj == 3)titleCorr = "_JetPt40to60";
711 if(jj == 4)titleCorr = "_JetPt60to80";
712 if(jj == 5)titleCorr = "_JetPt80to100";
714 fh2CorrPt1Pt2[jj] = new TH2F(Form("CorrPt1Pt2%s",titleCorr.Data()),Form("CorrPt1Pt2%s",titleCorr.Data()),
715 2*kNbinsPt, xMinPt, xMaxPt,
716 2*kNbinsPt, xMinPt, xMaxPt);
717 fh2CorrZ1Z2[jj] = new TH2F(Form("CorrZ1Z2%s",titleCorr.Data()),Form("CorrZ1Z2%s",titleCorr.Data()),
718 kNbinsFF, xMinFF, xMaxFF,
719 kNbinsFF, xMinFF, xMaxFF);
720 fh2CorrKsi1Ksi2[jj] = new TH2F(Form("CorrKsi1Ksi2%s",titleCorr.Data()),Form("CorrKsi1Ksi2%s",titleCorr.Data()),
721 kNbinsKsi, xMinKsi, xMaxKsi,
722 kNbinsKsi, xMinKsi, xMaxKsi);
723 fh2CorrjT1jT2[jj] = new TH2F(Form("CorrjT1jT2%s",titleCorr.Data()),Form("CorrjT1jT2%s",titleCorr.Data()),
724 kNbinsjT, xMinjT, xMaxjT,
725 kNbinsjT, xMinjT, xMaxjT);
728 fh2CorrPt1Pt2[jj] ->GetXaxis()->SetTitle("pt_track1");
729 fh2CorrZ1Z2[jj] ->GetXaxis()->SetTitle("z_track1");
730 fh2CorrKsi1Ksi2[jj] ->GetXaxis()->SetTitle("ksi_track1");
731 fh2CorrjT1jT2[jj] ->GetXaxis()->SetTitle("jt_track1");
733 fh2CorrPt1Pt2[jj] ->GetYaxis()->SetTitle("pt_track2");
734 fh2CorrZ1Z2[jj] ->GetYaxis()->SetTitle("z_track2");
735 fh2CorrKsi1Ksi2[jj] ->GetYaxis()->SetTitle("ksi_track2");
736 fh2CorrjT1jT2[jj] ->GetYaxis()->SetTitle("jt_track2");
738 fCommonHistList->Add(fh2CorrPt1Pt2[jj]);
739 fCommonHistList->Add(fh2CorrZ1Z2[jj]);
740 fCommonHistList->Add(fh2CorrKsi1Ksi2[jj]);
741 fCommonHistList->Add(fh2CorrjT1jT2[jj]);
746 // =========== Switch on Sumw2 for all histos ===========
747 for (Int_t i=0; i<fCommonHistList->GetEntries(); ++i){
748 TH1 *h1 = dynamic_cast<TH1*>(fCommonHistList->At(i));
751 TProfile *hPro = dynamic_cast<TProfile*>(fCommonHistList->At(i));
752 if(hPro) hPro->Sumw2();
756 TH1::AddDirectory(oldStatus);
757 PostData(1, fCommonHistList);
759 //_________________________________________________________________________________//
761 void AliAnalysisTaskJetProperties::Init()
764 if(fDebug > 1) Printf("AliAnalysisTaskJetProperties::Init()");
767 //_________________________________________________________________________________//
769 void AliAnalysisTaskJetProperties::UserExec(Option_t *)
772 // Called for each event
773 if(fDebug > 2) Printf("AliAnalysisTaskJetProperties::UserExec()");
775 //if(fDebug > 1) Printf("Analysis event #%5d", (Int_t) fEntry);
778 AliInputEventHandler* inputHandler = (AliInputEventHandler*)
779 ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
780 if(!(inputHandler->IsEventSelected() & AliVEvent::kMB)){
781 if(inputHandler->InheritsFrom("AliESDInputHandler") && fUsePhysicsSelection){ // PhysicsSelection only with ESD input
782 fh1EvtSelection->Fill(1.);
783 if (fDebug > 2 ) Printf(" Trigger Selection: event REJECTED ... ");
784 PostData(1, fCommonHistList);
789 fESD = dynamic_cast<AliESDEvent*>(InputEvent());
791 if(fDebug>2) Printf("%s:%d ESDEvent not found in the input", (char*)__FILE__,__LINE__);
794 fMCEvent = MCEvent();
796 if(fDebug>2) Printf("%s:%d MCEvent not found in the input", (char*)__FILE__,__LINE__);
799 // get AOD event from input/ouput
800 TObject* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
801 if( handler && handler->InheritsFrom("AliAODInputHandler") ) {
802 fAOD = ((AliAODInputHandler*)handler)->GetEvent();
803 if(fUseAODInputJets) fAODJets = fAOD;
804 if (fDebug > 2) Printf("%s:%d AOD event from input", (char*)__FILE__,__LINE__);
807 handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
808 if( handler && handler->InheritsFrom("AliAODHandler") ) {
809 fAOD = ((AliAODHandler*)handler)->GetAOD();
811 if (fDebug > 2) Printf("%s:%d AOD event from output", (char*)__FILE__,__LINE__);
815 if(!fAODJets && !fUseAODInputJets){ // case we have AOD in input & output and want jets from output
816 TObject* outHandler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
817 if( outHandler && outHandler->InheritsFrom("AliAODHandler") ) {
818 fAODJets = ((AliAODHandler*)outHandler)->GetAOD();
819 if (fDebug > 2) Printf("%s:%d jets from output AOD", (char*)__FILE__,__LINE__);
823 if(fNonStdFile.Length()!=0){
824 // case we have an AOD extension - fetch the jets from the extended output
826 AliAODHandler *aodH = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
827 fAODExtension = (aodH?aodH->GetExtension(fNonStdFile.Data()):0);
829 if(fDebug>2)Printf("AODExtension not found for %s",fNonStdFile.Data());
834 Printf("%s:%d AODEvent not found", (char*)__FILE__,__LINE__);
838 Printf("%s:%d AODEvent with jet branch not found", (char*)__FILE__,__LINE__);
843 // *** vertex cut ***
844 AliAODVertex* primVtx = fAOD->GetPrimaryVertex();
845 Int_t nTracksPrim = primVtx->GetNContributors();
846 fh1VertexNContributors->Fill(nTracksPrim);
848 if (fDebug > 2) Printf("%s:%d primary vertex selection: %d", (char*)__FILE__,__LINE__,nTracksPrim);
850 if(nTracksPrim<fNContributors){
851 if (fDebug > 2) Printf("%s:%d primary vertex selection: event REJECTED...",(char*)__FILE__,__LINE__);
852 fh1EvtSelection->Fill(3.);
853 PostData(1, fCommonHistList);
857 if(fRejectPileup && AliAnalysisHelperJetTasks::IsPileUp()){
858 if (fDebug > 2) Printf("%s:%d SPD pileup : event REJECTED...",(char*)__FILE__,__LINE__);
859 fh1EvtSelection->Fill(6.);
860 PostData(1, fCommonHistList);
865 fh1VertexZ->Fill(primVtx->GetZ());
867 if(TMath::Abs(primVtx->GetZ())>fMaxVertexZ){
868 if (fDebug > 2) Printf("%s:%d primary vertex z = %f: event REJECTED...",(char*)__FILE__,__LINE__,primVtx->GetZ());
869 fh1EvtSelection->Fill(4.);
870 PostData(1, fCommonHistList);
874 TString primVtxName(primVtx->GetName());
876 if(primVtxName.CompareTo("TPCVertex",TString::kIgnoreCase) == 1){
877 if (fDebug > 2) Printf("%s:%d primary vertex selection: TPC vertex, event REJECTED...",(char*)__FILE__,__LINE__);
878 fh1EvtSelection->Fill(5.);
879 PostData(1, fCommonHistList);
883 if (fDebug > 2) Printf("%s:%d event ACCEPTED ...",(char*)__FILE__,__LINE__);
884 fh1EvtSelection->Fill(0.);
885 //___ get MC information __________________________________________________________________
886 Double_t ptHard = 0.;
887 Double_t nTrials = 1; // trials for MC trigger weight for real data
890 AliGenEventHeader* genHeader = fMCEvent->GenEventHeader();
892 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
893 AliGenHijingEventHeader* hijingGenHeader = 0x0;
896 if(fDebug>2) Printf("%s:%d pythiaGenHeader found", (char*)__FILE__,__LINE__);
897 nTrials = pythiaGenHeader->Trials();
898 ptHard = pythiaGenHeader->GetPtHard();
900 fh1PtHard->Fill(ptHard);
901 fh1PtHardTrials->Fill(ptHard,nTrials);
904 } else { // no pythia, hijing?
906 if(fDebug>2) Printf("%s:%d no pythiaGenHeader found", (char*)__FILE__,__LINE__);
908 hijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(genHeader);
909 if(!hijingGenHeader){
910 Printf("%s:%d no pythiaGenHeader or hjingGenHeader found", (char*)__FILE__,__LINE__);
912 if(fDebug>2) Printf("%s:%d hijingGenHeader found", (char*)__FILE__,__LINE__);
916 fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
920 //___ fetch jets __________________________________________________________________________
921 Int_t nJ = GetListOfJets(fJetList);
923 if(nJ>=0) nJets = fJetList->GetEntries();
925 Printf("%s:%d Selected jets: %d %d",(char*)__FILE__,__LINE__,nJ,nJets);
926 if(nJ != nJets) Printf("%s:%d Mismatch Selected Jets: %d %d",(char*)__FILE__,__LINE__,nJ,nJets);
928 FillJetProperties(fJetList);
929 FillJetShape(fJetList);
930 FillJetShapeUE(fJetList);
931 FillFFCorr(fJetList);
934 PostData(1, fCommonHistList);
936 //_________________________________________________________________________________//
938 void AliAnalysisTaskJetProperties::Terminate(Option_t *)
942 if(fDebug > 1) printf("AliAnalysisTaskJetProperties::Terminate() \n");
944 //_________________________________________________________________________________//
946 Int_t AliAnalysisTaskJetProperties::GetListOfJets(TList *list)
948 //this functionality is motivated by AliAnalysisTaskFragmentationFunction
949 if(fDebug > 2) printf("AliAnalysisTaskJetProperties::GetListOfJets() \n");
950 // fill list of jets selected according to type
952 if(fDebug>2) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
956 if(fBranchJets.Length()==0){
957 Printf("%s:%d no jet branch specified", (char*)__FILE__,__LINE__);
958 if(fDebug>2)fAOD->Print();
961 TClonesArray *aodJets = 0;
962 if(fBranchJets.Length()) aodJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchJets.Data()));
963 if(!aodJets) aodJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchJets.Data()));
964 if(fAODExtension&&!aodJets) aodJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchJets.Data()));
967 if(fBranchJets.Length())Printf("%s:%d no jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchJets.Data());
968 if(fDebug>2)fAOD->Print();
973 for(Int_t ijet=0; ijet<aodJets->GetEntries(); ijet++){
974 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodJets->At(ijet));
976 if( tmp->Pt() < fJetPtCut ) continue;
977 if( tmp->Eta() < fJetEtaMin || tmp->Eta() > fJetEtaMax)continue;
978 if(fJetRejectType==kReject1Track && tmp->GetRefTracks()->GetEntriesFast()==1)continue;//rejecting 1track jet if...
985 //_________________________________________________________________________________//
987 Int_t AliAnalysisTaskJetProperties::GetListOfJetTracks(TList* list, const AliAODJet* jet)
989 //this functionality is motivated by AliAnalysisTaskFragmentationFunction
990 if(fDebug > 3) printf("AliAnalysisTaskJetProperties::GetListOfJetTracks() \n");
992 // list of jet tracks from trackrefs
993 Int_t nTracks = jet->GetRefTracks()->GetEntriesFast();
995 for (Int_t itrack=0; itrack<nTracks; itrack++) {
996 if(fTrackType==kTrackUndef){
997 if(fDebug>3)Printf("%s:%d unknown track type %d in AOD", (char*)__FILE__,__LINE__,kTrackUndef);
1000 else if(fTrackType == kTrackAOD){
1001 AliAODTrack* trackAod = dynamic_cast<AliAODTrack*>(jet->GetRefTracks()->At(itrack));
1003 AliError("expected ref track not found ");
1006 list->Add(trackAod);
1010 else if(fTrackType==kTrackAODMC){
1011 AliAODMCParticle* trackmc = dynamic_cast<AliAODMCParticle*>(jet->GetRefTracks()->At(itrack));
1013 AliError("expected ref trackmc not found ");
1020 else if (fTrackType==kTrackKine){
1021 AliVParticle* trackkine = dynamic_cast<AliVParticle*>(jet->GetRefTracks()->At(itrack));
1023 AliError("expected ref trackkine not found ");
1026 list->Add(trackkine);
1033 //_________________________________________________________________________________//
1035 void AliAnalysisTaskJetProperties::FillJetProperties(TList *jetlist){
1036 //filling up the histograms jets and tracks inside jet
1037 if(fDebug > 2) printf("AliAnalysisTaskJetProperties::FillJetProperties() \n");
1039 for(Int_t iJet=0; iJet < jetlist->GetEntries(); iJet++){
1040 Float_t JetPt;Float_t JetPhi;Float_t JetEta; // Float_t JetE;
1041 AliAODJet *jet = dynamic_cast<AliAODJet*>(jetlist->At(iJet));
1043 JetEta = jet->Eta();
1044 JetPhi = jet->Phi();
1047 fh2EtaJet ->Fill(JetPt,JetEta);
1048 fh2PhiJet ->Fill(JetPt,JetPhi);
1049 fh2PtJet ->Fill(JetPt,JetPt);
1050 fh1PtJet ->Fill(JetPt);
1051 fTrackListJet->Clear();
1052 Int_t nJT = GetListOfJetTracks(fTrackListJet,jet);
1053 Int_t nJetTracks = 0;
1054 if(nJT>=0) nJetTracks = fTrackListJet->GetEntries();
1056 Printf("%s:%d Jet tracks: %d %d",(char*)__FILE__,__LINE__,nJT,nJetTracks);
1057 if(nJT != nJetTracks) Printf("%s:%d Mismatch Jet Tracks: %d %d",(char*)__FILE__,__LINE__,nJT,nJetTracks);
1060 fh2NtracksJet ->Fill(JetPt,fTrackListJet->GetEntries());
1061 fProNtracksJet ->Fill(JetPt,fTrackListJet->GetEntries());
1063 for (Int_t j =0; j< fTrackListJet->GetEntries(); j++){
1064 if(fTrackType==kTrackUndef)continue;
1065 Float_t TrackEta=-99.0; Float_t TrackPt=-99.0; Float_t TrackPhi=-99.0;
1066 Float_t FF=-99.0; Float_t DelEta=-99.0; Float_t DelPhi=-99.0;
1067 Float_t DelR=-99.0; // Float_t AreaJ=-99.0;
1069 if(fTrackType==kTrackAOD){
1070 AliAODTrack *trackaod = dynamic_cast<AliAODTrack*>(fTrackListJet->At(j));
1071 if(!trackaod)continue;
1072 TrackEta = trackaod->Eta();
1073 TrackPhi = trackaod->Phi();
1074 TrackPt = trackaod->Pt();
1076 else if(fTrackType==kTrackAODMC){
1077 AliAODMCParticle* trackmc = dynamic_cast<AliAODMCParticle*>(fTrackListJet->At(j));
1078 if(!trackmc)continue;
1079 TrackEta = trackmc->Eta();
1080 TrackPhi = trackmc->Phi();
1081 TrackPt = trackmc->Pt();
1083 else if(fTrackType==kTrackKine){
1084 AliVParticle* trackkine = dynamic_cast<AliVParticle*>(fTrackListJet->At(j));
1085 if(!trackkine)continue;
1086 TrackEta = trackkine->Eta();
1087 TrackPhi = trackkine->Phi();
1088 TrackPt = trackkine->Pt();
1090 if(JetPt)FF = TrackPt/JetPt;
1091 if(FF)Ksi = TMath::Log(1./FF);
1092 DelEta = TMath::Abs(JetEta - TrackEta);
1093 DelPhi = TMath::Abs(JetPhi - TrackPhi);
1094 if(DelPhi>TMath::Pi())DelPhi = TMath::Abs(DelPhi-TMath::TwoPi());
1095 DelR = TMath::Sqrt(DelEta*DelEta + DelPhi*DelPhi);
1096 // AreaJ = TMath::Pi()*DelR*DelR;
1097 fh2EtaTrack ->Fill(JetPt,TrackEta);
1098 fh2PhiTrack ->Fill(JetPt,TrackPhi);
1099 fh2PtTrack ->Fill(JetPt,TrackPt);
1100 fh2FF ->Fill(JetPt,FF);
1101 fh2Ksi ->Fill(JetPt,Ksi);
1102 fh2DelEta ->Fill(JetPt,DelEta);
1103 fh2DelPhi ->Fill(JetPt,DelPhi);
1104 fh2DelR ->Fill(JetPt,DelR);
1106 fTrackListJet->Clear();
1108 }//FillJetProperties
1109 //_________________________________________________________________________________//
1110 void AliAnalysisTaskJetProperties::FillFFCorr(TList *jetlist){
1111 //filling up the histograms jets and tracks inside jet
1112 if(fDebug > 2) printf("AliAnalysisTaskJetProperties::FillFFCorr() \n");
1114 for(Int_t iJet=0; iJet < jetlist->GetEntries(); iJet++){
1115 Float_t JetPt;Float_t JetTheta;
1116 AliAODJet *jet = dynamic_cast<AliAODJet*>(jetlist->At(iJet));
1118 JetTheta = jet->Theta();
1120 fh1CorrJetPt -> Fill(JetPt);
1122 fTrackListJet->Clear();
1123 Int_t nJT = GetListOfJetTracks(fTrackListJet,jet);
1124 Int_t nJetTracks = 0;
1125 if(nJT>=0) nJetTracks = fTrackListJet->GetEntries();
1127 Printf("%s:%d Jet tracks: %d %d",(char*)__FILE__,__LINE__,nJT,nJetTracks);
1128 if(nJT != nJetTracks) Printf("%s:%d Mismatch Jet Tracks: %d %d",(char*)__FILE__,__LINE__,nJT,nJetTracks);
1132 for (Int_t j =0; j< fTrackListJet->GetEntries(); j++){
1133 if(fTrackType==kTrackUndef)continue;
1134 Float_t TrackPt1=-99.0; Float_t TrackPt2=-99.0;
1135 Float_t FF1=-99.0; Float_t FF2=-99.0;
1136 Float_t Ksi1=-99.0; Float_t Ksi2=-99.0;
1137 Float_t TrackTheta1=0.0; Float_t TrackTheta2=0.0;
1138 Float_t DelTheta1=0.0; Float_t DelTheta2=0.0;
1139 Float_t jT1=-99.0; Float_t jT2=-99.0;
1140 if(fTrackType==kTrackAOD){
1141 AliAODTrack *trackaod = dynamic_cast<AliAODTrack*>(fTrackListJet->At(j));
1142 if(!trackaod)continue;
1143 TrackTheta1 = trackaod->Theta();
1144 TrackPt1 = trackaod->Pt();
1146 else if(fTrackType==kTrackAODMC){
1147 AliAODMCParticle* trackmc = dynamic_cast<AliAODMCParticle*>(fTrackListJet->At(j));
1148 if(!trackmc)continue;
1149 TrackTheta1 = trackmc->Theta();
1150 TrackPt1 = trackmc->Pt();
1152 else if(fTrackType==kTrackKine){
1153 AliVParticle* trackkine = dynamic_cast<AliVParticle*>(fTrackListJet->At(j));
1154 if(!trackkine)continue;
1155 TrackTheta1 = trackkine->Theta();
1156 TrackPt1 = trackkine->Pt();
1159 if(JetPt)FF1 = TrackPt1/JetPt;
1160 if(FF1)Ksi1 = TMath::Log(1./FF1);
1161 DelTheta1 = TMath::Abs(JetTheta - TrackTheta1);
1162 jT1 = TrackPt1 * TMath::Sin(DelTheta1);
1163 fh2CorrPtTrack1 ->Fill(JetPt,TrackPt1);
1164 fh2CorrFF1 ->Fill(JetPt,FF1);
1165 fh2CorrKsi1 ->Fill(JetPt,Ksi1);
1166 fh2CorrjT1 ->Fill(JetPt,jT1);
1167 for (Int_t jj =j+1; jj< fTrackListJet->GetEntries(); jj++){
1168 if(fTrackType==kTrackUndef)continue;
1169 if(fTrackType==kTrackAOD){
1170 AliAODTrack *trackaod2 = dynamic_cast<AliAODTrack*>(fTrackListJet->At(jj));
1171 if(!trackaod2)continue;
1172 TrackTheta2 = trackaod2->Theta();
1173 TrackPt2 = trackaod2->Pt();
1175 else if(fTrackType==kTrackAODMC){
1176 AliAODMCParticle* trackmc2 = dynamic_cast<AliAODMCParticle*>(fTrackListJet->At(jj));
1177 if(!trackmc2)continue;
1178 TrackTheta2 = trackmc2->Theta();
1179 TrackPt2 = trackmc2->Pt();
1181 else if(fTrackType==kTrackKine){
1182 AliVParticle* trackkine2 = dynamic_cast<AliVParticle*>(fTrackListJet->At(jj));
1183 if(!trackkine2)continue;
1184 TrackTheta2 = trackkine2->Theta();
1185 TrackPt2 = trackkine2->Pt();
1187 if(JetPt)FF2 = TrackPt2/JetPt;
1188 if(FF2)Ksi2 = TMath::Log(1./FF2);
1189 DelTheta2 = TMath::Abs(JetTheta - TrackTheta2);
1190 jT2 = TrackPt2 * TMath::Sin(DelTheta2);
1191 Float_t ptmin=10.; Float_t ptmax=20.0;
1192 for(Int_t iBin=0; iBin<6; iBin++){
1193 if(iBin == 0)ptmin=10.; ptmax=20.;
1194 if(iBin == 1)ptmin=20.; ptmax=30.;
1195 if(iBin == 2)ptmin=30.; ptmax=40.;
1196 if(iBin == 3)ptmin=40.; ptmax=60.;
1197 if(iBin == 4)ptmin=60.; ptmax=80.;
1198 if(iBin == 5)ptmin=80.; ptmax=100.;
1199 if(JetPt>ptmin && JetPt <= ptmax){
1200 fh2CorrPt1Pt2[iBin] ->Fill(TrackPt1,TrackPt2);
1201 fh2CorrZ1Z2[iBin] ->Fill(FF1,FF2);
1202 fh2CorrKsi1Ksi2[iBin]->Fill(Ksi1,Ksi2);
1203 fh2CorrjT1jT2[iBin] ->Fill(jT1,jT2);
1206 }//inside track loop
1208 Float_t diff_JetPt_TrkPtSum = JetPt - TotPt;
1209 fh1JetPtvsTrkSum->Fill(diff_JetPt_TrkPtSum);
1211 fTrackListJet->Clear();
1214 //_________________________________________________________________________________//
1216 void AliAnalysisTaskJetProperties::FillJetShape(TList *jetlist){
1217 //filling up the histograms
1218 if(fDebug > 2) printf("AliAnalysisTaskJetProperties::FillJetShape() \n");
1219 Float_t JetEta; Float_t JetPhi; Float_t JetPt;
1220 AliAODJet *jet = dynamic_cast<AliAODJet*>(jetlist->At(0));//Leading jet only
1222 JetEta = jet->Eta();
1223 JetPhi = jet->Phi();
1225 fh1PtLeadingJet->Fill(JetPt);
1226 Float_t NchSumA[50] = {0.};
1227 Float_t PtSumA[50] = {0.};
1228 Float_t delRPtSum80pc = 0;
1229 Float_t delRNtrkSum80pc = 0;
1230 Float_t PtSumDiffShape[10] = {0.0};
1231 Float_t PtSumIntShape[10] = {0.0};
1233 fTrackListJet->Clear();
1234 Int_t nJT = GetListOfJetTracks(fTrackListJet,jet);
1235 Int_t nJetTracks = 0;
1236 if(nJT>=0) nJetTracks = fTrackListJet->GetEntries();
1238 Printf("%s:%d Jet tracks: %d %d",(char*)__FILE__,__LINE__,nJT,nJetTracks);
1239 if(nJT != nJetTracks) Printf("%s:%d Mismatch Jet Tracks: %d %d",(char*)__FILE__,__LINE__,nJT,nJetTracks);
1241 fh2NtracksLeadingJet->Fill(JetPt,nJetTracks);
1242 fProNtracksLeadingJet->Fill(JetPt,nJetTracks);
1243 Int_t *index = new Int_t [nJetTracks];//dynamic array containing index
1244 Float_t *delRA = new Float_t [nJetTracks];//dynamic array containing delR
1245 Float_t *delEtaA = new Float_t [nJetTracks];//dynamic array containing delEta
1246 Float_t *delPhiA = new Float_t [nJetTracks];//dynamic array containing delPhi
1247 Float_t *trackPtA = new Float_t [nJetTracks];//dynamic array containing pt-track
1248 Float_t *trackEtaA = new Float_t [nJetTracks];//dynamic array containing eta-track
1249 Float_t *trackPhiA = new Float_t [nJetTracks];//dynamic array containing phi-track
1250 for(Int_t ii=0; ii<nJetTracks; ii++){
1260 for (Int_t j =0; j< nJetTracks; j++){
1261 if(fTrackType==kTrackUndef)continue;
1263 Float_t TrackEta=-99.0; Float_t TrackPt=-99.0; Float_t TrackPhi=-99.0;
1264 Float_t DelEta=-99.0; Float_t DelPhi=-99.0; Float_t DelR=-99.0; Float_t AreaJ=-99.0;
1266 if(fTrackType==kTrackAOD){
1267 AliAODTrack *trackaod = dynamic_cast<AliAODTrack*>(fTrackListJet->At(j));
1268 if(!trackaod)continue;
1269 TrackEta = trackaod->Eta();
1270 TrackPhi = trackaod->Phi();
1271 TrackPt = trackaod->Pt();
1273 else if(fTrackType==kTrackAODMC){
1274 AliAODMCParticle* trackmc = dynamic_cast<AliAODMCParticle*>(fTrackListJet->At(j));
1275 if(!trackmc)continue;
1276 TrackEta = trackmc->Eta();
1277 TrackPhi = trackmc->Phi();
1278 TrackPt = trackmc->Pt();
1280 else if(fTrackType==kTrackKine){
1281 AliVParticle* trackkine = dynamic_cast<AliVParticle*>(fTrackListJet->At(j));
1282 if(!trackkine)continue;
1283 TrackEta = trackkine->Eta();
1284 TrackPhi = trackkine->Phi();
1285 TrackPt = trackkine->Pt();
1288 DelEta = TMath::Abs(JetEta - TrackEta);
1289 DelPhi = TMath::Abs(JetPhi - TrackPhi);
1290 if(DelPhi>TMath::Pi())DelPhi = TMath::Abs(DelPhi-TMath::TwoPi());
1291 DelR = TMath::Sqrt(DelEta*DelEta + DelPhi*DelPhi);
1292 AreaJ = TMath::Pi()*DelR*DelR;
1294 fh2AreaCh ->Fill(JetPt,AreaJ);
1295 fProAreaCh->Fill(JetPt,AreaJ);
1297 delEtaA[j] = DelEta;
1298 delPhiA[j] = DelPhi;
1299 trackPtA[j] = TrackPt;
1300 trackEtaA[j] = TrackEta;
1301 trackPhiA[j] = TrackPhi;
1303 //calculating diff and integrated jet shapes
1304 Float_t kDeltaR = 0.1;
1305 Float_t RMin = kDeltaR/2.0;
1306 Float_t RMax = kDeltaR/2.0;
1307 Float_t tmpR = 0.05;
1308 for(Int_t ii1=0; ii1<kNbinsR;ii1++){
1309 if((DelR > (tmpR-RMin)) && (DelR <=(tmpR+RMax)))PtSumDiffShape[ii1]+= TrackPt;
1310 if(DelR>0.0 && DelR <=(tmpR+RMax))PtSumIntShape[ii1]+= TrackPt;
1314 for(Int_t ibin=1; ibin<=50; ibin++){
1315 Float_t xlow = 0.02*(ibin-1);
1316 Float_t xup = 0.02*ibin;
1317 if( xlow <= DelR && DelR < xup){
1319 PtSumA[ibin-1]+= TrackPt;
1323 fTrackListJet->Clear();
1325 //---------------------
1326 Float_t tmp1R = 0.05;
1327 for(Int_t jj1=0; jj1<kNbinsR;jj1++){
1328 if(JetPt>20 && JetPt<=100){
1329 fProDiffJetShape->Fill(tmp1R,PtSumDiffShape[jj1]/JetPt);
1330 fProIntJetShape ->Fill(tmp1R,PtSumIntShape[jj1]/JetPt);
1332 Float_t jetPtMin0=20.0; Float_t jetPtMax0=30.0;
1333 for(Int_t k=0; k<13; k++){
1334 if(k==0) {jetPtMin0=20.0;jetPtMax0=25.0;}
1335 if(k==1) {jetPtMin0=25.0;jetPtMax0=30.0;}
1336 if(k==2) {jetPtMin0=20.0;jetPtMax0=30.0;}
1337 if(k==3) {jetPtMin0=30.0;jetPtMax0=35.0;}
1338 if(k==4) {jetPtMin0=35.0;jetPtMax0=40.0;}
1339 if(k==5) {jetPtMin0=30.0;jetPtMax0=40.0;}
1340 if(k==6) {jetPtMin0=40.0;jetPtMax0=50.0;}
1341 if(k==7) {jetPtMin0=50.0;jetPtMax0=60.0;}
1342 if(k==8) {jetPtMin0=40.0;jetPtMax0=60.0;}
1343 if(k==9) {jetPtMin0=60.0;jetPtMax0=70.0;}
1344 if(k==10){jetPtMin0=70.0;jetPtMax0=80.0;}
1345 if(k==11){jetPtMin0=60.0;jetPtMax0=80.0;}
1346 if(k==12){jetPtMin0=80.0;jetPtMax0=100.0;}
1347 if(JetPt>jetPtMin0 && JetPt<=jetPtMax0){
1348 fProDiffJetShapeA[k]->Fill(tmp1R,PtSumDiffShape[jj1]/JetPt);
1349 fProIntJetShapeA[k] ->Fill(tmp1R,PtSumIntShape[jj1]/JetPt);
1354 //----------------------//
1357 Bool_t iflagPtSum = kFALSE;
1358 Bool_t iflagNtrkSum = kFALSE;
1359 TMath::Sort(nJetTracks,delRA,index,0);
1360 for(Int_t ii=0; ii<nJetTracks; ii++){
1362 PtSum += trackPtA[index[ii]];
1364 cout << index[ii] << "\t" <<
1366 delEta[ii]<< "\t" <<
1367 delPhi[ii]<< "\t" <<
1368 trackPt[ii]<< "\t" <<
1369 trackEta[ii]<< "\t" <<
1370 trackPhi[ii]<< "\t DelR " <<
1371 delR[index[ii]] << endl;
1374 if((Float_t)NtrkSum/(Float_t)nJetTracks > 0.79){
1375 delRNtrkSum80pc = delRA[index[ii]];
1376 iflagNtrkSum = kTRUE;
1380 if(PtSum/JetPt >= 0.8000){
1381 delRPtSum80pc = delRA[index[ii]];
1391 delete [] trackEtaA;
1392 delete [] trackPhiA;
1393 fh2DelR80pcNch ->Fill(JetPt,delRNtrkSum80pc);
1394 fProDelR80pcNch->Fill(JetPt,delRNtrkSum80pc);
1395 fh2DelR80pcPt ->Fill(JetPt,delRPtSum80pc);
1396 fProDelR80pcPt ->Fill(JetPt,delRPtSum80pc);
1397 for(Int_t ibin=0; ibin<50; ibin++){
1398 Float_t iR = 0.02*ibin + 0.01;
1399 fh3PtDelRNchSum->Fill(JetPt,iR,NchSumA[ibin]);
1400 fh3PtDelRPtSum ->Fill(JetPt,iR,PtSumA[ibin]);
1401 Float_t jetPtMin=20.0; Float_t jetPtMax=30.0;
1402 for(Int_t k=0; k<13; k++){
1403 if(k==0) {jetPtMin=20.0;jetPtMax=25.0;}
1404 if(k==1) {jetPtMin=25.0;jetPtMax=30.0;}
1405 if(k==2) {jetPtMin=20.0;jetPtMax=30.0;}
1406 if(k==3) {jetPtMin=30.0;jetPtMax=35.0;}
1407 if(k==4) {jetPtMin=35.0;jetPtMax=40.0;}
1408 if(k==5) {jetPtMin=30.0;jetPtMax=40.0;}
1409 if(k==6) {jetPtMin=40.0;jetPtMax=50.0;}
1410 if(k==7) {jetPtMin=50.0;jetPtMax=60.0;}
1411 if(k==8) {jetPtMin=40.0;jetPtMax=60.0;}
1412 if(k==9) {jetPtMin=60.0;jetPtMax=70.0;}
1413 if(k==10){jetPtMin=70.0;jetPtMax=80.0;}
1414 if(k==11){jetPtMin=60.0;jetPtMax=80.0;}
1415 if(k==12){jetPtMin=80.0;jetPtMax=100.0;}
1416 if(JetPt>jetPtMin && JetPt<jetPtMax){
1417 fProDelRNchSum[k]->Fill(iR,NchSumA[ibin]);
1418 fProDelRPtSum[k]->Fill(iR,PtSumA[ibin]);
1424 //_________________________________________________________________________________//
1426 void AliAnalysisTaskJetProperties::FillJetShapeUE(TList *jetlist){
1427 //filling up the histograms
1428 if(fDebug > 2) printf("AliAnalysisTaskJetProperties::FillJetShape() \n");
1429 AliAODJet *jet = dynamic_cast<AliAODJet*>(jetlist->At(0));//Leading jet only
1432 jet->PxPyPz(jetMom);
1434 TVector3 jet3mom(jetMom);
1435 // Rotate phi and keep eta unchanged
1437 const Double_t alpha = TMath::Pi()/2.;
1438 Double_t etaTilted = jet3mom.Eta();
1439 Double_t phiTilted = TVector2::Phi_0_2pi(jet3mom.Phi()) + alpha;
1440 if(phiTilted > 2*TMath::Pi()) phiTilted = phiTilted - 2*TMath::Pi();
1442 Double_t JetPt = jet->Pt();
1444 Float_t NchSumA[50] = {0.};
1445 Float_t PtSumA[50] = {0.};
1446 Float_t delRPtSum80pc = 0;
1447 Float_t delRNtrkSum80pc = 0;
1448 Float_t PtSumDiffShape[10] = {0.0};
1449 Float_t PtSumIntShape[10] = {0.0};
1452 //Int_t nTracks = GetListOfTracks(fTrackList,fTrackType);
1453 fTrackList->Clear();
1454 GetListOfTracks(fTrackList,fTrackType);
1455 Double_t sumPtPerp = 0;
1456 //if(fDebug > 100) printf("Cone radius for bckg. = %f Track type = %d\n",fJetRadius, fTrackType);
1457 fTrackListUE->Clear();
1458 GetTracksTiltedwrpJetAxis(alpha, fTrackList, fTrackListUE,jet,fJetRadius,sumPtPerp);
1459 fTrackList->Clear();
1460 fh1PtSumInJetConeUE->Fill(sumPtPerp);
1461 Int_t nTracksUE = fTrackListUE->GetEntries();
1462 fh2NtracksLeadingJetUE->Fill(JetPt,nTracksUE);
1463 fProNtracksLeadingJetUE->Fill(JetPt,nTracksUE);
1465 Int_t *index = new Int_t [nTracksUE];//dynamic array containing index
1466 Float_t *delRA = new Float_t [nTracksUE];//dynamic array containing delR
1467 Float_t *delEtaA = new Float_t [nTracksUE];//dynamic array containing delEta
1468 Float_t *delPhiA = new Float_t [nTracksUE];//dynamic array containing delPhi
1469 Float_t *trackPtA = new Float_t [nTracksUE];//dynamic array containing pt-track
1470 Float_t *trackEtaA = new Float_t [nTracksUE];//dynamic array containing eta-track
1471 Float_t *trackPhiA = new Float_t [nTracksUE];//dynamic array containing phi-track
1472 for(Int_t ii=0; ii<nTracksUE; ii++){
1482 for (Int_t j =0; j< nTracksUE; j++){
1483 if(fTrackType==kTrackUndef)continue;
1485 Float_t TrackEta=-99.0; Float_t TrackPt=-99.0; Float_t TrackPhi=-99.0;
1486 Float_t DelEta=-99.0; Float_t DelPhi=-99.0; Float_t DelR=-99.0; Float_t AreaJ=-99.0;
1488 if(fTrackType==kTrackAOD){
1489 AliAODTrack *trackaod = dynamic_cast<AliAODTrack*>(fTrackListUE->At(j));
1490 if(!trackaod)continue;
1491 TrackEta = trackaod->Eta();
1492 TrackPhi = trackaod->Phi();
1493 TrackPt = trackaod->Pt();
1494 //if(fDebug > 100) printf("FillJetShapeUE itrack, trackPt %d, %f\n",j,TrackPt);
1496 else if(fTrackType==kTrackAODMC){
1497 AliAODMCParticle* trackmc = dynamic_cast<AliAODMCParticle*>(fTrackListUE->At(j));
1498 if(!trackmc)continue;
1499 TrackEta = trackmc->Eta();
1500 TrackPhi = trackmc->Phi();
1501 TrackPt = trackmc->Pt();
1502 //if(fDebug > 100) printf("FillJetShapeUE itrack, trackPt %d, %f\n",j,TrackPt);
1504 else if(fTrackType==kTrackKine){
1505 AliVParticle* trackkine = dynamic_cast<AliVParticle*>(fTrackListUE->At(j));
1506 if(!trackkine)continue;
1507 TrackEta = trackkine->Eta();
1508 TrackPhi = trackkine->Phi();
1509 TrackPt = trackkine->Pt();
1510 //if(fDebug > 100) printf("FillJetShapeUE itrack, trackPt %d, %f\n",j,TrackPt);
1513 DelEta = TMath::Abs(etaTilted - TrackEta);
1514 DelPhi = TMath::Abs(phiTilted - TrackPhi);
1515 if(DelPhi>TMath::Pi())DelPhi = TMath::Abs(DelPhi-TMath::TwoPi());
1516 DelR = TMath::Sqrt(DelEta*DelEta + DelPhi*DelPhi);
1517 AreaJ = TMath::Pi()*DelR*DelR;
1519 fh2AreaChUE ->Fill(JetPt,AreaJ);
1520 fProAreaChUE->Fill(JetPt,AreaJ);
1523 delEtaA[j] = DelEta;
1524 delPhiA[j] = DelPhi;
1525 trackPtA[j] = TrackPt;
1526 trackEtaA[j] = TrackEta;
1527 trackPhiA[j] = TrackPhi;
1529 //calculating diff and integrated jet shapes
1530 Float_t kDeltaR = 0.1;
1531 Float_t RMin = kDeltaR/2.0;
1532 Float_t RMax = kDeltaR/2.0;
1533 Float_t tmpR = 0.05;
1534 for(Int_t ii1=0; ii1<kNbinsR;ii1++){
1535 if((DelR > (tmpR-RMin)) && (DelR <=(tmpR+RMax)))PtSumDiffShape[ii1]+= TrackPt;
1536 if(DelR>0.0 && DelR <=(tmpR+RMax))PtSumIntShape[ii1]+= TrackPt;
1540 for(Int_t ibin=1; ibin<=50; ibin++){
1541 Float_t xlow = 0.02*(ibin-1);
1542 Float_t xup = 0.02*ibin;
1543 if( xlow <= DelR && DelR < xup){
1545 PtSumA[ibin-1]+= TrackPt;
1549 fTrackListUE->Clear();
1551 //---------------------
1552 Float_t tmp1R = 0.05;
1553 for(Int_t jj1=0; jj1<kNbinsR;jj1++){
1554 if(JetPt>20 && JetPt<=100){
1555 fProDiffJetShapeUE->Fill(tmp1R,PtSumDiffShape[jj1]/JetPt);
1556 fProIntJetShapeUE ->Fill(tmp1R,PtSumIntShape[jj1]/JetPt);
1558 Float_t jetPtMin0=20.0; Float_t jetPtMax0=30.0;
1559 for(Int_t k=0; k<13; k++){
1560 if(k==0) {jetPtMin0=20.0;jetPtMax0=25.0;}
1561 if(k==1) {jetPtMin0=25.0;jetPtMax0=30.0;}
1562 if(k==2) {jetPtMin0=20.0;jetPtMax0=30.0;}
1563 if(k==3) {jetPtMin0=30.0;jetPtMax0=35.0;}
1564 if(k==4) {jetPtMin0=35.0;jetPtMax0=40.0;}
1565 if(k==5) {jetPtMin0=30.0;jetPtMax0=40.0;}
1566 if(k==6) {jetPtMin0=40.0;jetPtMax0=50.0;}
1567 if(k==7) {jetPtMin0=50.0;jetPtMax0=60.0;}
1568 if(k==8) {jetPtMin0=40.0;jetPtMax0=60.0;}
1569 if(k==9) {jetPtMin0=60.0;jetPtMax0=70.0;}
1570 if(k==10){jetPtMin0=70.0;jetPtMax0=80.0;}
1571 if(k==11){jetPtMin0=60.0;jetPtMax0=80.0;}
1572 if(k==12){jetPtMin0=80.0;jetPtMax0=100.0;}
1573 if(JetPt>jetPtMin0 && JetPt<=jetPtMax0){
1574 fProDiffJetShapeAUE[k]->Fill(tmp1R,PtSumDiffShape[jj1]/JetPt);
1575 fProIntJetShapeAUE[k] ->Fill(tmp1R,PtSumIntShape[jj1]/JetPt);
1580 //----------------------//
1583 Bool_t iflagPtSum = kFALSE;
1584 Bool_t iflagNtrkSum = kFALSE;
1585 TMath::Sort(nTracksUE,delRA,index,0);
1586 for(Int_t ii=0; ii<nTracksUE; ii++){
1588 PtSum += trackPtA[index[ii]];
1590 cout << index[ii] << "\t" <<
1592 delEta[ii]<< "\t" <<
1593 delPhi[ii]<< "\t" <<
1594 trackPt[ii]<< "\t" <<
1595 trackEta[ii]<< "\t" <<
1596 trackPhi[ii]<< "\t DelR " <<
1597 delR[index[ii]] << endl;
1600 if((Float_t)NtrkSum/(Float_t)nTracksUE > 0.79){
1601 delRNtrkSum80pc = delRA[index[ii]];
1602 iflagNtrkSum = kTRUE;
1606 if(PtSum/JetPt >= 0.8000){
1607 delRPtSum80pc = delRA[index[ii]];
1617 delete [] trackEtaA;
1618 delete [] trackPhiA;
1619 fh2DelR80pcNchUE ->Fill(JetPt,delRNtrkSum80pc);
1620 fProDelR80pcNchUE->Fill(JetPt,delRNtrkSum80pc);
1621 fh2DelR80pcPtUE ->Fill(JetPt,delRPtSum80pc);
1622 fProDelR80pcPtUE ->Fill(JetPt,delRPtSum80pc);
1623 for(Int_t ibin=0; ibin<50; ibin++){
1624 Float_t iR = 0.02*ibin + 0.01;
1625 fh3PtDelRNchSumUE->Fill(JetPt,iR,NchSumA[ibin]);
1626 fh3PtDelRPtSumUE ->Fill(JetPt,iR,PtSumA[ibin]);
1627 Float_t jetPtMin=20.0; Float_t jetPtMax=30.0;
1628 for(Int_t k=0; k<13; k++){
1629 if(k==0) {jetPtMin=20.0;jetPtMax=25.0;}
1630 if(k==1) {jetPtMin=25.0;jetPtMax=30.0;}
1631 if(k==2) {jetPtMin=20.0;jetPtMax=30.0;}
1632 if(k==3) {jetPtMin=30.0;jetPtMax=35.0;}
1633 if(k==4) {jetPtMin=35.0;jetPtMax=40.0;}
1634 if(k==5) {jetPtMin=30.0;jetPtMax=40.0;}
1635 if(k==6) {jetPtMin=40.0;jetPtMax=50.0;}
1636 if(k==7) {jetPtMin=50.0;jetPtMax=60.0;}
1637 if(k==8) {jetPtMin=40.0;jetPtMax=60.0;}
1638 if(k==9) {jetPtMin=60.0;jetPtMax=70.0;}
1639 if(k==10){jetPtMin=70.0;jetPtMax=80.0;}
1640 if(k==11){jetPtMin=60.0;jetPtMax=80.0;}
1641 if(k==12){jetPtMin=80.0;jetPtMax=100.0;}
1642 if(JetPt>jetPtMin && JetPt<jetPtMax){
1643 fProDelRNchSumUE[k]->Fill(iR,NchSumA[ibin]);
1644 fProDelRPtSumUE[k]->Fill(iR,PtSumA[ibin]);
1650 //_________________________________________________________________________________//
1652 void AliAnalysisTaskJetProperties::GetTracksTiltedwrpJetAxis(Float_t alpha, TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius,Double_t& sumPt){
1653 //This part is inherited from AliAnalysisTaskFragmentationFunction.cxx
1654 // List of tracks in cone perpendicular to the jet azimuthal direction
1656 jet->PxPyPz(jetMom);
1658 TVector3 jet3mom(jetMom);
1659 // Rotate phi and keep eta unchanged
1660 Double_t etaTilted = jet3mom.Eta();//no change in eta
1661 Double_t phiTilted = TVector2::Phi_0_2pi(jet3mom.Phi()) + alpha;//rotate phi by alpha
1662 if(phiTilted > 2*TMath::Pi()) phiTilted = phiTilted - 2*TMath::Pi();
1664 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
1665 if(fTrackType==kTrackUndef)continue;
1666 Double_t trackMom[3];
1668 if(fTrackType==kTrackAOD){
1669 AliAODTrack *trackaod = dynamic_cast<AliAODTrack*>(inputlist->At(itrack));
1670 if(!trackaod)continue;
1671 trackaod->PxPyPz(trackMom);
1672 TVector3 track3mom(trackMom);
1674 Double_t deta = track3mom.Eta() - etaTilted;
1675 Double_t dphi = TMath::Abs(track3mom.Phi() - phiTilted);
1676 if (dphi > TMath::Pi()) dphi = 2. * TMath::Pi() - dphi;
1677 Double_t dR = TMath::Sqrt(deta * deta + dphi * dphi);
1680 outputlist->Add(trackaod);
1681 sumPt += trackaod->Pt();
1682 //if(fDebug > 100) printf("GetTracksTiltewrpJetAxis itrack, trackPt %d, %f\n",itrack,track3mom.Pt());
1685 else if(fTrackType==kTrackAODMC){
1686 AliAODMCParticle* trackmc = dynamic_cast<AliAODMCParticle*>(inputlist->At(itrack));
1687 if(!trackmc)continue;
1688 trackmc->PxPyPz(trackMom);
1689 TVector3 track3mom(trackMom);
1691 Double_t deta = track3mom.Eta() - etaTilted;
1692 Double_t dphi = TMath::Abs(track3mom.Phi() - phiTilted);
1693 if (dphi > TMath::Pi()) dphi = 2. * TMath::Pi() - dphi;
1694 Double_t dR = TMath::Sqrt(deta * deta + dphi * dphi);
1697 outputlist->Add(trackmc);
1698 sumPt += trackmc->Pt();
1699 //if(fDebug > 100) printf("GetTracksTiltewrpJetAxis itrack, trackPt %d, %f\n",itrack,track3mom.Pt());
1702 else if(fTrackType==kTrackKine){
1703 AliVParticle* trackkine = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
1704 if(!trackkine)continue;
1705 trackkine->PxPyPz(trackMom);
1706 TVector3 track3mom(trackMom);
1708 Double_t deta = track3mom.Eta() - etaTilted;
1709 Double_t dphi = TMath::Abs(track3mom.Phi() - phiTilted);
1710 if (dphi > TMath::Pi()) dphi = 2. * TMath::Pi() - dphi;
1711 Double_t dR = TMath::Sqrt(deta * deta + dphi * dphi);
1714 outputlist->Add(trackkine);
1715 sumPt += trackkine->Pt();
1716 //if(fDebug > 100) printf("GetTracksTiltewrpJetAxis itrack, trackPt %d, %f\n",itrack,track3mom.Pt());
1721 //-----------------------------------------------//
1722 Int_t AliAnalysisTaskJetProperties::GetListOfTracks(TList *list, Int_t type)
1724 //This part is inherited from AliAnalysisTaskFragmentationFunction.cxx (and modified)
1725 // fill list of tracks selected according to type
1727 if(fDebug > 3) Printf("%s:%d Selecting tracks with %d", (char*)__FILE__,__LINE__,type);
1730 if(fDebug>3) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
1734 if(!fAOD) return -1;
1736 if(!fAOD->GetTracks()) return 0;
1738 if(type==kTrackUndef) return 0;
1741 if(type==kTrackAOD){
1742 // all rec. tracks, esd filter mask, within acceptance
1743 for(Int_t it=0; it<fAOD->GetNumberOfTracks(); ++it){
1744 AliAODTrack *tr = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(it));
1745 if(!tr) AliFatal("Not a standard AOD");
1747 if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask)))continue;//selecting filtermask
1748 if(tr->Eta() < fTrackEtaMin || tr->Eta() > fTrackEtaMax) continue;
1749 if(tr->Pt() < fTrackPtCut) continue;
1754 else if (type==kTrackKine){
1755 // kine particles, primaries, charged only within acceptance
1756 if(!fMCEvent) return iCount;
1757 for(Int_t it=0; it<fMCEvent->GetNumberOfTracks(); ++it){
1758 if(!fMCEvent->IsPhysicalPrimary(it))continue;//selecting only primaries
1759 AliMCParticle* part = (AliMCParticle*) fMCEvent->GetTrack(it);
1761 if(part->Particle()->GetPDG()->Charge()==0)continue;//removing neutrals
1762 if(part->Eta() < fTrackEtaMin || part->Eta() > fTrackEtaMax) continue;//eta cut
1763 if(part->Pt() < fTrackPtCut)continue;//pt cut
1768 else if (type==kTrackAODMC) {
1769 // MC particles (from AOD), physical primaries, charged only within acceptance
1770 if(!fAOD) return -1;
1772 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
1773 if(!tca)return iCount;
1775 for(int it=0; it<tca->GetEntriesFast(); ++it){
1776 AliAODMCParticle *part = dynamic_cast<AliAODMCParticle*>(tca->At(it));
1778 if(!part->IsPhysicalPrimary())continue;
1779 if(part->Charge()==0) continue;
1780 if(part->Eta() > fTrackEtaMax || part->Eta() < fTrackEtaMin)continue;
1781 if(part->Pt() < fTrackPtCut) continue;
1790 //_______________________________________________________________________________