AliPhysics  cc1c0ba (cc1c0ba)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalQGTagging.cxx
Go to the documentation of this file.
1 //
2 // Jet QG tagging analysis task.
3 //
4 // Author: D. Caffarri, L. Cunqueiro
5 //just testing
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 
42 
43 
44 #include "AliAODEvent.h"
46 
47 using std::cout;
48 using std::endl;
49 
51 
52 //________________________________________________________________________
55  fContainer(0),
56  fMinFractionShared(0),
57  fJetShapeType(kData),
58  fJetShapeSub(kNoSub),
59  fJetSelection(kInclusive),
60  fPtThreshold(-9999.),
61  fRMatching(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  fh2ResponseUW(0x0),
75  fh2ResponseW(0x0),
76  fPhiJetCorr6(0x0),
77  fPhiJetCorr7(0x0),
78  fEtaJetCorr6(0x0),
79  fEtaJetCorr7(0x0),
80  fPtJetCorr(0x0),
81  fPtJet(0x0),
82  fhpTjetpT(0x0),
83  fhPt(0x0),
84  fhPhi(0x0),
85  fHLundIterative(0x0),
86  fNbOfConstvspT(0x0),
87  fTreeObservableTagging(0)
88 
89 {
90  for(Int_t i=0;i<17;i++){
91  fShapesVar[i]=0;}
92  SetMakeGeneralHistograms(kTRUE);
93  DefineOutput(1, TList::Class());
94  DefineOutput(2, TTree::Class());
95 }
96 
97 //________________________________________________________________________
99  AliAnalysisTaskEmcalJet(name, kTRUE),
100  fContainer(0),
101  fMinFractionShared(0),
102  fJetShapeType(kData),
103  fJetShapeSub(kNoSub),
104  fJetSelection(kInclusive),
105  fPtThreshold(-9999.),
106  fRMatching(0.2),
107  fSelectedShapes(0),
108  fminpTTrig(20.),
109  fmaxpTTrig(50.),
110  fangWindowRecoil(0.6),
111  fSemigoodCorrect(0),
112  fHolePos(0),
113  fHoleWidth(0),
114  fCentSelectOn(kTRUE),
115  fCentMin(0),
116  fCentMax(10),
117  fOneConstSelectOn(kFALSE),
118  fDerivSubtrOrder(0),
119  fh2ResponseUW(0x0),
120  fh2ResponseW(0x0),
121  fPhiJetCorr6(0x0),
122  fPhiJetCorr7(0x0),
123  fEtaJetCorr6(0x0),
124  fEtaJetCorr7(0x0),
125  fPtJetCorr(0x0),
126  fPtJet(0x0),
127  fhpTjetpT(0x0),
128  fhPt(0x0),
129  fhPhi(0x0),
130  fHLundIterative(0x0),
131  fNbOfConstvspT(0x0),
132  fTreeObservableTagging(0)
133 
134 {
135  // Standard constructor.
136  for(Int_t i=0;i<17;i++){
137  fShapesVar[i]=0;}
139 
140  DefineOutput(1, TList::Class());
141  DefineOutput(2, TTree::Class());
142 }
143 
144 //________________________________________________________________________
146 {
147  // Destructor.
148 }
149 
150 //________________________________________________________________________
152 {
153  // Create user output.
154 
156 
157  Bool_t oldStatus = TH1::AddDirectoryStatus();
158  TH1::AddDirectory(kFALSE);
159 
160 
161 
162 
163  fh2ResponseUW= new TH2F("fh2ResponseUW", "fh2ResponseUW", 100, 0, 200, 100, 0, 200);
164  fOutput->Add(fh2ResponseUW);
165  fh2ResponseW= new TH2F("fh2ResponseW", "fh2ResponseW", 100, 0, 200, 100, 0, 200);
166  fOutput->Add(fh2ResponseW);
167  fPhiJetCorr6= new TH2F("fPhiJetCorr6", "fPhiJetCorr6", 50, 0, 2*TMath::Pi(), 50, 0, 2*TMath::Pi());
168  fOutput->Add(fPhiJetCorr6);
169  fEtaJetCorr6= new TH2F("fEtaJetCorr6", "fEtaJetCorr6", 50, -1.5, 1.5, 50, -1.5, 1.5);
170  fOutput->Add(fEtaJetCorr6);
171 
172  fPhiJetCorr7= new TH2F("fPhiJetCorr7", "fPhiJetCorr7", 50, 0, 2*TMath::Pi(), 50, 0, 2*TMath::Pi());
173  fOutput->Add(fPhiJetCorr7);
174  fEtaJetCorr7= new TH2F("fEtaJetCorr7", "fEtaJetCorr7", 50, -1.5, 1.5, 50, -1.5, 1.5);
175  fOutput->Add(fEtaJetCorr7);
176 
177  fPtJetCorr= new TH2F("fPtJetCorr", "fPtJetCorr", 100, 0, 200, 100, 0, 200);
178  fOutput->Add(fPtJetCorr);
179  fPtJet= new TH1F("fPtJet", "fPtJet", 100, 0, 200);
180  fOutput->Add(fPtJet);
181 
182  fhpTjetpT= new TH2F("fhpTjetpT", "fhpTjetpT", 200, 0, 200, 200, 0, 200);
183  fOutput->Add(fhpTjetpT);
184  fhPt= new TH1F("fhPt", "fhPt", 200, 0, 200);
185  fOutput->Add(fhPt);
186  fhPhi= new TH1F("fhPhi", "fhPhi", 100, -TMath::Pi(), TMath::Pi());
187  fOutput->Add(fhPhi);
188 
189  //log(1/theta),log(z*theta),jetpT,algo//
190  const Int_t dimSpec = 4;
191  const Int_t nBinsSpec[4] = {100,100,20,2};
192  const Double_t lowBinSpec[4] = {0.0,-10, 0,0};
193  const Double_t hiBinSpec[4] = {5.0, 0,200,2};
194  fHLundIterative = new THnSparseF("fHLundIterative",
195  "LundIterativePlot [log(1/theta),log(z*theta),pTjet,algo]",
196  dimSpec,nBinsSpec,lowBinSpec,hiBinSpec);
197  fOutput->Add(fHLundIterative);
198 
199  fNbOfConstvspT=new TH2F("fNbOfConstvspT", "fNbOfConstvspT", 100, 0, 100, 200, 0, 200);
200  fOutput->Add(fNbOfConstvspT);
201 
202  // =========== Switch on Sumw2 for all histos ===========
203  for (Int_t i=0; i<fOutput->GetEntries(); ++i) {
204  TH1 *h1 = dynamic_cast<TH1*>(fOutput->At(i));
205  if (h1){
206  h1->Sumw2();
207  continue;
208  }
209  THnSparse *hn = dynamic_cast<THnSparse*>(fOutput->At(i));
210  if(hn)hn->Sumw2();
211  }
212 
213 
214  TH1::AddDirectory(oldStatus);
215  const Int_t nVar = 17;
216  const char* nameoutput = GetOutputSlot(2)->GetContainer()->GetName();
217  fTreeObservableTagging = new TTree(nameoutput, nameoutput);
218 
219 
220  TString *fShapesVarNames = new TString [nVar];
221 
222  fShapesVarNames[0] = "partonCode";
223  fShapesVarNames[1] = "ptJet";
224  fShapesVarNames[2] = "ptDJet";
225  fShapesVarNames[3] = "mJet";
226  // fShapesVarNames[4] = "nbOfConst";
227  fShapesVarNames[4] = "angularity";
228  fShapesVarNames[5] = "circularity";
229  fShapesVarNames[6] = "lesub";
230  fShapesVarNames[7] = "coronna";
231 
232  fShapesVarNames[8] = "ptJetMatch";
233  fShapesVarNames[9] = "ptDJetMatch";
234  fShapesVarNames[10] = "mJetMatch";
235  // fShapesVarNames[12] = "nbOfConstMatch";
236  fShapesVarNames[11] = "angularityMatch";
237  fShapesVarNames[12] = "circularityMatch";
238  fShapesVarNames[13] = "lesubMatch";
239  fShapesVarNames[14] = "coronnaMatch";
240  fShapesVarNames[15]="weightPythia";
241  //fShapesVarNames[14]="ntrksEvt";
242  //fShapesVarNames[16]="rhoVal";
243  //fShapesVarNames[17]="rhoMassVal";
244  fShapesVarNames[16]="ptUnsub";
245 
246  for(Int_t ivar=0; ivar < nVar; ivar++){
247  cout<<"looping over variables"<<endl;
248  fTreeObservableTagging->Branch(fShapesVarNames[ivar].Data(), &fShapesVar[ivar], Form("%s/F", fShapesVarNames[ivar].Data()));}
249 
250  PostData(1,fOutput);
251  PostData(2,fTreeObservableTagging);
252 
253  delete [] fShapesVarNames;
254 }
255 
256 //________________________________________________________________________
258 {
259  // Run analysis code here, if needed. It will be executed before FillHistograms().
260 
261  return kTRUE;
262 }
263 
264 //________________________________________________________________________
266 {
267  // Fill histograms.
268  //cout<<"base container"<<endl;
269  AliEmcalJet* jet1 = NULL;
270  AliJetContainer *jetCont = GetJetContainer(0);
271 
272  Float_t kWeight=1;
273  if (fCentSelectOn)
274  if ((fCent>fCentMax) || (fCent<fCentMin)) return 0;
275 
276  AliAODTrack *triggerHadron = 0x0;
277 
278  if (fJetSelection == kRecoil) {
279  //Printf("Recoil jets!!!, fminpTTrig = %f, fmaxpTTrig = %f", fminpTTrig, fmaxpTTrig);
280  Int_t triggerHadronLabel = SelectTrigger(fminpTTrig, fmaxpTTrig);
281 
282 
283  if (triggerHadronLabel==-99999) {
284  //Printf ("Trigger Hadron not found, return");
285  return 0;}
286 
287  AliTrackContainer *PartCont =NULL;
288  AliParticleContainer *PartContMC=NULL;
289 
290  if (fJetShapeSub==kConstSub){
292  else PartCont = GetTrackContainer(1);
293  }
294  else{
296  else PartCont = GetTrackContainer(0);
297  }
298  TClonesArray *TrackArray = NULL;
299  TClonesArray *TrackArrayMC = NULL;
300  if (fJetShapeType == AliAnalysisTaskEmcalQGTagging::kGenOnTheFly) TrackArrayMC = PartContMC->GetArray();
301  else TrackArray = PartCont->GetArray();
302  if (fJetShapeType == AliAnalysisTaskEmcalQGTagging::kGenOnTheFly) triggerHadron = static_cast<AliAODTrack*>(TrackArrayMC->At(triggerHadronLabel));
303  else triggerHadron = static_cast<AliAODTrack*>(TrackArray->At(triggerHadronLabel));
304 
305 
306 
307 
308 
309  if (!triggerHadron) {
310  //Printf("No Trigger hadron with the found label!!");
311  return 0;
312  }
313 
314  if(fSemigoodCorrect){
315  Double_t disthole=RelativePhi(triggerHadron->Phi(),fHolePos);
316  if(TMath::Abs(disthole)+fHoleWidth>TMath::Pi()-fangWindowRecoil){
317  return 0;}
318  }
319 
320  fhPt->Fill(triggerHadron->Pt());
321 
322  }
323 
324 
326  TClonesArray *trackArrayAn = partContAn->GetArray();
327  Int_t ntracksEvt = trackArrayAn->GetEntriesFast();
328 
329  Float_t rhoVal=0, rhoMassVal = 0.;
330  if(jetCont) {
331 
332  jetCont->ResetCurrentID();
334  //rho
335  AliRhoParameter* rhoParam = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject("RhoSparseR020"));
336  if (!rhoParam) {
337  Printf("%s: Could not retrieve rho %s (some histograms will be filled with zero)!", GetName(), jetCont->GetRhoName().Data());
338  } else rhoVal = rhoParam->GetVal();
339  //rhom
340  AliRhoParameter* rhomParam = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject("RhoMassSparseR020"));
341  if (!rhomParam) {
342  Printf("%s: Could not retrieve rho_m %s (some histograms will be filled with zero)!", GetName(), jetCont->GetRhoMassName().Data());
343  } else rhoMassVal = rhomParam->GetVal();
344  }
345 
346  while((jet1 = jetCont->GetNextAcceptJet())) {
347  if (!jet1) continue;
348  AliEmcalJet* jet2 = 0x0;
349  AliEmcalJet* jet3 = 0x0;
350  fPtJet->Fill(jet1->Pt());
351  AliEmcalJet *jetUS = NULL;
352  Int_t ifound=0, jfound=0;
353  Int_t ilab=-1, jlab=-1;
354 
356  Double_t disthole=RelativePhi(jet1->Phi(),fHolePos);
357  if(TMath::Abs(disthole)<fHoleWidth){
358  continue;}
359  }
360 
361  Float_t dphiRecoil = 0.;
362  if (fJetSelection == kRecoil){
363  dphiRecoil = RelativePhi(triggerHadron->Phi(), jet1->Phi());
364  if (TMath::Abs(dphiRecoil) < (TMath::Pi() - fangWindowRecoil)) {
365  // Printf("Recoil jets back to back not found! continuing");
366  continue;
367  }
368 
369  fhpTjetpT->Fill(triggerHadron->Pt(), jet1->Pt());
370  //Printf(" ************ FILLING HISTOS****** shapeSub = %d, triggerHadron = %f, jet1 = %f", fJetShapeSub, triggerHadron->Pt(), jet1->Pt());
371  fhPhi->Fill(RelativePhi(triggerHadron->Phi(), jet1->Phi()));
372 
373  }
374 
375 
376  fShapesVar[0] = 0.;
378  AliJetContainer *jetContTrue = GetJetContainer(1);
379  AliJetContainer *jetContUS = GetJetContainer(2);
380 
381  if(fJetShapeSub==kConstSub){
382  for(Int_t i = 0; i<jetContUS->GetNJets(); i++) {
383  jetUS = jetContUS->GetJet(i);
384  if(jetUS->GetLabel()==jet1->GetLabel()) {
385  ifound++;
386  if(ifound==1) ilab = i;
387  }
388  }
389  if(ilab==-1) continue;
390  jetUS=jetContUS->GetJet(ilab);
391  jet2=jetUS->ClosestJet();
392  }
393 
394  if(!(fJetShapeSub==kConstSub)) jet2 = jet1->ClosestJet();
395  if (!jet2) {
396  Printf("jet2 does not exist, returning");
397  continue;
398  }
399 
400  AliJetContainer *jetContPart=GetJetContainer(3);
401  jet3=jet2->ClosestJet();
402 
403  if(!jet3){
404  Printf("jet3 does not exist, returning");
405  continue;
406  }
407  cout<<"jet 3 exists"<<jet3->Pt()<<endl;
408 
409 
410  fh2ResponseUW->Fill(jet1->Pt(),jet2->Pt());
411 
412  Double_t fraction=0;
413  if(!(fJetShapeSub==kConstSub)) fraction = jetCont->GetFractionSharedPt(jet1);
414  if(fJetShapeSub==kConstSub) fraction = jetContUS->GetFractionSharedPt(jetUS);
415  //if (fraction > 0.1) cout<<"***** hey a jet matched with fraction"<<fraction<<" "<<jet1->Pt()<<" "<<jet2->Pt()<<" "<<fCent<<endl;
416 
417  if(fraction<fMinFractionShared) continue;
418  //InputEvent()->Print();
419 
420  }
421 
422 
423 
424  if (fJetShapeType == kPythiaDef){
425 
426  AliJetContainer *jetContTrue = GetJetContainer(1);
427  AliJetContainer *jetContUS = GetJetContainer(2);
428  AliJetContainer *jetContPart = GetJetContainer(3);
429 
430  if(fJetShapeSub==kConstSub){
431 
432  for(Int_t i = 0; i<jetContUS->GetNJets(); i++) {
433  jetUS = jetContUS->GetJet(i);
434  if(jetUS->GetLabel()==jet1->GetLabel()) {
435  ifound++;
436  if(ifound==1) ilab = i;
437  }
438  }
439  if(ilab==-1) continue;
440  jetUS=jetContUS->GetJet(ilab);
441  jet2=jetUS->ClosestJet();
442 
443  if (!jet2) {
444  Printf("jet2 does not exist, returning");
445  continue;
446  }
447 
448  for(Int_t j=0; j<jetContPart->GetNJets(); j++) {
449 
450  jet3 = jetContPart->GetJet(j);
451  if(!jet3) continue;
452  if(jet3->GetLabel()==jet2->GetLabel()) {
453  jfound++;
454  if(jfound==1) jlab = j;
455  }
456  }
457  if(jlab==-1) continue;
458  jet3=jetContPart->GetJet(jlab);
459  if(!jet3){
460  Printf("jet3 does not exist, returning");
461  continue;
462  }
463  }
464  if(!(fJetShapeSub==kConstSub)) jet3 = jet1->ClosestJet();
465  if (!jet3) {
466  Printf("jet3 does not exist, returning");
467  continue;
468  }
469 
470 
471  fh2ResponseUW->Fill(jet1->Pt(),jet3->Pt());
472 
473 
474  }
475 
476 
477  if (fJetShapeType == kGenOnTheFly){
478  const AliEmcalPythiaInfo *partonsInfo = 0x0;
479  partonsInfo = GetPythiaInfo();
480  Double_t jp1=RelativePhi(jet1->Phi(),partonsInfo->GetPartonPhi6());
481  Double_t detap1=(jet1->Eta())-(partonsInfo->GetPartonEta6());
482  kWeight=partonsInfo->GetPythiaEventWeight();
483  fh2ResponseW->Fill(jet1->Pt(),jet1->Pt(),kWeight);
484 
485  Float_t dRp1 = TMath::Sqrt(jp1 * jp1 + detap1 * detap1);
486  fEtaJetCorr6->Fill(jet1->Eta(), partonsInfo->GetPartonEta6());
487  fPhiJetCorr6->Fill(jet1->Phi(), partonsInfo->GetPartonPhi6());
488  if(dRp1 < fRMatching) {
489  fShapesVar[0] = partonsInfo->GetPartonFlag6();
490  fPtJetCorr ->Fill(partonsInfo->GetPartonPt6(), jet1->Pt());
491  }
492  else {
493  jp1=RelativePhi(jet1->Phi(),partonsInfo->GetPartonPhi7());
494  detap1=(jet1->Eta())-(partonsInfo->GetPartonEta7());
495  dRp1 = TMath::Sqrt(jp1 * jp1 + detap1 * detap1);
496  fEtaJetCorr7->Fill(jet1->Eta(), partonsInfo->GetPartonEta7());
497  fPhiJetCorr7->Fill(jet1->Phi(), partonsInfo->GetPartonPhi7());
498  if(dRp1 < fRMatching) {
499  fShapesVar[0] = partonsInfo->GetPartonFlag7();
500  fPtJetCorr->Fill(partonsInfo->GetPartonPt7(), jet1->Pt());
501  }
502  else fShapesVar[0]=0;
503  }
504  }
505 
506 
507 
508 
509  Double_t ptSubtracted = 0;
510  if (fJetShapeSub==kConstSub) ptSubtracted= jet1->Pt();
511 
512  else if (fJetShapeSub==kDerivSub) {
513  ptSubtracted=jet1->Pt()-GetRhoVal(0)*jet1->Area();
514  }
515 
516  else if (fJetShapeSub==kNoSub) {
517  if ((fJetShapeType==kData) || (fJetShapeType==kDetEmbPartPythia)) ptSubtracted=jet1->Pt()-GetRhoVal(0)*jet1->Area();
518  else if ((fJetShapeType==kPythiaDef) || (fJetShapeType==kMCTrue) || (fJetShapeType==kGenOnTheFly)) ptSubtracted= jet1->Pt();
519  }
520 
521  //Printf("ptSubtracted=%f,fPtThreshold =%f ", ptSubtracted, fPtThreshold);
522  if (ptSubtracted < fPtThreshold) continue;
523 
524  if (fOneConstSelectOn == kTRUE) fNbOfConstvspT->Fill(GetJetNumberOfConstituents(jet1,0), ptSubtracted);
525  if ((fCentSelectOn == kFALSE) && (jet1->GetNumberOfTracks() <= 1)) continue;
526 
527 
528  fShapesVar[1] = ptSubtracted;
529  fShapesVar[2] = GetJetpTD(jet1,0);
530  fShapesVar[3] = GetJetMass(jet1,0);
531  fShapesVar[4] = GetJetAngularity(jet1,0);
532  fShapesVar[5] = GetJetCircularity(jet1,0);
533  fShapesVar[6] = GetJetLeSub(jet1,0);
534  fShapesVar[6] = GetJetCoronna(jet1,0);
535  RecursiveParents(jet1,jetCont,0);
536  RecursiveParents(jet1,jetCont,1);
537 
538  Float_t ptMatch=0., ptDMatch=0., massMatch=0., constMatch=0.,angulMatch=0.,circMatch=0., lesubMatch=0., sigma2Match=0., coronnaMatch=0;
539  Int_t kMatched = 0;
540 
541  if (fJetShapeType==kPythiaDef) {
542  kMatched =1;
543  if(fJetShapeSub==kConstSub) kMatched = 3;
544 
545  ptMatch=jet3->Pt();
546  ptDMatch=GetJetpTD(jet3, kMatched);
547  massMatch=GetJetMass(jet3,kMatched);
548  //constMatch=1.*GetJetNumberOfConstituents(jet2,kMatched);
549  angulMatch=GetJetAngularity(jet3, kMatched);
550  circMatch=GetJetCircularity(jet3, kMatched);
551  lesubMatch=GetJetLeSub(jet3, kMatched);
552  coronnaMatch=GetJetCoronna(jet3,kMatched);
553  //sigma2Match = GetSigma2(jet2, kMatched);
554  }
555 
557  if(fJetShapeSub==kConstSub) kMatched = 3;
558  if(fJetShapeSub==kDerivSub) kMatched = 2;
559  ptMatch=jet3->Pt();
560  ptDMatch=GetJetpTD(jet3, kMatched);
561  massMatch=GetJetMass(jet3,kMatched);
562  // constMatch=1.*GetJetNumberOfConstituents(jet3,kMatched);
563  angulMatch=GetJetAngularity(jet3, kMatched);
564  circMatch=GetJetCircularity(jet3, kMatched);
565  lesubMatch=GetJetLeSub(jet3, kMatched);
566  coronnaMatch = GetJetCoronna(jet3, kMatched);
567 
568  }
569 
570 
571 
573  kMatched = 0;
574  ptMatch=0.;
575  ptDMatch=0.;
576  massMatch=0.;
577  //constMatch=0.;
578  angulMatch=0.;
579  circMatch=0.;
580  lesubMatch=0.;
581  coronnaMatch =0.;
582 
583  }
584 
585 
586 
587  fShapesVar[8] = ptMatch;
588  fShapesVar[9] = ptDMatch;
589  fShapesVar[10] = massMatch;
590  fShapesVar[11] = angulMatch;
591  fShapesVar[12] = circMatch;
592  fShapesVar[13] = lesubMatch;
593  fShapesVar[14] = coronnaMatch;
594  fShapesVar[15] = kWeight;
595  //fShapesVar[16] = ntracksEvt;
596  // fShapesVar[16] = rhoVal;
597  //fShapesVar[17] = rhoMassVal;
598  fShapesVar[16] = jet1->Pt();
599 
600 
601  fTreeObservableTagging->Fill();
602 
603 
604 
605 
606 
607 
608  }
609 
610  }
611 
612  return kTRUE;
613 }
614 
615 //________________________________________________________________________
617  //calc subtracted jet mass
618  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
620  else return jet->GetShapeProperties()->GetSecondOrderSubtracted();
621  else
622  return jet->M();
623 }
624 
625 //________________________________________________________________________
627 
628  AliJetContainer *jetCont = GetJetContainer(jetContNb);
629  if (!jet->GetNumberOfTracks())
630  return 0;
631  Double_t den=0.;
632  Double_t num = 0.;
633  AliVParticle *vp1 = 0x0;
634  for(UInt_t i = 0; i < jet->GetNumberOfTracks(); i++) {
635  vp1 = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
636 
637  if (!vp1){
638  Printf("AliVParticle associated to constituent not found");
639  continue;
640  }
641 
642  Double_t dphi = RelativePhi(vp1->Phi(),jet->Phi());
643  Double_t dr2 = (vp1->Eta()-jet->Eta())*(vp1->Eta()-jet->Eta()) + dphi*dphi;
644  Double_t dr = TMath::Sqrt(dr2);
645  num=num+vp1->Pt()*dr;
646  den=den+vp1->Pt();
647  }
648  return num/den;
649 }
650 
651 //________________________________________________________________________
653 
654  if((fJetShapeSub==kDerivSub) && (jetContNb==0))
657  else
658  return Angularity(jet, jetContNb);
659 
660 }
661 
662 //____________________________________________________________________________
663 
665 
666  AliTrackContainer *PartCont = NULL;
667  AliParticleContainer *PartContMC = NULL;
668 
669 
670  if (fJetShapeSub==kConstSub){
672  else PartCont = GetTrackContainer(1);
673  }
674  else{
676  else PartCont = GetTrackContainer(0);
677  }
678 
679  TClonesArray *TracksArray = NULL;
680  TClonesArray *TracksArrayMC = NULL;
681 
682  if (fJetShapeType == AliAnalysisTaskEmcalQGTagging::kGenOnTheFly) TracksArrayMC = PartContMC->GetArray();
683  else TracksArray = PartCont->GetArray();
684 
686  if(!PartContMC || !TracksArrayMC) return -2;
687  }
688  else {
689  if(!PartCont || !TracksArray) return -2;
690  }
691 
692 
693  AliAODTrack *Track = 0x0;
694  Float_t sumpt=0;
695  Int_t NTracks=0;
696  if (fJetShapeType == AliAnalysisTaskEmcalQGTagging::kGenOnTheFly) NTracks = TracksArrayMC->GetEntriesFast();
697  else NTracks = TracksArray->GetEntriesFast();
698 
699  for(Int_t i=0; i < NTracks; i++){
701  if((Track = static_cast<AliAODTrack*>(PartContMC->GetAcceptParticle(i)))){
702  if (!Track) continue;
703  if(TMath::Abs(Track->Eta())>0.9) continue;
704  Double_t dphi = RelativePhi(Track->Phi(),jet->Phi());
705  Double_t dr2 = (Track->Eta()-jet->Eta())*(Track->Eta()-jet->Eta()) + dphi*dphi;
706  Double_t dr = TMath::Sqrt(dr2);
707  if((dr>=0.8) && (dr<1)) sumpt=sumpt+Track->Pt();
708  }
709  }
710  else{
711  if((Track = static_cast<AliAODTrack*>(PartCont->GetAcceptTrack(i)))){
712  if (!Track) continue;
713  if(TMath::Abs(Track->Eta())>0.9) continue;
714  if (Track->Pt()<0.15) continue;
715  Double_t dphi = RelativePhi(Track->Phi(),jet->Phi());
716  Double_t dr2 = (Track->Eta()-jet->Eta())*(Track->Eta()-jet->Eta()) + dphi*dphi;
717  Double_t dr = TMath::Sqrt(dr2);
718  if((dr>=0.8) && (dr<1)) sumpt=sumpt+Track->Pt();
719 
720  }
721  }
722  }
723 
724 
725 
726  return sumpt;
727 
728 
729 
730 
731 }
732 
733 //________________________________________________________________________
735 
736  if((fJetShapeSub==kDerivSub) && (jetContNb==0)) return -2;
737  else
738  return Coronna(jet, jetContNb);
739 
740 }
741 
742 
743 
744 
745 
746 //________________________________________________________________________
748 
749  AliJetContainer *jetCont = GetJetContainer(jetContNb);
750  if (!jet->GetNumberOfTracks())
751  return 0;
752  Double_t den=0.;
753  Double_t num = 0.;
754  AliVParticle *vp1 = 0x0;
755  for(UInt_t i = 0; i < jet->GetNumberOfTracks(); i++) {
756  vp1 = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
757 
758  if (!vp1){
759  Printf("AliVParticle associated to constituent not found");
760  continue;
761  }
762 
763  num=num+vp1->Pt()*vp1->Pt();
764  den=den+vp1->Pt();
765  }
766  return TMath::Sqrt(num)/den;
767 }
768 
769 //________________________________________________________________________
771  //calc subtracted jet mass
772  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
774  else return jet->GetShapeProperties()->GetSecondOrderSubtractedpTD();
775  else
776  return PTD(jet, jetContNb);
777 
778 }
779 
780 //_____________________________________________________________________________
782 
783  AliJetContainer *jetCont = GetJetContainer(jetContNb);
784  if (!jet->GetNumberOfTracks())
785  return 0;
786  Double_t mxx = 0.;
787  Double_t myy = 0.;
788  Double_t mxy = 0.;
789  int nc = 0;
790  Double_t sump2 = 0.;
791  Double_t pxjet=jet->Px();
792  Double_t pyjet=jet->Py();
793  Double_t pzjet=jet->Pz();
794 
795 
796  //2 general normalized vectors perpendicular to the jet
797  TVector3 ppJ1(pxjet, pyjet, pzjet);
798  TVector3 ppJ3(- pxjet* pzjet, - pyjet * pzjet, pxjet * pxjet + pyjet * pyjet);
799  ppJ3.SetMag(1.);
800  TVector3 ppJ2(-pyjet, pxjet, 0);
801  ppJ2.SetMag(1.);
802  AliVParticle *vp1 = 0x0;
803  for(UInt_t i = 0; i < jet->GetNumberOfTracks(); i++) {
804  vp1 = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
805 
806  if (!vp1){
807  Printf("AliVParticle associated to constituent not found");
808  continue;
809  }
810 
811  TVector3 pp(vp1->Px(), vp1->Py(), vp1->Pz());
812 
813  //local frame
814  TVector3 pLong = pp.Dot(ppJ1) / ppJ1.Mag2() * ppJ1;
815  TVector3 pPerp = pp - pLong;
816  //projection onto the two perpendicular vectors defined above
817 
818  Float_t ppjX = pPerp.Dot(ppJ2);
819  Float_t ppjY = pPerp.Dot(ppJ3);
820  Float_t ppjT = TMath::Sqrt(ppjX * ppjX + ppjY * ppjY);
821  if(ppjT<=0) return 0;
822 
823  mxx += (ppjX * ppjX / ppjT);
824  myy += (ppjY * ppjY / ppjT);
825  mxy += (ppjX * ppjY / ppjT);
826  nc++;
827  sump2 += ppjT;}
828 
829  if(nc<2) return 0;
830  if(sump2==0) return 0;
831  // Sphericity Matrix
832  Double_t ele[4] = {mxx / sump2, mxy / sump2, mxy / sump2, myy / sump2};
833  TMatrixDSym m0(2,ele);
834 
835  // Find eigenvectors
836  TMatrixDSymEigen m(m0);
837  TVectorD eval(2);
838  TMatrixD evecm = m.GetEigenVectors();
839  eval = m.GetEigenValues();
840  // Largest eigenvector
841  int jev = 0;
842  // cout<<eval[0]<<" "<<eval[1]<<endl;
843  if (eval[0] < eval[1]) jev = 1;
844  TVectorD evec0(2);
845  // Principle axis
846  evec0 = TMatrixDColumn(evecm, jev);
847  Double_t compx=evec0[0];
848  Double_t compy=evec0[1];
849  TVector2 evec(compx, compy);
850  Double_t circ=0;
851  if(jev==1) circ=2*eval[0];
852  if(jev==0) circ=2*eval[1];
853 
854  return circ;
855 
856 
857 
858 }
859 
860 
861 
862 
863 //________________________________________________________________________
865  //calc subtracted jet mass
866 
867  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
870  else
871  return Circularity(jet, jetContNb);
872 
873 }
874 
875 //________________________________________________________________________
877 
878  AliJetContainer *jetCont = GetJetContainer(jetContNb);
879  if (!jet->GetNumberOfTracks())
880  return 0;
881  Double_t den=0.;
882  Double_t num = 0.;
883  AliVParticle *vp1 = 0x0;
884  AliVParticle *vp2 = 0x0;
885  std::vector<int> ordindex;
886  ordindex=jet->GetPtSortedTrackConstituentIndexes(jetCont->GetParticleContainer()->GetArray());
887  //Printf("Nbof const = %d", jet->GetNumberOfTracks());
888  //Printf("ordindex[0] = %d, ordindex[1] = %d", ordindex[0], ordindex[1]);
889 
890  if(ordindex.size()<2) return -1;
891 
892  vp1 = static_cast<AliVParticle*>(jet->TrackAt(ordindex[0], jetCont->GetParticleContainer()->GetArray()));
893  if (!vp1){
894  Printf("AliVParticle associated to Leading constituent not found");
895  return -1;
896  }
897 
898  vp2 = static_cast<AliVParticle*>(jet->TrackAt(ordindex[1], jetCont->GetParticleContainer()->GetArray()));
899  if (!vp2){
900  Printf("AliVParticle associated to Subleading constituent not found");
901  return -1;
902  }
903 
904 
905  num=vp1->Pt();
906  den=vp2->Pt();
907  //Printf("vp1->Pt() =%f, vp2->Pt() =%f", vp1->Pt(), vp2->Pt());
908 
909 return num-den;
910 }
911 
912 //________________________________________________________________________
914  //calc subtracted jet mass
915 
916  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
919  else
920  return LeSub(jet, jetContNb);
921 
922 }
923 
924 //________________________________________________________________________
926  //calc subtracted jet mass
927 
928  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
931  else
932  return jet->GetNumberOfTracks();
933 
934  }
935 
936 
937 //______________________________________________________________________________
939 
940  AliJetContainer *jetCont = GetJetContainer(jetContNb);
941  if (!jet->GetNumberOfTracks())
942  return 0;
943  Double_t mxx = 0.;
944  Double_t myy = 0.;
945  Double_t mxy = 0.;
946  int nc = 0;
947  Double_t sump2 = 0.;
948 
949  AliVParticle *vp1 = 0x0;
950  for(UInt_t i = 0; i < jet->GetNumberOfTracks(); i++) {
951  vp1 = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
952 
953  if (!vp1){
954  Printf("AliVParticle associated to constituent not found");
955  continue;
956  }
957 
958  Double_t ppt=vp1->Pt();
959  Double_t dphi = RelativePhi(vp1->Phi(),jet->Phi());
960 
961  Double_t deta = vp1->Eta()-jet->Eta();
962  mxx += ppt*ppt*deta*deta;
963  myy += ppt*ppt*dphi*dphi;
964  mxy -= ppt*ppt*deta*TMath::Abs(dphi);
965  nc++;
966  sump2 += ppt*ppt;
967 
968  }
969  if(nc<2) return 0;
970  if(sump2==0) return 0;
971  // Sphericity Matrix
972  Double_t ele[4] = {mxx , mxy , mxy , myy };
973  TMatrixDSym m0(2,ele);
974 
975  // Find eigenvectors
976  TMatrixDSymEigen m(m0);
977  TVectorD eval(2);
978  TMatrixD evecm = m.GetEigenVectors();
979  eval = m.GetEigenValues();
980  // Largest eigenvector
981  int jev = 0;
982  // cout<<eval[0]<<" "<<eval[1]<<endl;
983  if (eval[0] < eval[1]) jev = 1;
984  TVectorD evec0(2);
985  // Principle axis
986  evec0 = TMatrixDColumn(evecm, jev);
987  Double_t compx=evec0[0];
988  Double_t compy=evec0[1];
989  TVector2 evec(compx, compy);
990  Double_t sig=0;
991  if(jev==1) sig=TMath::Sqrt(TMath::Abs(eval[0])/sump2);
992  if(jev==0) sig=TMath::Sqrt(TMath::Abs(eval[1])/sump2);
993 
994  return sig;
995 
996 }
997 
998 //________________________________________________________________________
1000  //calc subtracted jet mass
1001 
1002  if((fJetShapeSub==kDerivSub)&&(jetContNb==0))
1004  else return jet->GetShapeProperties()->GetSecondOrderSubtractedSigma2();
1005  else
1006  return Sigma2(jet, jetContNb);
1007 
1008 }
1009 
1010 //________________________________________________________________________
1012 
1013  AliTrackContainer *PartCont = NULL;
1014  AliParticleContainer *PartContMC = NULL;
1015 
1016 
1017  if (fJetShapeSub==kConstSub){
1019  else PartCont = GetTrackContainer(1);
1020  }
1021  else{
1023  else PartCont = GetTrackContainer(0);
1024  }
1025 
1026  TClonesArray *TracksArray = NULL;
1027  TClonesArray *TracksArrayMC = NULL;
1028 
1029  if (fJetShapeType == AliAnalysisTaskEmcalQGTagging::kGenOnTheFly) TracksArrayMC = PartContMC->GetArray();
1030  else TracksArray = PartCont->GetArray();
1031 
1033  if(!PartContMC || !TracksArrayMC) return -99999;
1034  }
1035  else {
1036  if(!PartCont || !TracksArray) return -99999;
1037  }
1038 
1039 
1040  AliAODTrack *Track = 0x0;
1041 
1042 
1043 
1044  TList *trackList = new TList();
1045  Int_t triggers[100];
1046  for (Int_t iTrigger=0; iTrigger<100; iTrigger++) triggers[iTrigger] = 0;
1047  Int_t iTT = 0;
1048  Int_t NTracks=0;
1049  if (fJetShapeType == AliAnalysisTaskEmcalQGTagging::kGenOnTheFly) NTracks = TracksArrayMC->GetEntriesFast();
1050  else NTracks = TracksArray->GetEntriesFast();
1051 
1052  for(Int_t i=0; i < NTracks; i++){
1054  if((Track = static_cast<AliAODTrack*>(PartContMC->GetAcceptParticle(i)))){
1055  if (!Track) continue;
1056  if(TMath::Abs(Track->Eta())>0.9) continue;
1057  if (Track->Pt()<0.15) continue;
1058  if ((Track->Pt() >= minpT) && (Track->Pt()< maxpT)) {
1059  triggers[iTT] = i;
1060  iTT++;
1061  }
1062  }
1063  }
1064  else{
1065  if((Track = static_cast<AliAODTrack*>(PartCont->GetAcceptTrack(i)))){
1066  if (!Track) continue;
1067  if(TMath::Abs(Track->Eta())>0.9) continue;
1068  if (Track->Pt()<0.15) continue;
1069  if ((Track->Pt() >= minpT) && (Track->Pt()< maxpT)) {
1070  triggers[iTT] = i;
1071  iTT++;
1072  }
1073  }
1074  }
1075  }
1076 
1077 
1078  if (iTT == 0) return -99999;
1079  Int_t nbRn = 0, index = 0 ;
1080  TRandom3* random = new TRandom3(0);
1081  nbRn = random->Integer(iTT);
1082  index = triggers[nbRn];
1083  //Printf("iTT Total= %d, nbRn = %d, Index = %d",iTT, nbRn, index );
1084  return index;
1085 
1086 }
1087 
1088 //__________________________________________________________________________________
1090 
1091  if (vphi < -1*TMath::Pi()) vphi += (2*TMath::Pi());
1092  else if (vphi > TMath::Pi()) vphi -= (2*TMath::Pi());
1093  if (mphi < -1*TMath::Pi()) mphi += (2*TMath::Pi());
1094  else if (mphi > TMath::Pi()) mphi -= (2*TMath::Pi());
1095  double dphi = mphi-vphi;
1096  if (dphi < -1*TMath::Pi()) dphi += (2*TMath::Pi());
1097  else if (dphi > TMath::Pi()) dphi -= (2*TMath::Pi());
1098  return dphi;//dphi in [-Pi, Pi]
1099 }
1100 
1101 
1102 //_________________________________________________________________________
1104 
1105  std::vector<fastjet::PseudoJet> fInputVectors;
1106  fInputVectors.clear();
1107  fastjet::PseudoJet PseudoTracks;
1108  double xflagalgo=0;
1109  AliParticleContainer *fTrackCont = fJetCont->GetParticleContainer();
1110 
1111  if (fTrackCont) for (Int_t i=0; i<fJet->GetNumberOfTracks(); i++) {
1112  AliVParticle *fTrk = fJet->TrackAt(i, fTrackCont->GetArray());
1113  if (!fTrk) continue;
1114  PseudoTracks.reset(fTrk->Px(), fTrk->Py(), fTrk->Pz(),fTrk->E());
1115  PseudoTracks.set_user_index(fJet->TrackAt(i)+100);
1116  fInputVectors.push_back(PseudoTracks);
1117 
1118  }
1119 
1120 
1121 
1122  fastjet::JetDefinition *fJetDef;
1123  fastjet::ClusterSequence *fClustSeqSA;
1124  if(ReclusterAlgo==0) xflagalgo=0.5;
1125  if(ReclusterAlgo==1) xflagalgo=1.5;
1126  if(ReclusterAlgo==0) fJetDef = new fastjet::JetDefinition(fastjet::kt_algorithm, 1., static_cast<fastjet::RecombinationScheme>(0), fastjet::BestFJ30 );
1127  if(ReclusterAlgo==1) fJetDef = new fastjet::JetDefinition(fastjet::cambridge_algorithm, 1., static_cast<fastjet::RecombinationScheme>(0), fastjet::BestFJ30 );
1128 
1129  try {
1130  fClustSeqSA = new fastjet::ClusterSequence(fInputVectors, *fJetDef);
1131  } catch (fastjet::Error) {
1132  AliError(" [w] FJ Exception caught.");
1133  //return -1;
1134  }
1135 
1136  std::vector<fastjet::PseudoJet> fOutputJets;
1137  fOutputJets.clear();
1138  fOutputJets=fClustSeqSA->inclusive_jets(0);
1139 
1140  fastjet::PseudoJet jj;
1141  fastjet::PseudoJet j1;
1142  fastjet::PseudoJet j2;
1143  jj=fOutputJets[0];
1144 
1145  while(jj.has_parents(j1,j2)){
1146  if(j1.perp() < j2.perp()) swap(j1,j2);
1147  double delta_R=j1.delta_R(j2);
1148  double z=j2.perp()/(j1.perp()+j2.perp());
1149  double y =log(1.0/delta_R);
1150  double lnpt_rel=log(z*delta_R);
1151  Double_t LundEntries[4] = {y,lnpt_rel,fOutputJets[0].perp(),xflagalgo};
1152  fHLundIterative->Fill(LundEntries);
1153  jj=j1;}
1154 
1155 
1156  return;
1157 
1158 
1159 }
1160 
1161 
1162 
1163 
1164 
1165 
1166 
1167 //________________________________________________________________________
1169  //
1170  // retrieve event objects
1171  //
1173  return kFALSE;
1174 
1175  return kTRUE;
1176 }
1177 
1178 //_______________________________________________________________________
1180 {
1181  // Called once at the end of the analysis.
1182 
1183  // fTreeObservableTagging = dynamic_cast<TTree*>(GetOutputData(1));
1184  // if (!fTreeObservableTagging){
1185  // Printf("ERROR: fTreeObservableTagging not available");
1186  // return;
1187  // }
1188 
1189 }
1190 
Int_t SelectTrigger(Float_t minpT, Float_t maxpT)
Float_t Coronna(AliEmcalJet *jet, Int_t jetContNb)
Double_t GetFirstOrderSubtractedAngularity() const
Double_t Area() const
Definition: AliEmcalJet.h:123
const TString & GetRhoName() const
double Double_t
Definition: External.C:58
Double_t GetSecondOrderSubtractedSigma2() const
Definition: External.C:236
Bool_t RetrieveEventObjects()
Retrieve common objects from event.
Float_t GetPartonEta6() const
AliEmcalJet * ClosestJet() const
Definition: AliEmcalJet.h:222
AliJetContainer * GetJetContainer(Int_t i=0) const
Bool_t FillHistograms()
Function filling histograms.
Float_t GetPartonEta7() const
Double_t GetSecondOrderSubtractedConstituent() const
Double_t Eta() const
Definition: AliEmcalJet.h:114
Double_t Py() const
Definition: AliEmcalJet.h:100
Double_t Phi() const
Definition: AliEmcalJet.h:110
Float_t GetJetMass(AliEmcalJet *jet, Int_t jetContNb)
Float_t GetPythiaEventWeight() const
Container with name, TClonesArray and cuts for particles.
Int_t GetLabel() const
Definition: AliEmcalJet.h:117
Float_t GetPartonPhi7() const
Float_t GetJetAngularity(AliEmcalJet *jet, Int_t jetContNb)
Int_t GetPartonFlag7() const
Container for particles within the EMCAL framework.
Float_t GetPartonPhi6() const
Int_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:153
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:132
Float_t GetJetCoronna(AliEmcalJet *jet, Int_t jetContNb)
TString kData
Declare data MC or deltaAOD.
Double_t Px() const
Definition: AliEmcalJet.h:99
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
const TString & GetRhoMassName() const
Int_t GetPartonFlag6() const
AliParticleContainer * GetParticleContainer() const
Double_t GetFirstOrderSubtractedConstituent() const
int Int_t
Definition: External.C:63
Float_t GetJetCircularity(AliEmcalJet *jet, Int_t jetContNb)
unsigned int UInt_t
Definition: External.C:33
Float_t PTD(AliEmcalJet *jet, Int_t jetContNb)
float Float_t
Definition: External.C:68
Int_t GetNJets() const
Double_t GetSecondOrderSubtractedAngularity() const
Float_t GetSigma2(AliEmcalJet *jet, Int_t jetContNb)
virtual AliVParticle * GetAcceptParticle(Int_t i=-1) const
Double_t fCent
!event centrality
void RecursiveParents(AliEmcalJet *fJet, AliJetContainer *fJetCont, Int_t ReclusterAlgo)
AliEmcalJet * GetNextAcceptJet()
Float_t Angularity(AliEmcalJet *jet, Int_t jetContNb)
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 LeSub(AliEmcalJet *jet, Int_t jetContNb)
Double_t Pt() const
Definition: AliEmcalJet.h:102
Double_t GetRhoVal(Int_t i=0) const
Double_t GetFirstOrderSubtractedCircularity() const
AliEmcalList * fOutput
!output list
Float_t Sigma2(AliEmcalJet *jet, Int_t jetContNb)
Double_t RelativePhi(Double_t mphi, Double_t vphi)
const Int_t nVar
Double_t GetSecondOrderSubtractedCircularity() const
Float_t GetJetNumberOfConstituents(AliEmcalJet *jet, Int_t jetContNb)
AliTrackContainer * GetTrackContainer(Int_t i=0) const
Store some informaion about a Pythia eventThis class is used to store some information about a Pythia...
void SetMakeGeneralHistograms(Bool_t g)
virtual AliVTrack * GetAcceptTrack(Int_t i=-1) const
Base task in the EMCAL jet framework.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
const AliEmcalPythiaInfo * GetPythiaInfo() const
void swap(AliEmcalContainerIndexMap< X, Y > &first, AliEmcalContainerIndexMap< X, Y > &second)
Float_t GetJetpTD(AliEmcalJet *jet, Int_t jetContNb)
Double_t Pz() const
Definition: AliEmcalJet.h:101
Double_t GetFractionSharedPt(const AliEmcalJet *jet, AliParticleContainer *cont2=0x0) const
Declaration of class AliEmcalPythiaInfo.
const char Option_t
Definition: External.C:48
void UserCreateOutputObjects()
Main initialization function on the worker.
Double_t GetFirstOrderSubtractedSigma2() const
Float_t Circularity(AliEmcalJet *jet, Int_t jetContNb)
bool Bool_t
Definition: External.C:53
AliEmcalJetShapeProperties * GetShapeProperties() const
Definition: AliEmcalJet.h:256
Float_t GetJetLeSub(AliEmcalJet *jet, Int_t jetContNb)
Float_t GetPartonPt7() const
Double_t M() const
Definition: AliEmcalJet.h:113
Container for jet within the EMCAL jet framework.
Bool_t Run()
Run function. This is the core function of the analysis and contains the user code. Therefore users have to implement this function.
Definition: External.C:196
std::vector< int > GetPtSortedTrackConstituentIndexes(TClonesArray *tracks) const
Float_t GetPartonPt6() const
AliEmcalJet * GetJet(Int_t i) const