AliPhysics  f1cc956 (f1cc956)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalJetShapesMC.cxx
Go to the documentation of this file.
1 //
2 // Jet QG tagging analysis task.
3 //
4 // Author: D. Caffarri, L. Cunqueiro
5 
6 #include <TClonesArray.h>
7 #include <TH1F.h>
8 #include <TH2F.h>
9 #include <TH3F.h>
10 #include <THnSparse.h>
11 #include <TTree.h>
12 #include <TList.h>
13 #include <TLorentzVector.h>
14 #include <TProfile.h>
15 #include <TChain.h>
16 #include <TSystem.h>
17 #include <TFile.h>
18 #include <TKey.h>
19 #include <AliAnalysisDataSlot.h>
20 #include <AliAnalysisDataContainer.h>
21 #include "TMatrixD.h"
22 #include "TMatrixDSym.h"
23 #include "TMatrixDSymEigen.h"
24 #include "TVector3.h"
25 #include "TVector2.h"
26 #include "AliVCluster.h"
27 #include "AliVTrack.h"
28 #include "AliEmcalJet.h"
29 #include "AliRhoParameter.h"
30 #include "AliLog.h"
31 #include "AliEmcalParticle.h"
32 #include "AliMCEvent.h"
33 #include "AliGenPythiaEventHeader.h"
34 #include "AliAODMCHeader.h"
35 #include "AliMCEvent.h"
36 #include "AliAnalysisManager.h"
37 #include "AliJetContainer.h"
38 #include "AliParticleContainer.h"
39 #include "AliEmcalPythiaInfo.h"
40 #include "TRandom3.h"
41 #include "AliEmcalJetFinder.h"
42 #include "AliAODEvent.h"
44 
45 using std::cout;
46 using std::endl;
47 
49 
50 //________________________________________________________________________
53  fContainer(0),
54  fMinFractionShared(0),
55  fJetShapeType(kGenShapes),
56  fJetShapeSub(kNoSub),
57  fJetSelection(kInclusive),
58  fPtThreshold(-9999.),
59  fRMatching(0.2),
60  fJetRadius(0.4),
61  fSubjetRadius(0.2),
62  fSelectedShapes(0),
63  fminpTTrig(20.),
64  fmaxpTTrig(50.),
65  fangWindowRecoil(0.6),
66  fSemigoodCorrect(0),
67  fHolePos(0),
68  fHoleWidth(0),
69  fCentSelectOn(kTRUE),
70  fCentMin(0),
71  fCentMax(10),
72  fOneConstSelectOn(kFALSE),
73  fDerivSubtrOrder(0),
74  fPhiJetCorr6(0x0),
75  fPhiJetCorr7(0x0),
76  fEtaJetCorr6(0x0),
77  fEtaJetCorr7(0x0),
78  fPtJetCorr(0x0),
79  fPtJet(0x0),
80  fhpTjetpT(0x0),
81  fhPt(0x0),
82  fhPhi(0x0),
83  fNbOfConstvspT(0x0),
84  fTreeObservableTagging(0x0)
85 
86 {
87  for(Int_t i=0;i<23;i++){
88  fShapesVar[i]=0;}
89  SetMakeGeneralHistograms(kTRUE);
90 }
91 
92 //________________________________________________________________________
94  AliAnalysisTaskEmcalJet(name, kTRUE),
95  fContainer(0),
96  fMinFractionShared(0),
97  fJetShapeType(kGenShapes),
98  fJetShapeSub(kNoSub),
99  fJetSelection(kInclusive),
100  fPtThreshold(-9999.),
101  fRMatching(0.2),
102  fSelectedShapes(0),
103  fminpTTrig(20.),
104  fmaxpTTrig(50.),
105  fangWindowRecoil(0.6),
106  fSemigoodCorrect(0),
107  fHolePos(0),
108  fHoleWidth(0),
109  fCentSelectOn(kTRUE),
110  fCentMin(0),
111  fCentMax(10),
112  fOneConstSelectOn(kFALSE),
113  fDerivSubtrOrder(0),
114  fPhiJetCorr6(0x0),
115  fPhiJetCorr7(0x0),
116  fEtaJetCorr6(0x0),
117  fEtaJetCorr7(0x0),
118  fPtJetCorr(0x0),
119  fPtJet(0x0),
120  fhpTjetpT(0x0),
121  fhPt(0x0),
122  fhPhi(0x0),
123  fNbOfConstvspT(0x0),
124  fTreeObservableTagging(0x0)
125 
126 {
127  // Standard constructor.
128 
129 
130  for(Int_t i=0;i<23;i++){
131  fShapesVar[i]=0;}
132 
134 
135  DefineOutput(1, TList::Class());
136  DefineOutput(2, TTree::Class());
137 
138 
139 }
140 
141 //________________________________________________________________________
143 {
145  delete fTreeObservableTagging;
147  }
148 
149 }
150 
151 //________________________________________________________________________
153 {
154  // Create user output.
156 
157  Bool_t oldStatus = TH1::AddDirectoryStatus();
158  TH1::AddDirectory(oldStatus);
159 
160  //fTreeObservableTagging = new TTree("fTreeJetShape", "fTreeJetShape");
161 
162  //TH1::AddDirectory(oldStatus);
163 
164  const char* nameoutput = GetOutputSlot(2)->GetContainer()->GetName();
165  fTreeObservableTagging = new TTree(nameoutput, nameoutput);
166 
167  const Int_t nVar = 23;
168 
169  TString *fShapesVarNames = new TString [nVar];
170 
171  fShapesVarNames[0] = "partonCode";
172  fShapesVarNames[1] = "ptJet";
173  fShapesVarNames[2] = "ptDJet";
174  fShapesVarNames[3] = "mJet";
175  fShapesVarNames[4] = "nbOfConst";
176  fShapesVarNames[5] = "angularity";
177  fShapesVarNames[6] = "circularity";
178  fShapesVarNames[7] = "lesub";
179  fShapesVarNames[8] = "CoreFraction";
180  fShapesVarNames[9] = "Nsubjet1";
181  fShapesVarNames[10] = "Nsubjet2";
182  fShapesVarNames[11] = "SubjetFraction";
183  fShapesVarNames[12] = "DeltaR";
184  fShapesVarNames[13] = "OpenAngle";
185  fShapesVarNames[14] = "weightPythia";
186 
187  fShapesVarNames[15] = "NT70";
188  fShapesVarNames[16] = "nConstNT70";
189  fShapesVarNames[17] = "NT80";
190  fShapesVarNames[18] = "nConstNT80";
191  fShapesVarNames[19] = "NT90";
192  fShapesVarNames[20] = "nConstNT90";
193  fShapesVarNames[21] = "NT95";
194  fShapesVarNames[22] = "nConstNT95";
195 
196 
197  for(Int_t ivar=0; ivar < nVar; ivar++){
198  cout<<"looping over variables"<<endl;
199  fTreeObservableTagging->Branch(fShapesVarNames[ivar].Data(), &fShapesVar[ivar], Form("%s/F", fShapesVarNames[ivar].Data()));}
200 
201 
202 
203  fPhiJetCorr6= new TH2F("fPhiJetCorr6", "fPhiJetCorr6", 50, 0, 2*TMath::Pi(), 50, 0, 2*TMath::Pi());
204  fOutput->Add(fPhiJetCorr6);
205  fEtaJetCorr6= new TH2F("fEtaJetCorr6", "fEtaJetCorr6", 50, -1.5, 1.5, 50, -1.5, 1.5);
206  fOutput->Add(fEtaJetCorr6);
207 
208  fPhiJetCorr7= new TH2F("fPhiJetCorr7", "fPhiJetCorr7", 50, 0, 2*TMath::Pi(), 50, 0, 2*TMath::Pi());
209  fOutput->Add(fPhiJetCorr7);
210  fEtaJetCorr7= new TH2F("fEtaJetCorr7", "fEtaJetCorr7", 50, -1.5, 1.5, 50, -1.5, 1.5);
211  fOutput->Add(fEtaJetCorr7);
212 
213  fPtJetCorr= new TH2F("fPtJetCorr", "fPtJetCorr", 100, 0, 200, 100, 0, 200);
214  fOutput->Add(fPtJetCorr);
215  fPtJet= new TH1F("fPtJet", "fPtJet", 100, 0, 200);
216  fOutput->Add(fPtJet);
217 
218  fhpTjetpT= new TH2F("fhpTjetpT", "fhpTjetpT", 200, 0, 200, 200, 0, 200);
219  fOutput->Add(fhpTjetpT);
220  fhPt= new TH1F("fhPt", "fhPt", 200, 0, 200);
221  fOutput->Add(fhPt);
222  fhPhi= new TH1F("fhPhi", "fhPhi", 100, -TMath::Pi(), TMath::Pi());
223  fOutput->Add(fhPhi);
224 
225  fNbOfConstvspT=new TH2F("fNbOfConstvspT", "fNbOfConstvspT", 100, 0, 100, 200, 0, 200);
226  fOutput->Add(fNbOfConstvspT);
227 
228  //fOutput->Add(fTreeObservableTagging);
229 
230 
231  PostData(1, fOutput); // Post data for ALL output slots > 0 here
232  PostData(2, fTreeObservableTagging);
233 
234  delete [] fShapesVarNames;
235 
236 }
237 
238 //________________________________________________________________________
240 {
241  // Run analysis code here, if needed. It will be executed before FillHistograms().
242 
243  return kTRUE;
244 }
245 
246 //________________________________________________________________________
248 {
249  // Fill histograms.
250  cout<<"IntoFillHistograms"<<endl;
251  AliEmcalJet* jet1 = NULL;
252  AliJetContainer *jetCont = GetJetContainer(0);
253 
254  Float_t kWeight=1;
255  if (fCentSelectOn)
256  if ((fCent>fCentMax) || (fCent<fCentMin)) return 0;
257 
258  AliAODTrack *triggerHadron = 0x0;
259 
260  if (fJetSelection == kRecoil) {
261  //Printf("Recoil jets!!!, fminpTTrig = %f, fmaxpTTrig = %f", fminpTTrig, fmaxpTTrig);
262  Int_t triggerHadronLabel = SelectTrigger(fminpTTrig, fmaxpTTrig);
263 
264 
265  if (triggerHadronLabel==-99999) {
266  //Printf ("Trigger Hadron not found, return");
267  return 0;}
268 
269 
271  TClonesArray *trackArrayAn = partContAn->GetArray();
272  triggerHadron = static_cast<AliAODTrack*>(trackArrayAn->At(triggerHadronLabel));
273 
274  if (!triggerHadron) {
275  //Printf("No Trigger hadron with the found label!!");
276  return 0;
277  }
278 
279  if(fSemigoodCorrect){
280  Double_t disthole=RelativePhi(triggerHadron->Phi(),fHolePos);
281  if(TMath::Abs(disthole)+fHoleWidth>TMath::Pi()-fangWindowRecoil){
282  return 0;}
283  }
284 
285  fhPt->Fill(triggerHadron->Pt());
286 
287  }
288 
289  if(jetCont) {
290  jetCont->ResetCurrentID();
291  while((jet1 = jetCont->GetNextAcceptJet())) {
292  //Printf("jet1=%p", jet1);
293  if (!jet1) continue;
294  AliEmcalJet* jet2 = 0x0;
295  AliEmcalJet* jet3 = 0x0;
296  fPtJet->Fill(jet1->Pt());
297  AliEmcalJet *jetUS = NULL;
298  Int_t ifound=0, jfound=0;
299  Int_t ilab=-1, jlab=-1;
300 
302  Double_t disthole=RelativePhi(jet1->Phi(),fHolePos);
303  if(TMath::Abs(disthole)<fHoleWidth){
304  continue;
305  }
306  }
307 
308  Float_t dphiRecoil = 0.;
309  if (fJetSelection == kRecoil){
310  dphiRecoil = RelativePhi(triggerHadron->Phi(), jet1->Phi());
311  if (TMath::Abs(dphiRecoil) < (TMath::Pi() - fangWindowRecoil)) {
312  // Printf("Recoil jets back to back not found! continuing");
313  continue;
314  }
315 
316  fhpTjetpT->Fill(triggerHadron->Pt(), jet1->Pt());
317  //Printf(" ************ FILLING HISTOS****** shapeSub = %d, triggerHadron = %f, jet1 = %f", fJetShapeSub, triggerHadron->Pt(), jet1->Pt());
318  fhPhi->Fill(RelativePhi(triggerHadron->Phi(), jet1->Phi()));
319 
320  }
321 
322 
323  fShapesVar[0] = 0.;
324 
325  if (fJetShapeType == kGenShapes){
326  const AliEmcalPythiaInfo *partonsInfo = 0x0;
327  partonsInfo = GetPythiaInfo();
328  //Printf("partonsInfo=%p", partonsInfo);
329  Double_t jp1=RelativePhi(jet1->Phi(),partonsInfo->GetPartonPhi6());
330  Double_t detap1=(jet1->Eta())-(partonsInfo->GetPartonEta6());
331  kWeight=partonsInfo->GetPythiaEventWeight();
332  //Printf("kWeight=%f", kWeight);
333  fShapesVar[14] = kWeight;
334 
335  Float_t dRp1 = TMath::Sqrt(jp1 * jp1 + detap1 * detap1);
336  fEtaJetCorr6->Fill(jet1->Eta(), partonsInfo->GetPartonEta6());
337  fPhiJetCorr6->Fill(jet1->Phi(), partonsInfo->GetPartonPhi6());
338  if(dRp1 < fRMatching) {
339  fShapesVar[0] = partonsInfo->GetPartonFlag6();
340  fPtJetCorr ->Fill(partonsInfo->GetPartonPt6(), jet1->Pt());
341  }
342  else {
343  jp1=RelativePhi(jet1->Phi(),partonsInfo->GetPartonPhi7());
344  detap1=(jet1->Eta())-(partonsInfo->GetPartonEta7());
345  dRp1 = TMath::Sqrt(jp1 * jp1 + detap1 * detap1);
346  fEtaJetCorr7->Fill(jet1->Eta(), partonsInfo->GetPartonEta7());
347  fPhiJetCorr7->Fill(jet1->Phi(), partonsInfo->GetPartonPhi7());
348  if(dRp1 < fRMatching) {
349  fShapesVar[0] = partonsInfo->GetPartonFlag7();
350  fPtJetCorr->Fill(partonsInfo->GetPartonPt7(), jet1->Pt());
351  }
352  else fShapesVar[0]=0;
353  }
354  }
355 
356  Double_t ptSubtracted = 0;
357  ptSubtracted= jet1->Pt();
358  //Printf("ptSubtracted=%f", ptSubtracted);
359 
360 
361  if (ptSubtracted < fPtThreshold) continue;
362 
363  if ((fCentSelectOn == kFALSE) && (jet1->GetNumberOfTracks() <= 1)) continue;
364 
365  AliEmcalJetFinder *Reclusterer1; //Object containg Subjets from Subtracted Hybrid Jets
366  Reclusterer1 = Recluster(jet1, 0, fJetRadius, fSubjetRadius, 1, 0, "SubJetFinder_1");
367 
368  fShapesVar[1] = ptSubtracted;
369  fShapesVar[2] = GetJetpTD(jet1,0);
370  fShapesVar[3] = GetJetMass(jet1,0);
371  fShapesVar[4] = 1.*GetJetNumberOfConstituents(jet1,0);
372  fShapesVar[5] = GetJetAngularity(jet1,0);
373  fShapesVar[6] = GetJetCircularity(jet1,0);
374  fShapesVar[7] = GetJetLeSub(jet1,0);
375  fShapesVar[8] = GetJetCoreFrac(jet1,0);
376  fShapesVar[9] = NSubJettiness(jet1, 0, Reclusterer1, 1, 0, 1);
377  fShapesVar[10]= NSubJettiness(jet1, 0, Reclusterer1, 2, 0, 1);
378  fShapesVar[11]= GetSubjetFraction(jet1,0,fJetRadius,Reclusterer1);
379  fShapesVar[12]= fjNSubJettiness(jet1,0, 2, 0, 1, 2);
380  fShapesVar[13]= fjNSubJettiness(jet1,0, 2, 0, 1, 1);
381 
382  Float_t nTFractions[8]={0.,0.,0.,0.,0.,0.,0.,0.};
383  NTValues(jet1, 0, nTFractions);
384  //shape 14 is pythia weight!
385  for (Int_t ishape=15; ishape<23; ishape++) fShapesVar[ishape] = nTFractions[ishape-15];
386 
387 
388  fTreeObservableTagging->Fill();
389 
390  }
391 
392  }
393 
394  return kTRUE;
395 }
396 
397 //________________________________________________________________________
399  //calc subtracted jet mass
400  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
402  else return jet->GetShapeProperties()->GetSecondOrderSubtracted();
403  else
404  return jet->M();
405 }
406 
407 //________________________________________________________________________
409 
410  AliJetContainer *jetCont = GetJetContainer(jetContNb);
411  if (!jet->GetNumberOfTracks())
412  return 0;
413  Double_t den=0.;
414  Double_t num = 0.;
415  AliVParticle *vp1 = 0x0;
416  for(UInt_t i = 0; i < jet->GetNumberOfTracks(); i++) {
417  vp1 = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
418 
419  if (!vp1){
420  Printf("AliVParticle associated to constituent not found");
421  continue;
422  }
423 
424  Double_t dphi = RelativePhi(vp1->Phi(),jet->Phi());
425  Double_t dr2 = (vp1->Eta()-jet->Eta())*(vp1->Eta()-jet->Eta()) + dphi*dphi;
426  Double_t dr = TMath::Sqrt(dr2);
427  num=num+vp1->Pt()*dr;
428  den=den+vp1->Pt();
429  }
430  return num/den;
431 }
432 
433 //________________________________________________________________________
435 
436  if((fJetShapeSub==kDerivSub) && (jetContNb==0))
439  else
440  return Angularity(jet, jetContNb);
441 
442 }
443 
444 
445 //________________________________________________________________________
446 Float_t AliAnalysisTaskEmcalJetShapesMC::PTD(AliEmcalJet *jet, Int_t jetContNb){
447 
448  AliJetContainer *jetCont = GetJetContainer(jetContNb);
449  if (!jet->GetNumberOfTracks())
450  return 0;
451  Double_t den=0.;
452  Double_t num = 0.;
453  AliVParticle *vp1 = 0x0;
454  for(UInt_t i = 0; i < jet->GetNumberOfTracks(); i++) {
455  vp1 = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
456 
457  if (!vp1){
458  Printf("AliVParticle associated to constituent not found");
459  continue;
460  }
461 
462  num=num+vp1->Pt()*vp1->Pt();
463  den=den+vp1->Pt();
464  }
465  return TMath::Sqrt(num)/den;
466 }
467 
468 //________________________________________________________________________
470  //calc subtracted jet mass
471  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
473  else return jet->GetShapeProperties()->GetSecondOrderSubtractedpTD();
474  else
475  return PTD(jet, jetContNb);
476 
477 }
478 
479 //_____________________________________________________________________________
481 
482  AliJetContainer *jetCont = GetJetContainer(jetContNb);
483  if (!jet->GetNumberOfTracks())
484  return 0;
485  Double_t mxx = 0.;
486  Double_t myy = 0.;
487  Double_t mxy = 0.;
488  int nc = 0;
489  Double_t sump2 = 0.;
490  Double_t pxjet=jet->Px();
491  Double_t pyjet=jet->Py();
492  Double_t pzjet=jet->Pz();
493 
494 
495  //2 general normalized vectors perpendicular to the jet
496  TVector3 ppJ1(pxjet, pyjet, pzjet);
497  TVector3 ppJ3(- pxjet* pzjet, - pyjet * pzjet, pxjet * pxjet + pyjet * pyjet);
498  ppJ3.SetMag(1.);
499  TVector3 ppJ2(-pyjet, pxjet, 0);
500  ppJ2.SetMag(1.);
501  AliVParticle *vp1 = 0x0;
502  for(UInt_t i = 0; i < jet->GetNumberOfTracks(); i++) {
503  vp1 = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
504 
505  if (!vp1){
506  Printf("AliVParticle associated to constituent not found");
507  continue;
508  }
509 
510  TVector3 pp(vp1->Px(), vp1->Py(), vp1->Pz());
511 
512  //local frame
513  TVector3 pLong = pp.Dot(ppJ1) / ppJ1.Mag2() * ppJ1;
514  TVector3 pPerp = pp - pLong;
515  //projection onto the two perpendicular vectors defined above
516 
517  Float_t ppjX = pPerp.Dot(ppJ2);
518  Float_t ppjY = pPerp.Dot(ppJ3);
519  Float_t ppjT = TMath::Sqrt(ppjX * ppjX + ppjY * ppjY);
520  if(ppjT<=0) return 0;
521 
522  mxx += (ppjX * ppjX / ppjT);
523  myy += (ppjY * ppjY / ppjT);
524  mxy += (ppjX * ppjY / ppjT);
525  nc++;
526  sump2 += ppjT;}
527 
528  if(nc<2) return 0;
529  if(sump2==0) return 0;
530  // Sphericity Matrix
531  Double_t ele[4] = {mxx / sump2, mxy / sump2, mxy / sump2, myy / sump2};
532  TMatrixDSym m0(2,ele);
533 
534  // Find eigenvectors
535  TMatrixDSymEigen m(m0);
536  TVectorD eval(2);
537  TMatrixD evecm = m.GetEigenVectors();
538  eval = m.GetEigenValues();
539  // Largest eigenvector
540  int jev = 0;
541  // cout<<eval[0]<<" "<<eval[1]<<endl;
542  if (eval[0] < eval[1]) jev = 1;
543  TVectorD evec0(2);
544  // Principle axis
545  evec0 = TMatrixDColumn(evecm, jev);
546  Double_t compx=evec0[0];
547  Double_t compy=evec0[1];
548  TVector2 evec(compx, compy);
549  Double_t circ=0;
550  if(jev==1) circ=2*eval[0];
551  if(jev==0) circ=2*eval[1];
552 
553  return circ;
554 
555 
556 
557 }
558 
559 
560 
561 
562 //________________________________________________________________________
564  //calc subtracted jet mass
565 
566  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
569  else
570  return Circularity(jet, jetContNb);
571 
572 }
573 
574 //________________________________________________________________________
576 
577  AliJetContainer *jetCont = GetJetContainer(jetContNb);
578  if (!jet->GetNumberOfTracks())
579  return 0;
580  Double_t den=0.;
581  Double_t num = 0.;
582  AliVParticle *vp1 = 0x0;
583  AliVParticle *vp2 = 0x0;
584  std::vector<int> ordindex;
585  ordindex=jet->SortConstituentsPt(jetCont->GetParticleContainer()->GetArray());
586  //Printf("Nbof const = %d", jet->GetNumberOfTracks());
587  //Printf("ordindex[0] = %d, ordindex[1] = %d", ordindex[0], ordindex[1]);
588 
589  if(ordindex.size()<2) return -1;
590 
591  vp1 = static_cast<AliVParticle*>(jet->TrackAt(ordindex[0], jetCont->GetParticleContainer()->GetArray()));
592  if (!vp1){
593  Printf("AliVParticle associated to Leading constituent not found");
594  return -1;
595  }
596 
597  vp2 = static_cast<AliVParticle*>(jet->TrackAt(ordindex[1], jetCont->GetParticleContainer()->GetArray()));
598  if (!vp2){
599  Printf("AliVParticle associated to Subleading constituent not found");
600  return -1;
601  }
602 
603 
604  num=vp1->Pt();
605  den=vp2->Pt();
606  //Printf("vp1->Pt() =%f, vp2->Pt() =%f", vp1->Pt(), vp2->Pt());
607 
608 return num-den;
609 }
610 
611 //________________________________________________________________________
613  //calc subtracted jet mass
614 
615  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
618  else
619  return LeSub(jet, jetContNb);
620 
621 }
622 
623 //________________________________________________________________________
625  //calc subtracted jet mass
626 
627  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
630  else
631  return jet->GetNumberOfTracks();
632 
633  }
634 
635 
636 //________________________________________________________________________
637 AliEmcalJetFinder *AliAnalysisTaskEmcalJetShapesMC::Recluster(AliEmcalJet *Jet, Int_t JetContNb, Double_t JetRadius, Double_t SubJetRadius, Double_t SubJetMinPt, Int_t Algorithm, const char* Name){
638 
639  AliJetContainer *JetCont = GetJetContainer(JetContNb);
640  AliEmcalJetFinder *Reclusterer = new AliEmcalJetFinder(Name); //JetFinder Object for reclustered jets
641  Reclusterer->SetRadius(SubJetRadius);
642  Reclusterer->SetJetMinPt(SubJetMinPt);
643  Reclusterer->SetJetAlgorithm(Algorithm); //0 for anti-kt 1 for kt
644  Reclusterer->SetJetMaxEta(0.9-JetRadius);
645  Reclusterer->SetRecombSheme(0);
646  const AliVVertex *vert = InputEvent()->GetPrimaryVertex();
647 
648  //Double_t dVtx[3]={vert->GetX(),vert->GetY(),vert->GetZ()};
649  Double_t dVtx[3]={0.,0.,0.};
650  if(Reclusterer->AliEmcalJetFinder::Filter(Jet, JetCont, dVtx)){;} //reclustering jet1 using the jetfinderobject Reclusterer
651  return Reclusterer;
652 }
653 
654 
655 
656 //________________________________________________________________________
657 Double_t AliAnalysisTaskEmcalJetShapesMC::NSubJettiness(AliEmcalJet *Jet, Int_t JetContNb, AliEmcalJetFinder *Reclusterer, Int_t N, Int_t A, Int_t B){
658  AliJetContainer *JetCont = GetJetContainer(JetContNb);
659  AliEmcalJet *SubJet=NULL;
660  Double_t DeltaR1=0;
661  Double_t DeltaR2=0;
662  AliVParticle *JetParticle=0x0;
663  Double_t SubJetiness_Numerator = 0;
664  Double_t SubJetiness_Denominator = 0;
665  Double_t Index=-2;
666  Bool_t Error=kFALSE;
667  if (!Jet->GetNumberOfTracks()) return -2;
668  if (Reclusterer->GetNumberOfJets() < N) return -2;
669  for (Int_t i=0; i< Jet->GetNumberOfTracks(); i++){ //loops through all tracks (particles in the jet
670  JetParticle = static_cast<AliVParticle*>(Jet->TrackAt(i, JetCont->GetParticleContainer()->GetArray()));
671  for (Int_t j=1; j<=N; j++){
672  Index=SubJetOrdering(Jet,Reclusterer,j,0,kTRUE);
673  if(Index==-999){
674  Error = kTRUE;
675  i=Jet->GetNumberOfTracks();
676  break;
677  }
678  if(j==1){
679  DeltaR1=TMath::Power((Reclusterer->GetJet(Index)->Pt()),A)*TMath::Power((TMath::Sqrt((((JetParticle->Eta())-(Reclusterer->GetJet(Index)->Eta()))*((JetParticle->Eta())- (Reclusterer->GetJet(Index)->Eta())))+((RelativePhi((Reclusterer->GetJet(Index)->Phi()),JetParticle->Phi()))*(RelativePhi((Reclusterer->GetJet(Index)->Phi()),JetParticle->Phi()))))),B);
680  }
681  else{
682  DeltaR2=TMath::Power((Reclusterer->GetJet(Index)->Pt()),A)*TMath::Power((TMath::Sqrt((((JetParticle->Eta())-(Reclusterer->GetJet(Index)->Eta()))*((JetParticle->Eta())- (Reclusterer->GetJet(Index)->Eta())))+((RelativePhi((Reclusterer->GetJet(Index)->Phi()),JetParticle->Phi()))*(RelativePhi((Reclusterer->GetJet(Index)->Phi()),JetParticle->Phi()))))),B);
683  if (DeltaR2<DeltaR1) DeltaR1=DeltaR2;
684  }
685  }
686  SubJetiness_Numerator=SubJetiness_Numerator+(JetParticle->Pt()*DeltaR1);
687  if (A>=0) SubJetiness_Denominator=SubJetiness_Denominator+(TMath::Power((Reclusterer->GetJet(SubJetOrdering(Jet,Reclusterer,1,0,kTRUE))->Pt()),A)*JetParticle->Pt()*TMath::Power(fJetRadius,B));
688  else SubJetiness_Denominator=SubJetiness_Denominator+(TMath::Power((Reclusterer->GetJet(SubJetOrdering(Jet,Reclusterer,N,0,kTRUE))->Pt()),A)*JetParticle->Pt()*TMath::Power(fJetRadius,B));
689  }
690  if (SubJetiness_Denominator!=0 && !Error) return SubJetiness_Numerator/SubJetiness_Denominator;
691  else return -2;
692 
693 }
694 
695 //----------------------------------------------------------------------
696 Double_t AliAnalysisTaskEmcalJetShapesMC::GetSubjetFraction(AliEmcalJet *Jet, Int_t JetContNb, Double_t JetRadius, AliEmcalJetFinder *Reclusterer){
697  AliJetContainer *JetCont = GetJetContainer(JetContNb);
698  AliEmcalJet *SubJet=NULL;
699  Double_t DeltaR1=0;
700  Double_t DeltaR2=0;
701  AliVParticle *JetParticle=0x0;
702  Double_t SubJetiness_Numerator = 0;
703  Double_t SubJetiness_Denominator = 0;
704  Double_t Index=-2;
705  if (Reclusterer->GetNumberOfJets() < 1) return -2;
706  Index=SubJetOrdering(Jet,Reclusterer,1,0,kTRUE);
707  if(Index==-999) return -2;
708  SubJetiness_Numerator=(Reclusterer->GetJet(Index)->Pt());
709  SubJetiness_Denominator=Jet->Pt();
710  return SubJetiness_Numerator/SubJetiness_Denominator;
711 
712 
713 }
714 //__________________________________________________________________________________
716 
717  AliJetContainer *jetCont = GetJetContainer(jetContNb);
718  if (!jet->GetNumberOfTracks())
719  return 0;
720  Double_t den=0.;
721  Double_t num = 0.;
722  AliVParticle *vp1 = 0x0;
723  for(UInt_t i = 0; i < jet->GetNumberOfTracks(); i++) {
724  vp1 = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
725 
726  if (!vp1){
727  Printf("AliVParticle associated to constituent not found");
728  continue;
729  }
730 
731  Double_t dphi = RelativePhi(vp1->Phi(),jet->Phi());
732  Double_t dr2 = (vp1->Eta()-jet->Eta())*(vp1->Eta()-jet->Eta()) + dphi*dphi;
733  Double_t dr = TMath::Sqrt(dr2);
734  if(dr<=fSubjetRadius) num=num+vp1->Pt();
735 
736  }
737  return num/jet->Pt();
738 }
739 
740 
741 
742 
743 //________________________________________________________________________
745  //calc subtracted jet mass
746 
747  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
750  else
751  return CoreFrac(jet, jetContNb);
752 
753 }
754 
755 
756 
757 
758 //----------------------------------------------------------------------
759 Double_t AliAnalysisTaskEmcalJetShapesMC::SubJetOrdering(AliEmcalJet *Jet, AliEmcalJetFinder *Reclusterer, Int_t N, Int_t Type, Bool_t Index){
760  AliEmcalJet *SubJet=NULL;
761  Double_t SortingVariable;
762  Int_t ArraySize =N+1;
763  TArrayD *JetSorter = new TArrayD(ArraySize);
764  TArrayD *JetIndexSorter = new TArrayD(ArraySize);
765  for (Int_t i=0; i<ArraySize; i++){
766  JetSorter->SetAt(0,i);
767  }
768  for (Int_t i=0; i<ArraySize; i++){
769  JetIndexSorter->SetAt(0,i);
770  }
771  if(Reclusterer->GetNumberOfJets()<N) return -999;
772  for (Int_t i=0; i<Reclusterer->GetNumberOfJets(); i++){
773  SubJet=Reclusterer->GetJet(i);
774  if (Type==0) SortingVariable=SubJet->Pt();
775  else if (Type==1) SortingVariable=SubJet->E();
776  else if (Type==2) SortingVariable=SubJet->M();
777  for (Int_t j=0; j<N; j++){
778  if (SortingVariable>JetSorter->GetAt(j)){
779  for (Int_t k=N-1; k>=j; k--){
780  JetSorter->SetAt(JetSorter->GetAt(k),k+1);
781  JetIndexSorter->SetAt(JetIndexSorter->GetAt(k),k+1);
782  }
783  JetSorter->SetAt(SortingVariable,j);
784  JetIndexSorter->SetAt(i,j);
785  break;
786  }
787  }
788  }
789  if (!Index) return JetSorter->GetAt(N-1);
790  else return JetIndexSorter->GetAt(N-1);
791 }
792 
793 
794 
795 //returns -1 if the Nth hardest jet is requested where N>number of available jets
796 //type: 0=Pt 1=E 2=M
797 //Index TRUE=returns index FALSE=returns value of quantatiy in question
798 
799 
800 
801 
802 
803 //______________________________________________________________________________
805 
806  AliJetContainer *jetCont = GetJetContainer(jetContNb);
807  if (!jet->GetNumberOfTracks())
808  return 0;
809  Double_t mxx = 0.;
810  Double_t myy = 0.;
811  Double_t mxy = 0.;
812  int nc = 0;
813  Double_t sump2 = 0.;
814 
815  AliVParticle *vp1 = 0x0;
816  for(UInt_t i = 0; i < jet->GetNumberOfTracks(); i++) {
817  vp1 = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
818 
819  if (!vp1){
820  Printf("AliVParticle associated to constituent not found");
821  continue;
822  }
823 
824  Double_t ppt=vp1->Pt();
825  Double_t dphi = RelativePhi(vp1->Phi(),jet->Phi());
826 
827  Double_t deta = vp1->Eta()-jet->Eta();
828  mxx += ppt*ppt*deta*deta;
829  myy += ppt*ppt*dphi*dphi;
830  mxy -= ppt*ppt*deta*TMath::Abs(dphi);
831  nc++;
832  sump2 += ppt*ppt;
833 
834  }
835  if(nc<2) return 0;
836  if(sump2==0) return 0;
837  // Sphericity Matrix
838  Double_t ele[4] = {mxx , mxy , mxy , myy };
839  TMatrixDSym m0(2,ele);
840 
841  // Find eigenvectors
842  TMatrixDSymEigen m(m0);
843  TVectorD eval(2);
844  TMatrixD evecm = m.GetEigenVectors();
845  eval = m.GetEigenValues();
846  // Largest eigenvector
847  int jev = 0;
848  // cout<<eval[0]<<" "<<eval[1]<<endl;
849  if (eval[0] < eval[1]) jev = 1;
850  TVectorD evec0(2);
851  // Principle axis
852  evec0 = TMatrixDColumn(evecm, jev);
853  Double_t compx=evec0[0];
854  Double_t compy=evec0[1];
855  TVector2 evec(compx, compy);
856  Double_t sig=0;
857  if(jev==1) sig=TMath::Sqrt(TMath::Abs(eval[0])/sump2);
858  if(jev==0) sig=TMath::Sqrt(TMath::Abs(eval[1])/sump2);
859 
860  return sig;
861 
862 }
863 
864 //________________________________________________________________________
866  //calc subtracted jet mass
867 
868  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
871  else
872  return Sigma2(jet, jetContNb);
873 
874 }
875 
876 
877 //_________________________________________________________________________
878 void AliAnalysisTaskEmcalJetShapesMC::NTValues(AliEmcalJet *jet, Int_t jetContNb, Float_t* nTFractions){
879 
880  AliJetContainer *jetCont = GetJetContainer(jetContNb);
881  if (!jet->GetNumberOfTracks())
882  return;
883 
884  Double_t ptJet = jet->Pt();
885 
886  AliVParticle *vp1 = 0x0;
887  std::vector<int> ordindex;
888  ordindex=jet->SortConstituentsPt(jetCont->GetParticleContainer()->GetArray());
889  //Printf("Nbof const = %d", jet->GetNumberOfTracks());
890  //Printf("ordindex[0] = %d, ordindex[1] = %d", ordindex[0], ordindex[1]);
891  //if(ordindex.size()<2) return -1;
892 
893  for(Int_t iconst =0; iconst<jet->GetNumberOfTracks(); iconst++){
894 
895  vp1 = static_cast<AliVParticle*>(jet->TrackAt(ordindex[iconst], jetCont->GetParticleContainer()->GetArray()));
896  if (!vp1){
897  Printf("AliVParticle associated to Leading constituent not found");
898  return;
899  }
900 
901  if (nTFractions[0] <= 0.7*ptJet){
902  nTFractions[0] += vp1->Pt();
903  nTFractions[1] +=1;
904  }
905 
906  if (nTFractions[2] <= 0.8*ptJet){
907  nTFractions[2] += vp1->Pt();
908  nTFractions[3] +=1;
909  }
910 
911  if (nTFractions[4] <= 0.9*ptJet){
912  nTFractions[4] += vp1->Pt();
913  nTFractions[5] +=1;
914  }
915 
916  if (nTFractions[6] <= 0.95*ptJet){
917  nTFractions[6] += vp1->Pt();
918  nTFractions[7] +=1;
919  }
920  }
921 }
922 //_________________________________________________________________________________________________
923 Double_t AliAnalysisTaskEmcalJetShapesMC::fjNSubJettiness(AliEmcalJet *Jet, Int_t JetContNb, Int_t N, Int_t Algorithm, Double_t Beta, Int_t Option){
924 
925  //WARNING!!! Only works for parent jets that are clustered with Anti-Kt! To change go to AliEmcalJetFinder.cxx and look at the Nsubjettiness() function
926 
927  //Algorithm==0 -> kt_axes;
928  // Algorithm==1 -> ca_axes;
929  //Algorithm==2 -> antikt_0p2_axes;
930  //Algorithm==3 -> wta_kt_axes;
931  //Algorithm==4 -> wta_ca_axes;
932  //Algorithm==5 -> onepass_kt_axes;
933  //Algorithm==6 -> onepass_ca_axes;
934  //Algorithm==7 -> onepass_antikt_0p2_axes;
935  //Algorithm==8 -> onepass_wta_kt_axes;
936  //Algorithm==9 -> onepass_wta_ca_axes;
937  //Algorithm==10 -> min_axes;
938 
939 
940  //Option==0 returns Nsubjettiness Value
941  //Option==1 && N==2 returns opening angle between two subjet axes(Delta R?)
942  //Option==2 && N==2 returns Delta R
943 
944  if (Jet->GetNumberOfTracks()>=N){
945  AliJetContainer *JetCont = GetJetContainer(JetContNb);
946  AliEmcalJetFinder *JetFinder=new AliEmcalJetFinder("Nsubjettiness");
947  JetFinder->SetJetMaxEta(0.9-fJetRadius);
948  JetFinder->SetRadius(fJetRadius);
949  JetFinder->SetJetAlgorithm(0); //0 for anti-kt 1 for kt //this is for the JET!!!!!!!!!! Not the SubJets
950  JetFinder->SetRecombSheme(0);
951  JetFinder->SetJetMinPt(Jet->Pt());
952  const AliVVertex *vert = InputEvent()->GetPrimaryVertex();
953  //Double_t dVtx[3]={vert->GetX(),vert->GetY(),vert->GetZ()};
954  Double_t dVtx[3]={0,0,0};
955  return JetFinder->Nsubjettiness(Jet,JetCont,dVtx,N,Algorithm,fSubjetRadius,Beta,Option);
956 
957  }
958  else return -2;
959 }
960 
961 
962 
963 //________________________________________________________________________
964 Int_t AliAnalysisTaskEmcalJetShapesMC::SelectTrigger(Float_t minpT, Float_t maxpT){
965 
967  TClonesArray *tracksArray = partCont->GetArray();
968 
969  if(!partCont || !tracksArray) return -99999;
970  AliAODTrack *track = 0x0;
971  AliEmcalParticle *emcPart = 0x0;
972 
973 
974  TList *trackList = new TList();
975  Int_t triggers[100];
976  for (Int_t iTrigger=0; iTrigger<100; iTrigger++) triggers[iTrigger] = 0;
977  Int_t iTT = 0;
978 
979  for(Int_t iTrack=0; iTrack <= tracksArray->GetEntriesFast(); iTrack++){
980 
981 
982  if (fJetShapeSub == kConstSub){
983  emcPart = static_cast<AliEmcalParticle*>(tracksArray->At(iTrack));
984  if (!emcPart) continue;
985  if(TMath::Abs(emcPart->Eta())>0.9) continue;
986  if (emcPart->Pt()<0.15) continue;
987 
988  if ((emcPart->Pt() >= minpT) && (emcPart->Pt()< maxpT)) {
989  trackList->Add(emcPart);
990  triggers[iTT] = iTrack;
991  iTT++;
992  }
993  }
994  else{
995  track = static_cast<AliAODTrack*>(tracksArray->At(iTrack));
996  if (!track) continue;
997  if(TMath::Abs(track->Eta())>0.9) continue;
998  if (track->Pt()<0.15) continue;
999  if (!(track->TestFilterBit(768))) continue;
1000 
1001  if ((track->Pt() >= minpT) && (track->Pt()< maxpT)) {
1002  trackList->Add(track);
1003  triggers[iTT] = iTrack;
1004  iTT++;
1005 
1006  }
1007  }
1008  }
1009 
1010  if (iTT == 0) return -99999;
1011  Int_t nbRn = 0, index = 0 ;
1012  TRandom3* random = new TRandom3(0);
1013  nbRn = random->Integer(iTT);
1014 
1015  index = triggers[nbRn];
1016  //Printf("iTT Total= %d, nbRn = %d, Index = %d",iTT, nbRn, index );
1017  return index;
1018 
1019 }
1020 
1021 //__________________________________________________________________________________
1022 Double_t AliAnalysisTaskEmcalJetShapesMC::RelativePhi(Double_t mphi,Double_t vphi){
1023 
1024  if (vphi < -1*TMath::Pi()) vphi += (2*TMath::Pi());
1025  else if (vphi > TMath::Pi()) vphi -= (2*TMath::Pi());
1026  if (mphi < -1*TMath::Pi()) mphi += (2*TMath::Pi());
1027  else if (mphi > TMath::Pi()) mphi -= (2*TMath::Pi());
1028  double dphi = mphi-vphi;
1029  if (dphi < -1*TMath::Pi()) dphi += (2*TMath::Pi());
1030  else if (dphi > TMath::Pi()) dphi -= (2*TMath::Pi());
1031  return dphi;//dphi in [-Pi, Pi]
1032 }
1033 
1034 
1035 //________________________________________________________________________
1037  //
1038  // retrieve event objects
1039  //
1041  return kFALSE;
1042 
1043  return kTRUE;
1044 }
1045 
1046 //_______________________________________________________________________
1048 {
1049  // Called once at the end of the analysis.
1050 
1051  AliInfo("Terminate");
1052  AliAnalysisTaskSE::Terminate();
1053 
1054  fOutput = dynamic_cast<AliEmcalList*> (GetOutputData(1));
1055  if (!fOutput) {
1056  AliError("fOutput not available");
1057  return;
1058  }
1059 
1060  fTreeObservableTagging = dynamic_cast<TTree*>(GetOutputData(2));
1061  if (!fTreeObservableTagging){
1062  Printf("ERROR: fTreeObservableTagging not available");
1063  return;
1064  }
1065 
1066 }
1067 
void SetRadius(Double_t val)
Float_t GetSigma2(AliEmcalJet *jet, Int_t jetContNb=0)
Double_t GetFirstOrderSubtractedAngularity() const
Float_t GetJetMass(AliEmcalJet *jet, Int_t jetContNb=0)
void SetJetMinPt(Double_t val)
Double_t GetSecondOrderSubtractedSigma2() const
Float_t GetPartonEta6() const
AliJetContainer * GetJetContainer(Int_t i=0) const
Float_t GetPartonEta7() const
Double_t GetSecondOrderSubtractedConstituent() const
Double_t Eta() const
Definition: AliEmcalJet.h:88
ClassImp(AliAnalysisTaskEmcalJetShapesMC) AliAnalysisTaskEmcalJetShapesMC
Double_t Py() const
Definition: AliEmcalJet.h:74
Double_t Phi() const
Definition: AliEmcalJet.h:84
Float_t GetPythiaEventWeight() const
Float_t GetPartonPhi7() const
Float_t CoreFrac(AliEmcalJet *jet, Int_t jetContNb=0)
Float_t GetJetCircularity(AliEmcalJet *jet, Int_t jetContNb=0)
Double_t E() const
Definition: AliEmcalJet.h:86
Float_t GetJetpTD(AliEmcalJet *jet, Int_t jetContNb=0)
Double_t NSubJettiness(AliEmcalJet *Jet, Int_t JetContNb, AliEmcalJetFinder *Reclusterer, Int_t N, Int_t A, Int_t B)
Int_t GetPartonFlag7() const
Container for particles within the EMCAL framework.
Float_t GetPartonPhi6() const
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:106
Double_t Px() const
Definition: AliEmcalJet.h:73
Float_t GetJetCoreFrac(AliEmcalJet *jet, Int_t jetContNb=0)
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Double_t fjNSubJettiness(AliEmcalJet *Jet, Int_t JetContNb, Int_t N, Int_t Algorithm, Double_t Beta, Int_t Option)
Int_t GetPartonFlag6() const
AliParticleContainer * GetParticleContainer() const
Double_t GetFirstOrderSubtractedConstituent() const
void SetRecombSheme(Int_t val)
void SetJetAlgorithm(Int_t val)
Double_t Eta() const
Double_t Pt() const
Float_t GetJetNumberOfConstituents(AliEmcalJet *jet, Int_t jetContNb=0)
Double_t Nsubjettiness(AliEmcalJet *pJet, AliJetContainer *pContJets, Double_t dVtx[3], Int_t N, Int_t Algorithm, Double_t Radius, Double_t Beta, Int_t Option=0)
Task to store and correlate the MC shapes.
std::vector< int > SortConstituentsPt(TClonesArray *tracks) const
TTree * fTreeObservableTagging
! Tree with tagging variables subtracted MC or true MC or raw
Double_t RelativePhi(Double_t mphi, Double_t vphi)
Double_t GetSecondOrderSubtractedAngularity() const
Double_t GetSubjetFraction(AliEmcalJet *Jet, Int_t JetContNb, Double_t JetRadius, AliEmcalJetFinder *Reclusterer)
AliEmcalJetFinder * Recluster(AliEmcalJet *Jet, Int_t JetContNb, Double_t JetRadius, Double_t SubJetRadius, Double_t SubJetMinPt, Int_t Algorithm, const char *Name)
Double_t fCent
!event centrality
Float_t PTD(AliEmcalJet *jet, Int_t jetContNb=0)
void SetJetMaxEta(Double_t val)
AliEmcalJet * GetNextAcceptJet()
Bool_t Data(TH1F *h, Double_t *rangefit, Bool_t writefit, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmafit, Int_t &status)
Float_t GetJetAngularity(AliEmcalJet *jet, Int_t jetContNb=0)
Int_t SelectTrigger(Float_t minpT, Float_t maxpT)
AliEmcalJet * GetJet(Int_t index)
Double_t Pt() const
Definition: AliEmcalJet.h:76
Enhanced TList-derived class that implements correct merging for pt_hard binned production.
Definition: AliEmcalList.h:23
Float_t Angularity(AliEmcalJet *jet, Int_t jetContNb=0)
Double_t GetFirstOrderSubtractedCircularity() const
AliEmcalList * fOutput
!output list
Double_t SubJetOrdering(AliEmcalJet *Jet, AliEmcalJetFinder *Reclusterer, Int_t N, Int_t Type, Bool_t Index)
Short_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:127
void NTValues(AliEmcalJet *jet, Int_t jetContNb, Float_t *nTFractions)
const Int_t nVar
Double_t GetSecondOrderSubtractedCircularity() const
Float_t GetJetLeSub(AliEmcalJet *jet, Int_t jetContNb=0)
Store some informaion about a Pythia eventThis class is used to store some information about a Pythia...
void SetMakeGeneralHistograms(Bool_t g)
Base task in the EMCAL jet framework.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
const AliEmcalPythiaInfo * GetPythiaInfo() const
Double_t Pz() const
Definition: AliEmcalJet.h:75
Float_t Circularity(AliEmcalJet *jet, Int_t jetContNb=0)
Declaration of class AliEmcalPythiaInfo.
Double_t GetFirstOrderSubtractedSigma2() const
Float_t Sigma2(AliEmcalJet *jet, Int_t jetContNb=0)
AliEmcalJetShapeProperties * GetShapeProperties() const
Definition: AliEmcalJet.h:227
Float_t GetPartonPt7() const
Float_t LeSub(AliEmcalJet *jet, Int_t jetContNb=0)
Double_t M() const
Definition: AliEmcalJet.h:87
Container for jet within the EMCAL jet framework.
Float_t GetPartonPt6() const