AliPhysics  d565ceb (d565ceb)
AliAnalysisTaskRecursiveSoftDrop.cxx
Go to the documentation of this file.
1 //
2 // Basic analysis task.
3 //
4 // Basic analysis task template for analysis jets storing information in both tree
5 // branches and histograms
6 
7 #include <TClonesArray.h>
8 #include <TH1F.h>
9 #include <TH2F.h>
10 #include <TH3F.h>
11 #include <TCanvas.h>
12 #include <THnSparse.h>
13 #include <TTree.h>
14 #include <TList.h>
15 #include <TLorentzVector.h>
16 #include <TProfile.h>
17 #include <TChain.h>
18 #include <TSystem.h>
19 #include <TFile.h>
20 #include <TKey.h>
21 #include <AliAnalysisDataSlot.h>
22 #include <AliAnalysisDataContainer.h>
23 #include <vector>
24 #include "TMatrixD.h"
25 #include "TMatrixDSym.h"
26 #include "TMatrixDSymEigen.h"
27 #include "TVector3.h"
28 #include "TVector2.h"
29 #include "AliVCluster.h"
30 #include "AliVTrack.h"
31 #include "AliEmcalJet.h"
32 #include "AliRhoParameter.h"
33 #include "AliLog.h"
34 #include "AliEmcalParticle.h"
35 #include "AliMCEvent.h"
36 #include "AliGenPythiaEventHeader.h"
37 #include "AliAODMCHeader.h"
38 #include "AliMCEvent.h"
39 #include "AliAnalysisManager.h"
40 #include "AliJetContainer.h"
41 #include "AliParticleContainer.h"
42 //#include "AliPythiaInfo.h"
43 #include "TRandom3.h"
44 #include "AliPicoTrack.h"
45 #include "AliEmcalJetFinder.h"
46 #include "AliAODEvent.h"
48 
49 #include "FJ_includes.h"
50 
51 //Globals
52 using std::cout;
53 using std::endl;
54 
56 
57 //________________________________________________________________________
60  fContainer(0),
61  fJetShapeSub(kNoSub),
62  fPtThreshold(-9999.),
63  fCentSelectOn(kTRUE),
64  fCentMin(0),
65  fCentMax(10),
66  fJetRadius(0.4),
67  fSharedFractionPtMin(0.5),
68  fReclusteringAlgo(0),
69  fhJetPt(0x0),
70  fhJetPhi(0x0),
71  fhJetEta(0x0),
72  fhDetJetPt_Matched(0x0),
73  fTreeRecursive_Det(0),
74  fTreeRecursive_True(0)
75 
76 {
77  for(Int_t i=0;i<4;i++){
78  fShapesVar_Det[i]=0;
79  fShapesVar_True[i]=0;
80  }
81  SetMakeGeneralHistograms(kTRUE);
82  DefineOutput(1, TList::Class());
83  DefineOutput(2, TTree::Class());
84  DefineOutput(3, TTree::Class());
85 }
86 
87 //________________________________________________________________________
89  AliAnalysisTaskEmcalJet(name, kTRUE),
90  fContainer(0),
91  fJetShapeSub(kNoSub),
92  fPtThreshold(-9999.),
93  fCentSelectOn(kTRUE),
94  fCentMin(0),
95  fCentMax(10),
96  fJetRadius(0.4),
97  fSharedFractionPtMin(0.5),
98  fReclusteringAlgo(0),
99  fhJetPt(0x0),
100  fhJetPhi(0x0),
101  fhJetEta(0x0),
102  fhDetJetPt_Matched(0x0),
103  fTreeRecursive_Det(0),
104  fTreeRecursive_True(0)
105 {
106  // Standard constructor.
107  for(Int_t i=0;i<4;i++){
108  fShapesVar_Det[i]=0;
109  fShapesVar_True[i]=0;
110  }
112  DefineOutput(1, TList::Class());
113  DefineOutput(2, TTree::Class());
114  DefineOutput(3, TTree::Class());
115 }
116 
117 //________________________________________________________________________
119 {
120  // Destructor.
121 }
122 
123 //________________________________________________________________________
125 {
126  // Create user output.
127 
129 
130  Bool_t oldStatus = TH1::AddDirectoryStatus();
131  TH1::AddDirectory(kFALSE);
132  TH1::AddDirectory(oldStatus);
133  //create a tree used for the MC data and making a 4D response matrix
134  const char* nameoutput = GetOutputSlot(2)->GetContainer()->GetName();
135  fTreeRecursive_Det = new TTree(nameoutput, nameoutput);
136  const char* nameoutput2 = GetOutputSlot(3)->GetContainer()->GetName();
137  fTreeRecursive_True = new TTree(nameoutput2, nameoutput2);
138 
139  const Int_t intBranches = 4;
140 
141  std::vector<TString> fShapesVarNames_Det(intBranches), fShapesVarNames_True(intBranches);
142 
143 
144  fShapesVarNames_Det[0] = "Pt";
145  fShapesVarNames_Det[1] = "Z";
146  fShapesVarNames_Det[2] = "Theta";
147  fShapesVarNames_Det[3] = "N";
148  fShapesVarNames_True[0] = "Pt_Truth";
149  fShapesVarNames_True[1] = "Z_Truth";
150  fShapesVarNames_True[2] = "Theta_Truth";
151  fShapesVarNames_True[3] = "N_Truth";
152 
153  for(Int_t ivar=0; ivar < intBranches; ivar++){
154  cout<<"looping over variables"<<endl;
155  fTreeRecursive_Det->Branch(fShapesVarNames_Det[ivar].Data(), &fShapesVar_Det[ivar], Form("%s/D", fShapesVarNames_Det[ivar].Data()));
156  fTreeRecursive_True->Branch(fShapesVarNames_True[ivar].Data(), &fShapesVar_True[ivar], Form("%s/D", fShapesVarNames_True[ivar].Data()));
157  }
158 
159  fhJetPt= new TH1F("fhJetPt", "Jet Pt",1500,-0.5,149.5 );
160  fOutput->Add(fhJetPt);
161  fhJetPhi= new TH1F("fhJetPhi", "Jet Phi",360 , -1.5*(TMath::Pi()), 1.5*(TMath::Pi()));
162  fOutput->Add(fhJetPhi);
163  fhJetEta= new TH1F("fhJetEta", "Jet Eta",100,-2,2);
164  fOutput->Add(fhJetEta);
165  fhDetJetPt_Matched= new TH1F("fhDetJetPt_Matched", "Jet Pt",200,-0.5,199.5 );
167 
168  PostData(1,fOutput);
169  PostData(2,fTreeRecursive_Det);
170  PostData(3,fTreeRecursive_True);
171  // delete [] fShapesVarNames;
172 }
173 
174 //________________________________________________________________________
176 {
177  // Run analysis code here, if needed. It will be executed before FillHistograms().
178 
179 
180  return kTRUE;
181 }
182 
183 //________________________________________________________________________
185 {
186  if (fCentSelectOn){
187  if ((fCent>fCentMax) || (fCent<fCentMin)) return 0;
188  }
189 
190  if(fJetType == kData){
191  AliEmcalJet *Jet1 = NULL; //Original Jet in the event
192  AliJetContainer *JetCont= GetJetContainer(0); //Jet Container for event
193  Double_t JetPhi=0;
194  Double_t JetPt_ForThreshold=0;
195  if(JetCont) {
196  JetCont->ResetCurrentID();
197  while((Jet1=JetCont->GetNextAcceptJet())) {
198  if(!Jet1) continue;
199  if (fJetShapeSub==kNoSub) JetPt_ForThreshold = Jet1->Pt()-(GetRhoVal(0)*Jet1->Area());
200  else JetPt_ForThreshold = Jet1->Pt();
201  if(JetPt_ForThreshold<fPtThreshold) {
202  continue;
203  }
204  else {
205  fhJetPt->Fill(Jet1->Pt());
206  JetPhi=Jet1->Phi();
207  if(JetPhi < -1*TMath::Pi()) JetPhi += (2*TMath::Pi());
208  else if (JetPhi > TMath::Pi()) JetPhi -= (2*TMath::Pi());
209  fhJetPhi->Fill(JetPhi);
210  fhJetEta->Fill(Jet1->Eta());
211  RecursiveParents(Jet1,JetCont,kFALSE);
212  }
213  }
214  }
215  }
216 
217  if(fJetType == kEmb){
218  AliEmcalJet *JetHybridS = NULL; //Subtracted hybrid Jet
219  AliEmcalJet *JetHybridUS = NULL; //Unsubtracted Hybrid Jet //For matching SubtractedHybrid->DetPythia this jet container is also Subtracted Hybrid
220  AliEmcalJet *JetPythDet = NULL; //Detector Level Pythia Jet
221  AliEmcalJet *JetPythTrue = NULL; //Particle Level Pyhtia Jet
222  AliJetContainer *JetContHybridS= GetJetContainer(0); //Jet Container for Subtracted Hybrid Jets
223  AliJetContainer *JetContHybridUS= GetJetContainer(1); //Jet Container for Unsubtracted Hybrid Jets
224  AliJetContainer *JetContPythDet= GetJetContainer(2); //Jet Container for Detector Level Pyhtia Jets
225  AliJetContainer *JetContPythTrue= GetJetContainer(3); //Jet Container for Particle Level Pythia Jets
226 
227 
228 
229  Bool_t JetsMatched = kFALSE;
230  Double_t JetPtThreshold;
231  JetContHybridS->ResetCurrentID();
232  JetContHybridUS->ResetCurrentID();
233  JetContPythDet->ResetCurrentID();
234  JetContPythTrue->ResetCurrentID();
235 
236  while((JetHybridS = JetContHybridS->GetNextAcceptJet())){ //Get next Subtracted hybrid jet
237  if (fJetShapeSub==kConstSub) JetPtThreshold=JetHybridS->Pt();
238  else JetPtThreshold=JetHybridS->Pt()-(GetRhoVal(0)*JetHybridS->Area());
239  if ( (!JetHybridS) || (JetPtThreshold<fPtThreshold)) continue; //check pT is above threshold
240  Int_t JetNumber=-1;
241  for(Int_t i = 0; i<JetContHybridUS->GetNJets(); i++) {
242  JetHybridUS = JetContHybridUS->GetJet(i); //Get unsubtracted jets in order
243  if (!JetHybridUS) continue;
244 
245  if(JetHybridUS->GetLabel()==JetHybridS->GetLabel()) { //check if it mataches with current subtracted hybrid jet
246  JetNumber=i;
247  }
248  }
249  if(JetNumber==-1) continue;
250  JetHybridUS=JetContHybridUS->GetJet(JetNumber); //Get the matched Unsubtracted jet
251  if (JetContHybridUS->AliJetContainer::GetFractionSharedPt(JetHybridUS)<fSharedFractionPtMin) { //Check that the US closest jet shares a minimum
252  continue; // pT with Detector level pythia jet
253  }
254  JetPythDet=JetHybridUS->ClosestJet(); //get the closest jet that has passed the shared pT cut
255  if (!JetHybridUS) {
256  Printf("Unsubtracted embedded jet does not exist, returning");
257  continue;
258  }
259  if (!JetPythDet) continue;
260  UInt_t rejectionReason = 0;
261  if (!(JetContPythDet->AcceptJet(JetPythDet,rejectionReason))) continue; //Check the detector level just is accepted
262  fhDetJetPt_Matched->Fill(JetPythDet->Pt()); //Fill only matched detector level jets for tagging efficiency comparison
263  JetPythTrue=JetPythDet->ClosestJet(); //Get the corresponding pythia true jet
264  if(!JetPythTrue) continue;
265  JetsMatched=kTRUE; //jets have been matched
266 
267 
268  fhJetPt->Fill(JetHybridS->Pt());
269  Double_t JetPhi=JetHybridS->Phi();
270  if(JetPhi < -1*TMath::Pi()) JetPhi += (2*TMath::Pi());
271  else if (JetPhi > TMath::Pi()) JetPhi -= (2*TMath::Pi());
272  fhJetPhi->Fill(JetPhi);
273  fhJetEta->Fill(JetHybridS->Eta());
274  RecursiveParents(JetHybridS,JetContHybridS,kFALSE);
275  RecursiveParents(JetPythTrue,JetContPythTrue,kTRUE);
276 
277 
278 
279  }
280  }
281 
282 
283  return kTRUE;
284 }
285 
286 //_________________________________________________________________________
288  std::vector<fastjet::PseudoJet> fInputVectors;
289  fInputVectors.clear();
290  fastjet::PseudoJet PseudoTracks;
291  double xflagalgo=0;
292  AliParticleContainer *fTrackCont = fJetCont->GetParticleContainer();
293 
294  if (fTrackCont) for (Int_t i=0; i<fJet->GetNumberOfTracks(); i++) {
295  AliVParticle *fTrk = fJet->TrackAt(i, fTrackCont->GetArray());
296  if (!fTrk) continue;
297  PseudoTracks.reset(fTrk->Px(), fTrk->Py(), fTrk->Pz(),fTrk->E());
298  PseudoTracks.set_user_index(fJet->TrackAt(i)+100);
299  fInputVectors.push_back(PseudoTracks);
300 
301  }
302 
303 
304 
305  fastjet::JetAlgorithm jetalgo(fastjet::antikt_algorithm);
306  if(fReclusteringAlgo==0){ xflagalgo=0.5;
307  jetalgo=fastjet::kt_algorithm ;}
308 
309  if(fReclusteringAlgo==1){ xflagalgo=1.5;
310  jetalgo=fastjet::cambridge_algorithm;
311  }
312  if(fReclusteringAlgo==2){ xflagalgo=2.5;
313  jetalgo=fastjet::antikt_algorithm;
314  }
315 
316  fastjet::JetDefinition fJetDef(jetalgo, 1., static_cast<fastjet::RecombinationScheme>(0), fastjet::BestFJ30 );
317 
318  try {
319  fastjet::ClusterSequence fClustSeqSA(fInputVectors, fJetDef);
320  std::vector<fastjet::PseudoJet> fOutputJets;
321  fOutputJets.clear();
322  fOutputJets=fClustSeqSA.inclusive_jets(0);
323 
324  fastjet::PseudoJet jj;
325  fastjet::PseudoJet j1;
326  fastjet::PseudoJet j2;
327  jj=fOutputJets[0];
328  Int_t n = 0;
329  Double_t jet_pT=jj.perp();
330  while(jj.has_parents(j1,j2)){
331  n++;
332  if(j1.perp() < j2.perp()) swap(j1,j2);
333  double delta_R=j1.delta_R(j2);
334  double z=j2.perp()/(j1.perp()+j2.perp());
335  if(bTruth) {
336  fShapesVar_True[0]=jet_pT;
337  fShapesVar_True[1]=z;
338  fShapesVar_True[2]=delta_R;
339  fShapesVar_True[3]=n;
340  fTreeRecursive_True->Fill();
341  }
342  else {
343  fShapesVar_Det[0]=jet_pT;
344  fShapesVar_Det[1]=z;
345  fShapesVar_Det[2]=delta_R;
346  fShapesVar_Det[3]=n;
347  fTreeRecursive_Det->Fill();
348  }
349  jj=j1;
350  }
351 
352  } catch (fastjet::Error) {
353  AliError(" [w] FJ Exception caught.");
354  //return -1;
355  }
356  return;
357 }
358 
359 
360 //________________________________________________________________________
362  //
363  // retrieve event objects
364  //
366  return kFALSE;
367 
368  return kTRUE;
369 }
370 
371 
372 //_______________________________________________________________________
374 {
375  // Called once at the end of the analysis.
376 
377 }
378 
379 
381  const char * njetsData, //data jets
382  const char * njetsTrue, //Pyhthia Particle Level
383  const char * njetsDet,
384  const char * njetsHybridUs,
385  const char * njetsHybridS,
386  const Double_t R,
387  const char * nrhoBase,
388  const char * ntracksData,
389  const char * ntracksTrue,
390  const char * ntracksDet,
391  const char * ntracksHybridUs,
392  const char * ntracksHybridS,
393  const char *type,
394  const char *CentEst,
395  Int_t pSel,
396  TString trigClass,
397  TString kEmcalTriggers,
398  TString tag,
401  ) {
402 
403 
404 
405  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
406  if (!mgr)
407  {
408  ::Error("AddTaskRecursiveSoftDrop","No analysis manager found.");
409  return 0;
410  }
411  Bool_t ismc=kFALSE;
412  ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
413 
414  // Check the analysis type using the event handlers connected to the analysis manager.
415  //==============================================================================
416  if (!mgr->GetInputEventHandler())
417  {
418  ::Error("AliAnalysisTaskRecursiveSoftDrop", "This task requires an input event handler");
419  return NULL;
420  }
421  TString wagonName1;
422  TString wagonName2;
423  TString wagonName3;
424 
426  wagonName1 = Form("AliAnalysisTaskRecursiveSoftDrop_%s_TC%s%s",njetsData,trigClass.Data(),tag.Data());
427  wagonName2 = Form("AliAnalysisTaskRecursiveSoftDrop_%s_TC%s%sTree_Det",njetsData,trigClass.Data(),tag.Data());
428  wagonName3 = Form("AliAnalysisTaskRecursiveSoftDrop_%s_TC%s%sTree_True",njetsData,trigClass.Data(),tag.Data());
429  }
431  wagonName1 = Form("AliAnalysisTaskRecursiveSoftDrop_%s_TC%s%s",njetsHybridS,trigClass.Data(),tag.Data());
432  wagonName2 = Form("AliAnalysisTaskRecursiveSoftDrop_%s_TC%s%sTree_Det",njetsHybridS,trigClass.Data(),tag.Data());
433  wagonName3 = Form("AliAnalysisTaskRecursiveSoftDrop_%s_TC%s%sTree_True",njetsHybridS,trigClass.Data(),tag.Data());
434  }
435  //Configure jet tagger task
437 
438  task->SetJetShapeSub(jetShapeSub);
439  task->SetJetType(fjetType);
440  task->SetJetRadius(R);
441 
442  AliParticleContainer *trackContData=0x0;
443  AliParticleContainer *trackContDet=0x0;
444  AliParticleContainer *trackContTrue=0x0;
445  AliParticleContainer *trackContHybridS=0x0;
446  AliParticleContainer *trackContHybridUs=0x0;
447 
448  trackContData = task->AddParticleContainer(ntracksData);
450  trackContDet = task->AddParticleContainer(ntracksDet);
451  trackContTrue = task->AddMCParticleContainer(ntracksTrue);
452  trackContHybridS = task->AddParticleContainer(ntracksHybridS);
453  trackContHybridUs = task->AddParticleContainer(ntracksHybridUs);
454  }
455  AliJetContainer *JetContData=0x0;
456  AliJetContainer *JetContTrue=0x0;
457  AliJetContainer *JetContDet=0x0;
458  AliJetContainer *JetContHybridUs=0x0;
459  AliJetContainer *JetContHybridS=0x0;
460  TString strType(type);
461 
463  JetContData = task->AddJetContainer(njetsData,strType,R); //Data
464  if(JetContData) {
465  JetContData->SetRhoName(nrhoBase);
466  JetContData->ConnectParticleContainer(trackContData);
467  JetContData->SetPercAreaCut(0.6);
468  JetContData->SetJetRadius(R);
470  if(jetShapeSub==AliAnalysisTaskRecursiveSoftDrop::kConstSub) JetContData->SetAreaEmcCut(-2);
471  }
472  }
474  JetContHybridS = task->AddJetContainer(njetsHybridS,strType,R); //HybridS
475  if(JetContHybridS) {
476  JetContHybridS->SetRhoName(nrhoBase);
477  JetContHybridS->ConnectParticleContainer(trackContHybridS);
478  JetContHybridS->SetPercAreaCut(0.6);
479  JetContHybridS->SetJetRadius(R);
481  if(jetShapeSub==AliAnalysisTaskRecursiveSoftDrop::kConstSub) JetContHybridS->SetAreaEmcCut(-2);
482  }
483  JetContHybridUs = task->AddJetContainer(njetsHybridUs,strType,R); //HybridUs
484  if(JetContHybridUs) {
485  JetContHybridUs->SetRhoName(nrhoBase);
486  JetContHybridUs->ConnectParticleContainer(trackContHybridUs);
487  JetContHybridUs->SetPercAreaCut(0.6);
488  JetContHybridUs->SetJetRadius(R);
489  JetContHybridUs->SetJetAcceptanceType(AliEmcalJet::kTPCfid);
490  if(jetShapeSub==AliAnalysisTaskRecursiveSoftDrop::kConstSub) JetContHybridUs->SetAreaEmcCut(-2);
491  }
492  JetContDet = task->AddJetContainer(njetsDet,strType,R); //Det
493  if(JetContDet) {
494  JetContDet->SetRhoName(nrhoBase);
495  JetContDet->ConnectParticleContainer(trackContDet);
496  JetContDet->SetPercAreaCut(0.6);
497  JetContDet->SetJetRadius(R);
499  if(jetShapeSub==AliAnalysisTaskRecursiveSoftDrop::kConstSub) JetContDet->SetAreaEmcCut(-2);
500  }
501  JetContTrue = task->AddJetContainer(njetsTrue,strType,R); //True
502  if(JetContTrue) {
503  JetContTrue->SetRhoName(nrhoBase);
504  JetContTrue->ConnectParticleContainer(trackContTrue);
505  JetContTrue->SetPercAreaCut(0.6);
506  JetContTrue->SetJetRadius(R);
508  if(jetShapeSub==AliAnalysisTaskRecursiveSoftDrop::kConstSub) JetContTrue->SetAreaEmcCut(-2);
509  }
510  }
511 
512  task->SetCaloTriggerPatchInfoName(kEmcalTriggers.Data());
513  task->SetCentralityEstimator(CentEst);
514  task->SelectCollisionCandidates(pSel);
515  task->SetUseAliAnaUtils(kFALSE);
516 
517  mgr->AddTask(task);
518 
519  //Connnect input
520  mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer() );
521 
522  //Connect output
523  TString contName1(wagonName1);
524  TString contName2(wagonName2);
525  TString contName3(wagonName3);
526 
528  contName1 += "_Embedded";
529  contName2 += "_Embedded";
530  contName2 += "_Embedded";
531 
532  }
533 
534 
535  TString outputfile = Form("%s",AliAnalysisManager::GetCommonFileName());
536  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName1.Data(), TList::Class(),AliAnalysisManager::kOutputContainer,outputfile);
537  mgr->ConnectOutput(task,1,coutput1);
538  AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(contName2.Data(), TTree::Class(),AliAnalysisManager::kOutputContainer,outputfile);
539  mgr->ConnectOutput(task,2,coutput2);
540  AliAnalysisDataContainer *coutput3 = mgr->CreateContainer(contName3.Data(), TTree::Class(),AliAnalysisManager::kOutputContainer,outputfile);
541  mgr->ConnectOutput(task,3,coutput3);
542 
543  return task;
544 
545 }
void SetAreaEmcCut(Double_t a=0.99)
Bool_t RetrieveEventObjects()
Retrieve common objects from event.
Double_t Area() const
Definition: AliEmcalJet.h:130
double Double_t
Definition: External.C:58
AliEmcalJet * ClosestJet() const
Definition: AliEmcalJet.h:327
AliJetContainer * GetJetContainer(Int_t i=0) const
Double_t Eta() const
Definition: AliEmcalJet.h:121
void RecursiveParents(AliEmcalJet *fJet, AliJetContainer *fJetCont, Bool_t bTruth)
Double_t Phi() const
Definition: AliEmcalJet.h:117
Int_t GetLabel() const
Definition: AliEmcalJet.h:124
virtual Bool_t AcceptJet(Int_t i, UInt_t &rejectionReason) const
void SetPercAreaCut(Float_t p)
Bool_t FillHistograms()
Function filling histograms.
Container for particles within the EMCAL framework.
Int_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:160
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:139
void SetRhoName(const char *n)
TPC fiducial acceptance (each eta edge narrowed by jet R)
Definition: AliEmcalJet.h:68
AliParticleContainer * GetParticleContainer() const
int Int_t
Definition: External.C:63
void SetJetRadius(Float_t r)
unsigned int UInt_t
Definition: External.C:33
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.
Int_t GetNJets() const
static AliAnalysisTaskRecursiveSoftDrop * AddTaskRecursiveSoftDrop(const char *njetsData, const char *njetsTrue, const char *njetsDet, const char *njetsHybridUs, const char *njetsHybridS, const Double_t R, const char *nrhoBase, const char *ntracksData, const char *ntracksTrue, const char *ntracksDet, const char *ntracksHybridUs, const char *ntracksHybridS, const char *type, const char *CentEst, Int_t pSel, TString trigClass="", TString kEmcalTriggers="", TString tag="", AliAnalysisTaskRecursiveSoftDrop::JetShapeSub jetShapeSub=JetShapeSub::kConstSub, AliAnalysisTaskRecursiveSoftDrop::JetType fjetType=JetType::kData)
Double_t fCent
!event centrality
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)
void ConnectParticleContainer(AliParticleContainer *c)
Double_t Pt() const
Definition: AliEmcalJet.h:109
Double_t GetRhoVal(Int_t i=0) const
AliEmcalList * fOutput
!output list
void SetMakeGeneralHistograms(Bool_t g)
Base task in the EMCAL jet framework.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:51
const char Option_t
Definition: External.C:48
void UserCreateOutputObjects()
Main initialization function on the worker.
void SetJetAcceptanceType(UInt_t type)
bool Bool_t
Definition: External.C:53
void swap(PWGJE::EMCALJetTasks::AliAnalysisTaskEmcalJetHPerformance &first, PWGJE::EMCALJetTasks::AliAnalysisTaskEmcalJetHPerformance &second)
Container for jet within the EMCAL jet framework.
AliEmcalJet * GetJet(Int_t i) const