AliPhysics  449db5a (449db5a)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalJetSubstructureTree.cxx
Go to the documentation of this file.
1 /************************************************************************************
2  * Copyright (C) 2017, Copyright Holders of the ALICE Collaboration *
3  * All rights reserved. *
4  * *
5  * Redistribution and use in source and binary forms, with or without *
6  * modification, are permitted provided that the following conditions are met: *
7  * * Redistributions of source code must retain the above copyright *
8  * notice, this list of conditions and the following disclaimer. *
9  * * Redistributions in binary form must reproduce the above copyright *
10  * notice, this list of conditions and the following disclaimer in the *
11  * documentation and/or other materials provided with the distribution. *
12  * * Neither the name of the <organization> nor the *
13  * names of its contributors may be used to endorse or promote products *
14  * derived from this software without specific prior written permission. *
15  * *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND *
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED *
18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
19  * DISCLAIMED. IN NO EVENT SHALL ALICE COLLABORATION BE LIABLE FOR ANY *
20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES *
21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; *
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND *
23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
26  ************************************************************************************/
27 #include <iostream>
28 #include <string>
29 #include <sstream>
30 #include <vector>
31 
32 #include <fastjet/ClusterSequence.hh>
33 #include <fastjet/contrib/Nsubjettiness.hh>
34 #include <fastjet/contrib/SoftDrop.hh>
35 
36 #include <TLorentzVector.h>
37 #include <TMath.h>
38 #include <TString.h>
39 #include <TVector3.h>
40 
41 #include "AliAODInputHandler.h"
42 #include "AliAnalysisManager.h"
44 #include "AliClusterContainer.h"
45 #include "AliJetContainer.h"
47 #include "AliEmcalJet.h"
48 #include "AliEmcalList.h"
49 #include "AliLog.h"
50 #include "AliParticleContainer.h"
51 #include "AliTrackContainer.h"
52 #include "AliVCluster.h"
53 #include "AliVParticle.h"
54 
58 
59 namespace EmcalTriggerJets {
60 
61 AliAnalysisTaskEmcalJetSubstructureTree::AliAnalysisTaskEmcalJetSubstructureTree() :
63  fJetSubstructureTree(nullptr),
64  fSDZCut(0.1),
65  fSDBetaCut(0),
66  fReclusterizer(kCAAlgo),
67  fTriggerSelectionBits(AliVEvent::kAny),
68  fTriggerSelectionString("")
69 {
70  memset(fJetTreeData, 0, sizeof(Double_t) * kTNVar);
71 }
72 
74  AliAnalysisTaskEmcalJet(name, kTRUE),
75  fJetSubstructureTree(nullptr),
76  fSDZCut(0.1),
77  fSDBetaCut(0),
78  fReclusterizer(kCAAlgo),
79  fTriggerSelectionBits(AliVEvent::kAny),
80  fTriggerSelectionString("")
81 {
82  memset(fJetTreeData, 0, sizeof(Double_t) * kTNVar);
83  DefineOutput(2, TTree::Class());
84 }
85 
87 
88 }
89 
92 
93  OpenFile(2);
94  fJetSubstructureTree = new TTree("jetSubstructure", "Tree with jet substructure information");
95  TString varnames[kTNVar];
96  varnames[0] = "Radius";
97  varnames[1] = "EventWeight";
98  varnames[2] = "PtJetRec";
99  varnames[3] = "PtJetSim";
100  varnames[4] = "AreaRec";
101  varnames[5] = "AreaSim";
102  varnames[6] = "NEFRec";
103  varnames[7] = "NEFSim";
104  varnames[8] = "MassRec";
105  varnames[9] = "MassSim";
106  varnames[10] = "ZgMeasured";
107  varnames[11] = "ZgTrue";
108  varnames[12] = "RgMeasured";
109  varnames[13] = "RgTrue";
110  varnames[14] = "MgMeasured";
111  varnames[15] = "MgTrue";
112  varnames[16] = "PtgMeasured";
113  varnames[17] = "PtgTrue";
114  varnames[18] = "OneSubjettinessMeasured";
115  varnames[19] = "OneSubjettinessTrue";
116  varnames[20] = "TwoSubjettinessMeasured";
117  varnames[21] = "TwoSubjettinessTrue";
118  varnames[22] = "AngularityMeasured";
119  varnames[23] = "AngularityTrue";
120  varnames[24] = "PtDMeasured";
121  varnames[25] = "PtDTrue";
122  varnames[26] = "NCharged";
123  varnames[27] = "NNeutral";
124  varnames[28] = "NConstTrue";
125  varnames[29] = "NDroppedMeasured";
126  varnames[30] = "NDroppedTrue";
127 
128  for(int ib = 0; ib < kTNVar; ib++){
129  fJetSubstructureTree->Branch(varnames[ib], fJetTreeData + ib, Form("%s/D", varnames[ib].Data()));
130  }
131  PostData(1, fOutput);
132  PostData(2, fJetSubstructureTree);
133 }
134 
136  AliClusterContainer *clusters = GetClusterContainer("caloClusters");
137  AliTrackContainer *tracks = GetTrackContainer("tracks");
138  AliParticleContainer *particles = GetParticleContainer("mcparticles");
139 
140  AliJetContainer *mcjets = GetJetContainer("mcjets");
141  AliJetContainer *datajets = GetJetContainer("datajets");
142 
143  // Run trigger selection (not on pure MCgen train)
144  if(datajets){
145  if(!(fInputHandler->IsEventSelected() & fTriggerSelectionBits)) return false;
146  if(fTriggerSelectionString.Length()) {
147  if(!fInputEvent->GetFiredTriggerClasses().Contains(fTriggerSelectionString)) return false;
148  }
149  }
150 
151  Double_t weight = 1;
152 
153  AliSoftdropDefinition softdropSettings;
154  softdropSettings.fBeta = fSDBetaCut;
155  softdropSettings.fZ = fSDZCut;
156  switch(fReclusterizer) {
157  case kCAAlgo: softdropSettings.fRecluserAlgo = fastjet::cambridge_aachen_algorithm; break;
158  case kKTAlgo: softdropSettings.fRecluserAlgo = fastjet::kt_algorithm; break;
159  case kAKTAlgo: softdropSettings.fRecluserAlgo = fastjet::antikt_algorithm; break;
160  };
161 
162  AliNSubjettinessDefinition nsubjettinessSettings;
163  nsubjettinessSettings.fBeta = 1.;
164  nsubjettinessSettings.fRadius = 0.4;
165 
166  if(mcjets && !datajets) {
167  // pure MC (gen) train - run over MC jets
168  for(auto jet : mcjets->accepted()) {
169  try {
170  AliJetSubstructureData structure = MakeJetSubstructure(*jet, mcjets->GetJetRadius() * 2., particles, nullptr,{softdropSettings, nsubjettinessSettings});
171  Double_t angularity[2] = {0., MakeAngularity(*jet, particles, nullptr)},
172  ptd[2] = {0., MakePtD(*jet, particles, nullptr)};
173  FillTree(mcjets->GetJetRadius(), weight, nullptr, jet, nullptr, &(structure.fSoftDrop), nullptr, &(structure.fNsubjettiness), angularity, ptd);
174  } catch (ReclusterizerException &e) {
175  AliErrorStream() << "Error in reclusterization - skipping jet" << std::endl;
176  }
177  }
178  }
179 
180  if(datajets) {
181  for(auto jet : datajets->accepted()) {
182  AliEmcalJet *associatedJet = jet->MatchedJet();
183  if(mcjets) {
184  if(!associatedJet) continue;
185  try {
186  AliJetSubstructureData structureData = MakeJetSubstructure(*jet, datajets->GetJetRadius() * 2., tracks, clusters, {softdropSettings, nsubjettinessSettings}),
187  structureMC = MakeJetSubstructure(*associatedJet, mcjets->GetJetRadius() * 2, particles, nullptr, {softdropSettings, nsubjettinessSettings});
188  Double_t angularity[2] = {MakeAngularity(*jet, tracks, clusters), MakeAngularity(*associatedJet, particles, nullptr)},
189  ptd[2] = {MakePtD(*jet, tracks, clusters), MakePtD(*associatedJet, particles, nullptr)};
190  FillTree(datajets->GetJetRadius(), weight, jet, associatedJet, &(structureData.fSoftDrop), &(structureMC.fSoftDrop), &(structureData.fNsubjettiness), &(structureMC.fNsubjettiness), angularity, ptd);
191  } catch(ReclusterizerException &e) {
192  AliErrorStream() << "Error in reclusterization - skipping jet" << std::endl;
193  }
194  } else {
195  try {
196  AliJetSubstructureData structure = MakeJetSubstructure(*jet, 0.4, tracks, clusters, {softdropSettings, nsubjettinessSettings});
197  Double_t angularity[2] = {MakeAngularity(*jet, tracks, clusters), 0.},
198  ptd[2] = {MakePtD(*jet, tracks, clusters), 0.};
199  FillTree(datajets->GetJetRadius(), weight, jet, nullptr, &(structure.fSoftDrop), nullptr, &(structure.fNsubjettiness), nullptr, angularity, ptd);
200  } catch(ReclusterizerException &e) {
201  AliErrorStream() << "Error in reclusterization - skipping jet" << std::endl;
202  }
203  }
204  }
205  }
206 
207  return true;
208 }
209 
211  const AliEmcalJet *datajet, const AliEmcalJet *mcjet,
212  AliSoftDropParameters *dataSoftdrop, AliSoftDropParameters *mcSoftdrop,
213  AliNSubjettinessParameters *dataSubjettiness, AliNSubjettinessParameters *mcSubjettiness,
214  Double_t *angularity, Double_t *ptd){
215  fJetTreeData[kTRadius] = r;
216  fJetTreeData[kTWeight] = weight;
217  if(datajet) {
218  fJetTreeData[kTPtJetRec] = TMath::Abs(datajet->Pt());
220  fJetTreeData[kTNNeutral] = datajet->GetNumberOfClusters();
221  fJetTreeData[kTAreaRec] = datajet->Area();
222  fJetTreeData[kTNEFRec] = datajet->NEF();
223  fJetTreeData[kTMassRec] = datajet->M();
224  } else {
225  fJetTreeData[kTPtJetRec] = 0.;
228  fJetTreeData[kTAreaRec] = 0.;
229  fJetTreeData[kTNEFRec] = 0.;
230  fJetTreeData[kTMassRec] = 0.;
231  }
232 
233  if(mcjet) {
234  fJetTreeData[kTPtJetSim] = TMath::Abs(mcjet->Pt());
236  fJetTreeData[kTAreaSim] = mcjet->Area();
237  fJetTreeData[kTNEFSim] = mcjet->NEF();
238  fJetTreeData[kTMassSim] = mcjet->M();
239  } else {
240  fJetTreeData[kTPtJetSim] = 0.;
242  fJetTreeData[kTAreaSim] = 0.;
243  fJetTreeData[kTNEFSim] = 0.;
244  fJetTreeData[kTMassSim] = 0;
245  }
246 
247  if(dataSoftdrop) {
248  fJetTreeData[kTZgMeasured] = dataSoftdrop->fZg;
249  fJetTreeData[kTRgMeasured] = dataSoftdrop->fRg;
250  fJetTreeData[kTMgMeasured] = dataSoftdrop->fMg;
251  fJetTreeData[kTPtgMeasured] = dataSoftdrop->fPtg;
252  fJetTreeData[kTNDroppedMeasured] = dataSoftdrop->fNDropped;
253  } else {
259  }
260 
261  if(mcSoftdrop) {
262  fJetTreeData[kTZgTrue] = mcSoftdrop->fZg;
263  fJetTreeData[kTRgTrue] = mcSoftdrop->fRg;
264  fJetTreeData[kTMgTrue] = mcSoftdrop->fMg;
265  fJetTreeData[kTPtgTrue] = mcSoftdrop->fPtg;
266  fJetTreeData[kTNDroppedTrue] = mcSoftdrop->fNDropped;
267  } else {
268  fJetTreeData[kTZgTrue] = 0.;
269  fJetTreeData[kTRgTrue] = 0.;
270  fJetTreeData[kTMgTrue] = 0.;
271  fJetTreeData[kTPtgTrue] = 0.;
273  }
274 
275  if(dataSubjettiness) {
278  } else {
281  }
282 
283  if(mcSubjettiness) {
286  } else {
289  }
290 
291  fJetTreeData[kAngularityMeasured] = angularity[0];
292  fJetTreeData[kAngularityTrue] = angularity[1];
293  fJetTreeData[kPtDMeasured] = ptd[0];
294  fJetTreeData[kPtDTrue] = ptd[1];
295 
296  fJetSubstructureTree->Fill();
297 }
298 
299 
301  const int kClusterOffset = 30000; // In order to handle tracks and clusters in the same index space the cluster index needs and offset, large enough so that there is no overlap with track indices
302  std::vector<fastjet::PseudoJet> constituents;
303  for(int itrk = 0; itrk < jet.GetNumberOfTracks(); itrk++){
304  AliVTrack *track = static_cast<AliVTrack *>(jet.TrackAt(itrk, tracks->GetArray()));
305  fastjet::PseudoJet constituentTrack(track->Px(), track->Py(), track->Pz(), track->E());
306  constituentTrack.set_user_index(jet.TrackAt(itrk));
307  constituents.push_back(constituentTrack);
308  }
309 
310  for(int icl = 0; icl < jet.GetNumberOfClusters(); icl++) {
311  AliVCluster *cluster = jet.ClusterAt(icl, clusters->GetArray());
312  TLorentzVector clustervec;
313  cluster->GetMomentum(clustervec, fVertex);
314  fastjet::PseudoJet constituentCluster(clustervec.Px(), clustervec.Py(), clustervec.Pz(), cluster->GetHadCorrEnergy());
315  constituentCluster.set_user_index(jet.ClusterAt(icl) + kClusterOffset);
316  constituents.push_back(constituentCluster);
317  }
318 
319  // Redo jet finding on constituents with a
320  fastjet::JetDefinition jetdef(fastjet::antikt_algorithm, jetradius*2, static_cast<fastjet::RecombinationScheme>(0), fastjet::BestFJ30 );
321  std::vector<fastjet::PseudoJet> outputjets;
322  try {
323  fastjet::ClusterSequence jetfinder(constituents, jetdef);
324  outputjets = jetfinder.inclusive_jets(0);
325  AliJetSubstructureData result({MakeSoftDropParameters(outputjets[0], settings.fSoftdropSettings), MakeNsubjettinessParameters(outputjets[0], settings.fSubjettinessSettings)});
326  return result;
327  } catch (fastjet::Error &e) {
328  AliErrorStream() << " FJ Exception caught: " << e.message() << std::endl;
329  throw ReclusterizerException();
330  }
331 }
332 
334  fastjet::contrib::SoftDrop softdropAlgorithm(cutparameters.fBeta, cutparameters.fZ);
335  softdropAlgorithm.set_verbose_structure(kTRUE);
336  std::unique_ptr<fastjet::contrib::Recluster> reclusterizer(new fastjet::contrib::Recluster(cutparameters.fRecluserAlgo, 1, true));
337  softdropAlgorithm.set_reclustering(kTRUE, reclusterizer.get());
338  fastjet::PseudoJet groomed = softdropAlgorithm(jet);
339 
340  AliSoftDropParameters result({groomed.structure_of<fastjet::contrib::SoftDrop>().symmetry(),
341  groomed.structure_of<fastjet::contrib::SoftDrop>().delta_R(),
342  groomed.structure_of<fastjet::contrib::SoftDrop>().mu(),
343  groomed.perp(),
344  groomed.structure_of<fastjet::contrib::SoftDrop>().dropped_count()});
345  return result;
346 }
347 
350  fastjet::contrib::Nsubjettiness (1,fastjet::contrib::KT_Axes(),fastjet::contrib::NormalizedMeasure(cut.fBeta,cut.fRadius)).result(jet),
351  fastjet::contrib::Nsubjettiness (2,fastjet::contrib::KT_Axes(),fastjet::contrib::NormalizedMeasure(cut.fBeta,cut.fRadius)).result(jet)
352  });
353  return result;
354 }
355 
357  if(!jet.GetNumberOfTracks()) return 0;
358  TVector3 jetvec(jet.Px(), jet.Py(), jet.Pz());
359  Double_t den(0.), num(0.);
360  if(tracks){
361  for(UInt_t itrk = 0; itrk < jet.GetNumberOfTracks(); itrk++) {
362  AliVParticle *track = jet.TrackAt(itrk, tracks->GetArray());
363  if(!track){
364  AliErrorStream() << "Associated constituent particle / track not found\n";
365  continue;
366  }
367  TVector3 trackvec(track->Px(), track->Py(), track->Pz());
368 
369  num += track->Pt() * trackvec.DrEtaPhi(jetvec);
370  den += +track->Pt();
371  }
372  }
373  if(clusters) {
374  for(UInt_t icl = 0; icl < jet.GetNumberOfClusters(); icl++){
375  AliVCluster *clust = jet.ClusterAt(icl, clusters->GetArray());
376  if(!clust) {
377  AliErrorStream() << "Associated constituent cluster not found\n";
378  continue;
379  }
380  TLorentzVector clusterp;
381  clust->GetMomentum(clusterp, fVertex);
382 
383  num += clusterp.Pt() * clusterp.Vect().DrEtaPhi(jetvec);
384  den += clusterp.Pt();
385  }
386  }
387  return num/den;
388 }
389 
391  if (!jet.GetNumberOfTracks()) return 0;
392  Double_t den(0.), num(0.);
393  if(particles){
394  for(UInt_t itrk = 0; itrk < jet.GetNumberOfTracks(); itrk++) {
395  AliVParticle *trk = jet.TrackAt(itrk, particles->GetArray());
396  if(!trk){
397  AliErrorStream() << "Associated constituent particle / track not found\n";
398  continue;
399  }
400  num += trk->Pt() * trk->Pt();
401  den += trk->Pt();
402  }
403  }
404  if(clusters){
405  for(UInt_t icl = 0; icl < jet.GetNumberOfClusters(); icl++){
406  AliVCluster *clust = jet.ClusterAt(icl, clusters->GetArray());
407  if(!clust) {
408  AliErrorStream() << "Associated constituent cluster not found\n";
409  continue;
410  }
411  TLorentzVector clusterp;
412  clust->GetMomentum(clusterp, fVertex);
413  num += clusterp.Pt() * clusterp.Pt();
414  den += clusterp.Pt();
415  }
416  }
417  return TMath::Sqrt(num)/den;
418 }
419 
421  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
422 
423  Bool_t isAOD(kFALSE);
424  AliInputEventHandler *inputhandler = static_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
425  if(inputhandler) {
426  if(inputhandler->IsA() == AliAODInputHandler::Class()) isAOD = kTRUE;
427  }
428 
429  AliAnalysisTaskEmcalJetSubstructureTree *treemaker = new AliAnalysisTaskEmcalJetSubstructureTree("JetSubstructureTreemaker_" + TString::Format("R%02d_", int(jetradius * 10.)) + trigger);
430  mgr->AddTask(treemaker);
431  treemaker->SetMakeGeneralHistograms(kTRUE);
432  treemaker->SetVzRange(-10., 10);
433 
434  // Adding containers
435  if(isMC) {
436  AliParticleContainer *particles = treemaker->AddMCParticleContainer("mcparticles");
437 
438  AliJetContainer *mcjets = treemaker->AddJetContainer(
442  jetradius,
444  particles, nullptr);
445  mcjets->SetName("mcjets");
446  mcjets->SetJetPtCut(20.);
447  }
448 
449  if(isData) {
451  tracks->SetMinPt(0.15);
453  clusters->SetMinE(0.3); // 300 MeV E-cut
454 
455  AliJetContainer *datajets = treemaker->AddJetContainer(
459  jetradius,
461  tracks, clusters);
462  datajets->SetName("datajets");
463  datajets->SetJetPtCut(20.);
464 
465  treemaker->SetUseAliAnaUtils(true, true);
466 
467  // configure trigger selection
468  TString triggerstring(trigger);
469  if(triggerstring.Contains("INT7")) {
470  treemaker->SetTriggerBits(AliVEvent::kINT7);
471  } else if(triggerstring.Contains("EJ1")) {
472  treemaker->SetTriggerBits(AliVEvent::kEMCEJE);
473  treemaker->SetTriggerString("EJ1");
474  } else if(triggerstring.Contains("EJ2")) {
475  treemaker->SetTriggerBits(AliVEvent::kEMCEJE);
476  treemaker->SetTriggerString("EJ2");
477  }
478  }
479 
480  // Connecting containers
481  TString outputfile = mgr->GetCommonFileName();
482  outputfile += TString::Format(":JetSubstructure_R%02d_%s", int(jetradius * 10.), trigger);
483  mgr->ConnectInput(treemaker, 0, mgr->GetCommonInputContainer());
484  mgr->ConnectOutput(treemaker, 1, mgr->CreateContainer("JetSubstructureHistos_" + TString::Format("R%0d_", int(jetradius * 10.)) + trigger, AliEmcalList::Class(), AliAnalysisManager::kOutputContainer, outputfile));
485  mgr->ConnectOutput(treemaker, 2, mgr->CreateContainer("JetSubstuctureTree_" + TString::Format("R%0d_", int(jetradius * 10.)) + trigger, TTree::Class(), AliAnalysisManager::kOutputContainer, Form("JetSubstructureTree_%s.root", trigger)));
486 
487  return treemaker;
488 }
489 
490 } /* namespace EmcalTriggerJets */
Double_t Area() const
Definition: AliEmcalJet.h:123
double Double_t
Definition: External.C:58
Double_t MakePtD(const AliEmcalJet &jet, const AliParticleContainer *const particles, const AliClusterContainer *const clusters) const
AliJetContainer * GetJetContainer(Int_t i=0) const
Double_t Py() const
Definition: AliEmcalJet.h:100
Container with name, TClonesArray and cuts for particles.
void SetUseAliAnaUtils(Bool_t b, Bool_t bRejPilup=kTRUE)
AliJetSubstructureData MakeJetSubstructure(const AliEmcalJet &jet, double jetradius, const AliParticleContainer *tracks, const AliClusterContainer *clusters, const AliJetSubstructureSettings &settings) const
AliEmcalJet * MatchedJet() const
Definition: AliEmcalJet.h:226
Int_t ClusterAt(Int_t idx) const
Definition: AliEmcalJet.h:130
AliJetContainer * AddJetContainer(const char *n, TString defaultCutType, Float_t jetRadius=0.4)
Structure for results from the soft drop algorithm.
virtual bool Run()
Run function. This is the core function of the analysis and contains the user code. Therefore users have to implement this function.
void SetVzRange(Double_t min, Double_t max)
AliClusterContainer * AddClusterContainer(const char *n)
Create new cluster container and attach it to the task.
fastjet::JetAlgorithm fRecluserAlgo
Reclusterization algorithm.
UShort_t GetNumberOfConstituents() const
Definition: AliEmcalJet.h:133
Container for particles within the EMCAL framework.
Int_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:153
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:132
Double_t Px() const
Definition: AliEmcalJet.h:99
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
UShort_t GetNumberOfClusters() const
Definition: AliEmcalJet.h:131
void SetJetPtCut(Float_t cut)
unsigned int UInt_t
Definition: External.C:33
void FillTree(double r, double weight, const AliEmcalJet *datajet, const AliEmcalJet *mcjet, AliSoftDropParameters *dataSoftdrop, AliSoftDropParameters *mcsoftdrop, AliNSubjettinessParameters *dataSubjettiness, AliNSubjettinessParameters *mcSubjettiness, Double_t *angularity, Double_t *ptd)
AliNSubjettinessParameters MakeNsubjettinessParameters(const fastjet::PseudoJet &jet, const AliNSubjettinessDefinition &cut) const
Definition for the algorithm obtaining the softdrop parameters.
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Get cluster container attached to this task.
AliMCParticleContainer * AddMCParticleContainer(const char *n)
Create new container for MC particles and attach it to the task.
Double_t MakeAngularity(const AliEmcalJet &jet, const AliParticleContainer *tracks, const AliClusterContainer *clusters) const
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)
Double_t Pt() const
Definition: AliEmcalJet.h:102
ClassImp(AliAnalysisTaskDeltaPt) AliAnalysisTaskDeltaPt
Bool_t isMC
Float_t GetJetRadius() const
AliEmcalList * fOutput
!output list
Double_t fVertex[3]
!event vertex
AliTrackContainer * AddTrackContainer(const char *n)
Create new track container and attach it to the task.
AliTrackContainer * GetTrackContainer(Int_t i=0) const
void SetMakeGeneralHistograms(Bool_t g)
Base task in the EMCAL jet framework.
static AliAnalysisTaskEmcalJetSubstructureTree * AddEmcalJetSubstructureTreeMaker(Bool_t isMC, Bool_t isData, Double_t jetradius, const char *name)
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
Double_t Pz() const
Definition: AliEmcalJet.h:101
AliSoftDropParameters MakeSoftDropParameters(const fastjet::PseudoJet &jet, const AliSoftdropDefinition &cut) const
void UserCreateOutputObjects()
Main initialization function on the worker.
const AliJetIterableContainer accepted() const
bool Bool_t
Definition: External.C:53
Double_t NEF() const
Definition: AliEmcalJet.h:141
Container structure for EMCAL clusters.
Double_t M() const
Definition: AliEmcalJet.h:113
EMCal fiducial acceptance (each eta, phi edge narrowed by jet R)
Definition: AliEmcalJet.h:63
Container for jet within the EMCAL jet framework.
TList * OpenFile(const char *fname)
Definition: DrawAnaELoss.C:65
static TString ClusterContainerNameFactory(Bool_t isAOD)
Get name of the default cluster container.
static TString TrackContainerNameFactory(Bool_t isAOD)
Get name of the default track container.