AliPhysics  7622010 (7622010)
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 <set>
30 #include <sstream>
31 #include <vector>
32 
33 #include <fastjet/ClusterSequence.hh>
34 #include <fastjet/contrib/Nsubjettiness.hh>
35 #include <fastjet/contrib/SoftDrop.hh>
36 
37 #include <THistManager.h>
38 #include <TLinearBinning.h>
39 #include <TLorentzVector.h>
40 #include <TMath.h>
41 #include <TObjString.h>
42 #include <TString.h>
43 #include <TVector3.h>
44 
45 #include "AliAODEvent.h"
46 #include "AliAODInputHandler.h"
47 #include "AliAnalysisManager.h"
48 #include "AliAnalysisDataSlot.h"
49 #include "AliAnalysisDataContainer.h"
51 #include "AliCDBEntry.h"
52 #include "AliCDBManager.h"
53 #include "AliClusterContainer.h"
54 #include "AliJetContainer.h"
57 #include "AliEmcalJet.h"
58 #include "AliEmcalList.h"
60 #include "AliLog.h"
61 #include "AliParticleContainer.h"
62 #include "AliRhoParameter.h"
63 #include "AliTrackContainer.h"
64 #include "AliTriggerCluster.h"
65 #include "AliTriggerConfiguration.h"
66 #include "AliVCluster.h"
67 #include "AliVParticle.h"
68 
69 #ifdef EXPERIMENTAL_JETCONSTITUENTS
72 #endif
73 
74 
78 
79 namespace EmcalTriggerJets {
80 
83  fJetSubstructureTree(nullptr),
84  fQAHistos(nullptr),
85  fLumiMonitor(nullptr),
86  fSDZCut(0.1),
87  fSDBetaCut(0),
88  fReclusterizer(kCAAlgo),
89  fTriggerSelectionBits(AliVEvent::kAny),
90  fTriggerSelectionString(""),
91  fUseDownscaleWeight(false),
92  fFillPart(true),
93  fFillAcceptance(true),
94  fFillRho(true),
95  fFillMass(true),
96  fFillSoftDrop(true),
97  fFillNSub(true),
98  fFillStructGlob(true)
99 {
100  memset(fJetTreeData, 0, sizeof(Double_t) * kTNVar);
101 }
102 
104  AliAnalysisTaskEmcalJet(name, kTRUE),
108  fSDZCut(0.1),
109  fSDBetaCut(0),
111  fTriggerSelectionBits(AliVEvent::kAny),
113  fUseDownscaleWeight(false),
114  fFillPart(true),
115  fFillAcceptance(true),
116  fFillRho(true),
117  fFillMass(true),
118  fFillSoftDrop(true),
119  fFillNSub(true),
120  fFillStructGlob(true)
121 {
122  memset(fJetTreeData, 0, sizeof(Double_t) * kTNVar);
123  DefineOutput(2, TTree::Class());
124 }
125 
127 
128 }
129 
132 
133  // Make QA for constituent clusters
134  TLinearBinning jetptbinning(9, 20, 200),
135  clusterenergybinning(200, 0., 200),
136  timebinning(1000, -500., 500.),
137  m02binning(100, 0., 1.),
138  ncellbinning(101, -0.5, 100.5);
139  fQAHistos = new THistManager("QAhistos");
140  fQAHistos->CreateTH1("hEventCounter", "Event counter", 1, 0.5, 1.5);
141  fQAHistos->CreateTH2("hClusterConstE", "EMCAL cluster energy vs jet pt; p_{t, jet} (GeV/c); E_{cl} (GeV)", jetptbinning, clusterenergybinning);
142  fQAHistos->CreateTH2("hClusterConstTime", "EMCAL cluster time vs. jet pt; p_{t, jet} (GeV/c); t_{cl} (ns)", jetptbinning, timebinning);
143  fQAHistos->CreateTH2("hClusterConstM02", "EMCAL cluster M02 vs. jet pt; p{t, jet} (GeV/c); M02", jetptbinning, m02binning);
144  fQAHistos->CreateTH2("hClusterConstNcell", "EMCAL cluster ncell vs. jet pt; p{t, jet} (GeV/c); Number of cells", jetptbinning, ncellbinning);
145 
146  // Test of constituent QA
147 #ifdef EXPERIMENTAL_JETCONSTITUENTS
148  fQAHistos->CreateTH2("hChargedConstituentPt", "charged constituent pt vs jet pt (via constituent map); p_{t,jet} (GeV/c); p_{t,ch} (GeV/c)", jetptbinning, clusterenergybinning);
149  fQAHistos->CreateTH2("hChargedIndexPt", "charged constituent pt vs jet pt (via index map); p_{t, jet} (GeV/c); p_{t, ch} (GeV/c)", jetptbinning, clusterenergybinning);
150 
151  fQAHistos->CreateTH2("hClusterConstituentEDefault", "cluster constituent default energy vs. jet pt (va constituent map); p_{t, jet} (GeV/c); E_{cl} (GeV)", jetptbinning, clusterenergybinning);
152  fQAHistos->CreateTH2("hClusterConstituentENLC", "cluster constituent non-linearity-corrected energy vs. jet pt (va constituent map); p_{t, jet} (GeV/c); E_{cl} (GeV)", jetptbinning, clusterenergybinning);
153  fQAHistos->CreateTH2("hClusterConstituentEHC", "cluster constituent hadronic-corrected energy vs. jet pt (va constituent map); p_{t, jet} (GeV/c); E_{cl} (GeV)", jetptbinning, clusterenergybinning);
154  fQAHistos->CreateTH2("hClusterIndexENLC", "cluster constituent non-linearity-corrected energy vs. jet pt (via index map); p_{t, jet} (GeV/c); E_{cl} (GeV)", jetptbinning, clusterenergybinning);
155  fQAHistos->CreateTH2("hClusterIndexEHC", "cluster constituent hadronic-corrected energy vs. jet pt (via index map); p_{t, jet} (GeV/c); E_{cl} (GeV)", jetptbinning, clusterenergybinning);
156 #endif
157  for(auto h : *(fQAHistos->GetListOfHistograms())) fOutput->Add(h);
158 
159  OpenFile(2);
160  TString treename = this->GetOutputSlot(2)->GetContainer()->GetName();
161  fJetSubstructureTree = new TTree(treename, "Tree with jet substructure information");
162  TString varnames[kTNVar];
163  varnames[0] = "Radius";
164  varnames[1] = "EventWeight";
165  varnames[2] = "PtJetRec";
166  varnames[3] = "PtJetSim";
167  varnames[4] = "EJetRec";
168  varnames[5] = "EJetSim";
169  varnames[6] = "EtaRec";
170  varnames[7] = "EtaSim";
171  varnames[8] = "PhiRec";
172  varnames[9] = "PhiSim";
173  varnames[10] = "RhoPtRec";
174  varnames[11] = "RhoPtSim";
175  varnames[12] = "RhoMassRec";
176  varnames[13] = "RhoMassSim";
177  varnames[14] = "AreaRec";
178  varnames[15] = "AreaSim";
179  varnames[16] = "NEFRec";
180  varnames[17] = "NEFSim";
181  varnames[18] = "MassRec";
182  varnames[19] = "MassSim";
183  varnames[20] = "ZgMeasured";
184  varnames[21] = "ZgTrue";
185  varnames[22] = "RgMeasured";
186  varnames[23] = "RgTrue";
187  varnames[24] = "MgMeasured";
188  varnames[25] = "MgTrue";
189  varnames[26] = "PtgMeasured";
190  varnames[27] = "PtgTrue";
191  varnames[28] = "MugMeasured";
192  varnames[29] = "MugTrue";
193  varnames[30] = "OneSubjettinessMeasured";
194  varnames[31] = "OneSubjettinessTrue";
195  varnames[32] = "TwoSubjettinessMeasured";
196  varnames[33] = "TwoSubjettinessTrue";
197  varnames[34] = "AngularityMeasured";
198  varnames[35] = "AngularityTrue";
199  varnames[36] = "PtDMeasured";
200  varnames[37] = "PtDTrue";
201  varnames[38] = "NCharged";
202  varnames[39] = "NNeutral";
203  varnames[40] = "NConstTrue";
204  varnames[41] = "NDroppedMeasured";
205  varnames[42] = "NDroppedTrue";
206 
207  for(int ib = 0; ib < kTNVar; ib++){
208  LinkOutputBranch(varnames[ib], fJetTreeData + ib);
209  }
210  PostData(1, fOutput);
211  PostData(2, fJetSubstructureTree);
212 }
213 
215  // Check whether branch is rejected
216  if(!fFillPart && IsPartBranch(branchname)) return;
217  if(!fFillAcceptance && IsAcceptanceBranch(branchname)) return;
218  if(!fFillRho && IsRhoBranch(branchname)) return;
219  if(!fFillMass && IsMassBranch(branchname)) return;
220  if(!fFillSoftDrop && IsSoftdropBranch(branchname)) return;
221  if(!fFillNSub && IsNSubjettinessBranch(branchname)) return;
222  if(!fFillStructGlob && IsStructbranch(branchname)) return;
223 
224  std::cout << "Adding branch " << branchname << std::endl;
225  fJetSubstructureTree->Branch(branchname, datalocation, Form("%s/D", branchname.Data()));
226 }
227 
231  }
232 }
233 
237  AliParticleContainer *particles = GetParticleContainer("mcparticles");
238 
239  AliJetContainer *mcjets = GetJetContainer("mcjets");
240  AliJetContainer *datajets = GetJetContainer("datajets");
241 
242  FillLuminosity(); // Makes only sense in data
243 
244  // for(auto e : *(fInputEvent->GetList())) std::cout << e->GetName() << std::endl;
245 
246  TString rhoTagData = datajets ? TString::Format("R%02d", static_cast<Int_t>(datajets->GetJetRadius() * 10.)) : "",
247  rhoTagMC = mcjets ? TString::Format("R%02d", static_cast<Int_t>(mcjets->GetJetRadius() * 10.)) : "";
248 
249  AliRhoParameter *rhoPtRec = GetRhoFromEvent("RhoSparse_Full_" + rhoTagData),
250  *rhoMassRec = GetRhoFromEvent("RhoMassSparse_Full_" + rhoTagData),
251  *rhoPtSim = GetRhoFromEvent("RhoSparse_Full_" + rhoTagMC),
252  *rhoMassSim = GetRhoFromEvent("RhoMassSparse_Full_" + rhoTagMC);
253  AliDebugStream(2) << "Found rho parameter for reconstructed pt: " << (rhoPtRec ? "yes" : "no") << ", value: " << (rhoPtRec ? rhoPtRec->GetVal() : 0.) << std::endl;
254  AliDebugStream(2) << "Found rho parameter for sim pt: " << (rhoPtSim ? "yes" : "no") << ", value: " << (rhoPtSim ? rhoPtSim->GetVal() : 0.) << std::endl;
255  AliDebugStream(2) << "Found rho parameter for reconstructed Mass: " << (rhoMassRec ? "yes" : "no") << ", value: " << (rhoMassRec ? rhoMassRec->GetVal() : 0.) << std::endl;
256  AliDebugStream(2) << "Found rho parameter for sim Mass: " << (rhoMassSim ? "yes" : "no") << ", value: " << (rhoMassSim ? rhoMassSim->GetVal() : 0.) << std::endl;
257 
258  AliDebugStream(1) << "Inspecting jet radius " << (datajets ? datajets->GetJetRadius() : mcjets->GetJetRadius()) << std::endl;
259 
260  double weight = 1.;
263  }
264 
265  // Run trigger selection (not on pure MCgen train)
266  if(datajets){
267  if(!(fInputHandler->IsEventSelected() & fTriggerSelectionBits)) return false;
268  if(!mcjets){
269  // Pure data - do EMCAL trigger selection from selection string
270  if(fTriggerSelectionString.Length()) {
271  if(!fInputEvent->GetFiredTriggerClasses().Contains(fTriggerSelectionString)) return false;
272  }
273  } else {
274  // Simulation - do EMCAL trigger selection from trigger selection object
275  PWG::EMCAL::AliEmcalTriggerDecisionContainer *mctrigger = static_cast<PWG::EMCAL::AliEmcalTriggerDecisionContainer *>(fInputEvent->FindListObject("EmcalTriggerDecision"));
276  AliDebugStream(1) << "Found trigger decision object: " << (mctrigger ? "yes" : "no") << std::endl;
277  if(fTriggerSelectionString.Length()){
278  if(!mctrigger){
279  AliErrorStream() << "Trigger decision container not found in event - not possible to select EMCAL triggers" << std::endl;
280  return false;
281  }
282  if(!mctrigger->IsEventSelected(fTriggerSelectionString)) return false;
283  }
284  }
285  }
286 
287  // Count events (for spectrum analysis)
288  fQAHistos->FillTH1("hEventCounter", 1);
289 
290  Double_t rhoparameters[4]; memset(rhoparameters, 0, sizeof(Double_t) * 4);
291  if(rhoPtRec) rhoparameters[0] = rhoPtRec->GetVal();
292  if(rhoPtSim) rhoparameters[1] = rhoPtSim->GetVal();
293  if(rhoMassRec) rhoparameters[2] = rhoMassRec->GetVal();
294  if(rhoMassSim) rhoparameters[3] = rhoMassSim->GetVal();
295 
296  AliSoftdropDefinition softdropSettings;
297  softdropSettings.fBeta = fSDBetaCut;
298  softdropSettings.fZ = fSDZCut;
299  switch(fReclusterizer) {
300  case kCAAlgo: softdropSettings.fRecluserAlgo = fastjet::cambridge_aachen_algorithm; break;
301  case kKTAlgo: softdropSettings.fRecluserAlgo = fastjet::kt_algorithm; break;
302  case kAKTAlgo: softdropSettings.fRecluserAlgo = fastjet::antikt_algorithm; break;
303  };
304 
305  AliNSubjettinessDefinition nsubjettinessSettings;
306  nsubjettinessSettings.fBeta = 1.;
307  nsubjettinessSettings.fRadius = 0.4;
308 
309  if(datajets) {
310  AliDebugStream(1) << "In data jets branch: found " << datajets->GetNJets() << " jets, " << datajets->GetNAcceptedJets() << " were accepted\n";
311  AliDebugStream(1) << "Having MC information: " << (mcjets ? TString::Format("yes, with %d jets", mcjets->GetNJets()) : "no") << std::endl;
312  if(mcjets) {
313  AliDebugStream(1) << "In MC jets branch: found " << mcjets->GetNJets() << " jets, " << mcjets->GetNAcceptedJets() << " were accepted\n";
314  }
315  for(auto jet : datajets->accepted()) {
316  double pt = jet->Pt(), pz = jet->Pz(), E = jet->E(), M = TMath::Sqrt(E*E - pt*pt - pz*pz);
317  AliDebugStream(2) << "Next jet: pt:" << jet->Pt() << ", E: " << E << ", pz: " << pz << ", M(self): " << M << "M(fj)" << jet->M() << std::endl;
318  AliEmcalJet *associatedJet = jet->ClosestJet();
319 
320  if(mcjets) {
321  if(!associatedJet) {
322  AliDebugStream(2) << "Not found associated jet" << std::endl;
323  continue;
324  }
325  try {
326  DoConstituentQA(jet, tracks, clusters);
327  AliJetSubstructureData structureData = MakeJetSubstructure(*jet, datajets->GetJetRadius() * 2., tracks, clusters, {softdropSettings, nsubjettinessSettings}),
328  structureMC = fFillPart ? MakeJetSubstructure(*associatedJet, mcjets->GetJetRadius() * 2, particles, nullptr, {softdropSettings, nsubjettinessSettings}) : AliJetSubstructureData();
329  Double_t angularity[2] = {fFillStructGlob ? MakeAngularity(*jet, tracks, clusters) : 0., (fFillStructGlob && fFillPart) ? MakeAngularity(*associatedJet, particles, nullptr) : 0.},
330  ptd[2] = {fFillStructGlob ? MakePtD(*jet, tracks, clusters) : 0., (fFillStructGlob && fFillPart) ? MakePtD(*associatedJet, particles, nullptr) : 0};
331  FillTree(datajets->GetJetRadius(), weight, jet, associatedJet, &(structureData.fSoftDrop), &(structureMC.fSoftDrop), &(structureData.fNsubjettiness), &(structureMC.fNsubjettiness), angularity, ptd, rhoparameters);
332  } catch(ReclusterizerException &e) {
333  AliErrorStream() << "Error in reclusterization - skipping jet" << std::endl;
334  } catch(SubstructureException &e) {
335  AliErrorStream() << "Error in substructure observable - skipping jet" << std::endl;
336  }
337  } else {
338  try {
339  DoConstituentQA(jet, tracks, clusters);
340  AliJetSubstructureData structure = MakeJetSubstructure(*jet, 0.4, tracks, clusters, {softdropSettings, nsubjettinessSettings});
341  Double_t angularity[2] = {fFillStructGlob ? MakeAngularity(*jet, tracks, clusters): 0., 0.},
342  ptd[2] = {fFillStructGlob ? MakePtD(*jet, tracks, clusters) : 0., 0.};
343  FillTree(datajets->GetJetRadius(), weight, jet, nullptr, &(structure.fSoftDrop), nullptr, &(structure.fNsubjettiness), nullptr, angularity, ptd, rhoparameters);
344  } catch(ReclusterizerException &e) {
345  AliErrorStream() << "Error in reclusterization - skipping jet" << std::endl;
346  } catch(SubstructureException &e) {
347  AliErrorStream() << "Error in substructure observable - skipping jet" << std::endl;
348  }
349  }
350  }
351  } else {
352  if(mcjets) {
353  // for MCgen train
354  AliDebugStream(1) << "In MC pure jet branch: found " << mcjets->GetNJets() << " jets, " << mcjets->GetNAcceptedJets() << " were accepted\n";
355  for(auto j : mcjets->accepted()){
356  AliEmcalJet *mcjet = static_cast<AliEmcalJet *>(j);
357  try {
358  AliJetSubstructureData structure = MakeJetSubstructure(*mcjet, mcjets->GetJetRadius() * 2., particles, nullptr,{softdropSettings, nsubjettinessSettings});
359  Double_t angularity[2] = {0., MakeAngularity(*mcjet, particles, nullptr)},
360  ptd[2] = {0., MakePtD(*mcjet, particles, nullptr)};
361  FillTree(mcjets->GetJetRadius(), weight, nullptr, mcjet, nullptr, &(structure.fSoftDrop), nullptr, &(structure.fNsubjettiness), angularity, ptd, rhoparameters);
362  } catch (ReclusterizerException &e) {
363  AliErrorStream() << "Error in reclusterization - skipping jet" << std::endl;
364  } catch (SubstructureException &e) {
365  AliErrorStream() << "Error in substructure observable - skipping jet" << std::endl;
366  }
367  }
368  }
369  }
370 
371  return true;
372 }
373 
375  AliCDBManager * cdb = AliCDBManager::Instance();
376  if(!fMCEvent && cdb){
377  // Get List of trigger clusters
378  AliCDBEntry *en = cdb->Get("GRP/CTP/Config");
379  AliTriggerConfiguration *trg = static_cast<AliTriggerConfiguration *>(en->GetObject());
380  std::vector<std::string> clusternames;
381  for(auto c : trg->GetClusters()) {
382  AliTriggerCluster *clust = static_cast<AliTriggerCluster *>(c);
383  std::string clustname = clust->GetName();
384  auto iscent = clustname.find("CENT") != std::string::npos, iscalo = clustname.find("CALO") != std::string::npos;
385  if(!(iscalo || iscent)) continue;
386  clusternames.emplace_back(clustname);
387  }
388 
389  // Set the x-axis of the luminosity monitor histogram
390  fLumiMonitor = new TH1F("hLumiMonitor", "Luminosity monitor", clusternames.size(), 0, clusternames.size());
391  int currentbin(1);
392  for(auto c : clusternames) {
393  fLumiMonitor->GetXaxis()->SetBinLabel(currentbin++, c.data());
394  }
395  fOutput->Add(fLumiMonitor);
396  }
397 }
398 
400  const AliEmcalJet *datajet, const AliEmcalJet *mcjet,
401  AliSoftDropParameters *dataSoftdrop, AliSoftDropParameters *mcSoftdrop,
402  AliNSubjettinessParameters *dataSubjettiness, AliNSubjettinessParameters *mcSubjettiness,
403  Double_t *angularity, Double_t *ptd, Double_t *rhoparameters){
404 
405  memset(fJetTreeData,0, sizeof(Double_t) * kTNVar);
406  fJetTreeData[kTRadius] = r;
407  fJetTreeData[kTWeight] = weight;
408  if(fFillRho){
409  fJetTreeData[kTRhoPtRec] = rhoparameters[0];
410  if(fFillMass) fJetTreeData[kTRhoMassRec] = rhoparameters[2];
411  if(fFillPart){
412  fJetTreeData[kTRhoPtSim] = rhoparameters[1];
413  if(fFillMass) fJetTreeData[kTRhoMassSim] = rhoparameters[3];
414  }
415  }
416  if(datajet) {
417  fJetTreeData[kTPtJetRec] = TMath::Abs(datajet->Pt());
419  fJetTreeData[kTNNeutral] = datajet->GetNumberOfClusters();
420  fJetTreeData[kTAreaRec] = datajet->Area();
421  fJetTreeData[kTNEFRec] = datajet->NEF();
422  if(fFillMass) fJetTreeData[kTMassRec] = datajet->M();
423  fJetTreeData[kTEJetRec] = datajet->E();
424  if(fFillAcceptance) {
425  fJetTreeData[kTEtaRec] = datajet->Eta();
426  fJetTreeData[kTPhiRec] = datajet->Phi();
427  }
428  }
429 
430  if(fFillPart && mcjet){
431  fJetTreeData[kTPtJetSim] = TMath::Abs(mcjet->Pt());
433  fJetTreeData[kTAreaSim] = mcjet->Area();
434  fJetTreeData[kTNEFSim] = mcjet->NEF();
435  if(fFillMass) fJetTreeData[kTMassSim] = mcjet->M();
436  fJetTreeData[kTEJetSim] = mcjet->E();
437  if(fFillAcceptance){
438  fJetTreeData[kTEtaSim] = mcjet->Eta();
439  fJetTreeData[kTPhiSim] = mcjet->Phi();
440  }
441  }
442 
443  if(fFillSoftDrop){
444  if(dataSoftdrop) {
445  fJetTreeData[kTZgMeasured] = dataSoftdrop->fZg;
446  fJetTreeData[kTRgMeasured] = dataSoftdrop->fRg;
447  fJetTreeData[kTMgMeasured] = dataSoftdrop->fMg;
448  fJetTreeData[kTPtgMeasured] = dataSoftdrop->fPtg;
449  fJetTreeData[kTMugMeasured] = dataSoftdrop->fMug;
450  fJetTreeData[kTNDroppedMeasured] = dataSoftdrop->fNDropped;
451  }
452 
453  if(fFillPart && mcSoftdrop) {
454  fJetTreeData[kTZgTrue] = mcSoftdrop->fZg;
455  fJetTreeData[kTRgTrue] = mcSoftdrop->fRg;
456  fJetTreeData[kTMgTrue] = mcSoftdrop->fMg;
457  fJetTreeData[kTPtgTrue] = mcSoftdrop->fPtg;
458  fJetTreeData[kTMugTrue] = mcSoftdrop->fMug;
459  fJetTreeData[kTNDroppedTrue] = mcSoftdrop->fNDropped;
460  }
461  }
462 
463  if(fFillNSub){
464  if(dataSubjettiness) {
467  }
468 
469  if(fFillPart && mcSubjettiness) {
472  }
473  }
474 
475  if(fFillStructGlob){
476  fJetTreeData[kTAngularityMeasured] = angularity[0];
477  fJetTreeData[kTPtDMeasured] = ptd[0];
478 
479  if(fFillPart){
480  fJetTreeData[kTAngularityTrue] = angularity[1];
481  fJetTreeData[kTPtDTrue] = ptd[1];
482  }
483  }
484 
485  fJetSubstructureTree->Fill();
486 }
487 
491  if(fInputEvent->GetFiredTriggerClasses().Contains("INT7")) {
492  for(auto trigger : DecodeTriggerString(fInputEvent->GetFiredTriggerClasses().Data())){
493  auto int7trigger = trigger.IsTriggerClass("INT7");
494  auto bunchcrossing = trigger.fBunchCrossing == "B";
495  auto nopf = trigger.fPastFutureProtection == "NOPF";
496  AliDebugStream(4) << "Full name: " << trigger.ExpandClassName() << ", INT7 trigger: " << (int7trigger ? "Yes" : "No") << ", bunch crossing: " << (bunchcrossing ? "Yes" : "No") << ", no past-future protection: " << (nopf ? "Yes" : "No") << ", Cluster: " << trigger.fTriggerCluster << std::endl;
497  if(int7trigger && bunchcrossing && nopf) {
498  double downscale = downscalefactors->GetDownscaleFactorForTriggerClass(trigger.ExpandClassName());
499  AliDebugStream(5) << "Using downscale " << downscale << std::endl;
500  fLumiMonitor->Fill(trigger.fTriggerCluster.data(), 1./downscale);
501  }
502  }
503  }
504  }
505 }
506 
508  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
509  std::vector<fastjet::PseudoJet> constituents;
510  bool isMC = dynamic_cast<const AliTrackContainer *>(tracks);
511  AliDebugStream(2) << "Make new jet substrucutre for " << (isMC ? "MC" : "data") << " jet: Number of tracks " << jet.GetNumberOfTracks() << ", clusters " << jet.GetNumberOfClusters() << std::endl;
512  for(int itrk = 0; itrk < jet.GetNumberOfTracks(); itrk++){
513  auto track = jet.TrackAt(itrk, tracks->GetArray());
514  fastjet::PseudoJet constituentTrack(track->Px(), track->Py(), track->Pz(), track->E());
515  constituentTrack.set_user_index(jet.TrackAt(itrk));
516  constituents.push_back(constituentTrack);
517  }
518 
519  if(clusters){
520  for(int icl = 0; icl < jet.GetNumberOfClusters(); icl++) {
521  auto cluster = jet.ClusterAt(icl, clusters->GetArray());
522  TLorentzVector clustervec;
523  cluster->GetMomentum(clustervec, fVertex, (AliVCluster::VCluUserDefEnergy_t)clusters->GetDefaultClusterEnergy());
524  fastjet::PseudoJet constituentCluster(clustervec.Px(), clustervec.Py(), clustervec.Pz(), cluster->GetHadCorrEnergy());
525  constituentCluster.set_user_index(jet.ClusterAt(icl) + kClusterOffset);
526  constituents.push_back(constituentCluster);
527  }
528  }
529 
530  AliDebugStream(3) << "Found " << constituents.size() << " constituents for jet with pt=" << jet.Pt() << " GeV/c" << std::endl;
531  if(!constituents.size())
532  throw ReclusterizerException();
533  // Redo jet finding on constituents with a
534  fastjet::JetDefinition jetdef(fastjet::antikt_algorithm, jetradius*2, static_cast<fastjet::RecombinationScheme>(0), fastjet::BestFJ30 );
535  std::vector<fastjet::PseudoJet> outputjets;
536  try {
537  fastjet::ClusterSequence jetfinder(constituents, jetdef);
538  outputjets = jetfinder.inclusive_jets(0);
540  return result;
541  } catch (fastjet::Error &e) {
542  AliErrorStream() << " FJ Exception caught: " << e.message() << std::endl;
543  throw ReclusterizerException();
544  } catch (SoftDropException &e) {
545  AliErrorStream() << "Softdrop exception caught: " << e.what() << std::endl;
546  throw ReclusterizerException();
547  }
548 }
549 
551  fastjet::contrib::SoftDrop softdropAlgorithm(cutparameters.fBeta, cutparameters.fZ);
552  softdropAlgorithm.set_verbose_structure(kTRUE);
553  std::unique_ptr<fastjet::contrib::Recluster> reclusterizer(new fastjet::contrib::Recluster(cutparameters.fRecluserAlgo, 1, true));
554  softdropAlgorithm.set_reclustering(kTRUE, reclusterizer.get());
555  AliDebugStream(4) << "Jet has " << jet.constituents().size() << " constituents" << std::endl;
556  auto groomed = softdropAlgorithm(jet);
557  try {
558  auto softdropstruct = groomed.structure_of<fastjet::contrib::SoftDrop>();
559 
560  AliSoftDropParameters result({softdropstruct.symmetry(),
561  groomed.m(),
562  softdropstruct.delta_R(),
563  groomed.perp(),
564  softdropstruct.mu(),
565  softdropstruct.dropped_count()});
566  return result;
567  } catch(std::bad_cast &e) {
568  throw SoftDropException();
569  }
570 }
571 
574  fastjet::contrib::Nsubjettiness (1,fastjet::contrib::KT_Axes(),fastjet::contrib::NormalizedCutoffMeasure(cut.fBeta, cut.fRadius, 1e100)).result(jet),
575  fastjet::contrib::Nsubjettiness (2,fastjet::contrib::KT_Axes(),fastjet::contrib::NormalizedCutoffMeasure(cut.fBeta, cut.fRadius, 1e100)).result(jet)
576  });
577  return result;
578 }
579 
581  if(!(jet.GetNumberOfTracks() || jet.GetNumberOfClusters()))
582  throw SubstructureException();
583  TVector3 jetvec(jet.Px(), jet.Py(), jet.Pz());
584  Double_t den(0.), num(0.);
585  if(tracks){
586  for(UInt_t itrk = 0; itrk < jet.GetNumberOfTracks(); itrk++) {
587  auto track = jet.TrackAt(itrk, tracks->GetArray());
588  if(!track){
589  AliErrorStream() << "Associated constituent particle / track not found\n";
590  continue;
591  }
592  TVector3 trackvec(track->Px(), track->Py(), track->Pz());
593 
594  num += track->Pt() * trackvec.DrEtaPhi(jetvec);
595  den += +track->Pt();
596  }
597  }
598  if(clusters) {
599  for(UInt_t icl = 0; icl < jet.GetNumberOfClusters(); icl++){
600  auto clust = jet.ClusterAt(icl, clusters->GetArray());
601  if(!clust) {
602  AliErrorStream() << "Associated constituent cluster not found\n";
603  continue;
604  }
605  TLorentzVector clusterp;
606  clust->GetMomentum(clusterp, fVertex, (AliVCluster::VCluUserDefEnergy_t)clusters->GetDefaultClusterEnergy());
607 
608  num += clusterp.Pt() * clusterp.Vect().DrEtaPhi(jetvec);
609  den += clusterp.Pt();
610  }
611  }
612  return num/den;
613 }
614 
616  if (!(jet.GetNumberOfTracks() || jet.GetNumberOfClusters()))
617  throw SubstructureException();
618  Double_t den(0.), num(0.);
619  if(particles){
620  for(UInt_t itrk = 0; itrk < jet.GetNumberOfTracks(); itrk++) {
621  auto trk = jet.TrackAt(itrk, particles->GetArray());
622  if(!trk){
623  AliErrorStream() << "Associated constituent particle / track not found\n";
624  continue;
625  }
626  num += trk->Pt() * trk->Pt();
627  den += trk->Pt();
628  }
629  }
630  if(clusters){
631  for(UInt_t icl = 0; icl < jet.GetNumberOfClusters(); icl++){
632  auto clust = jet.ClusterAt(icl, clusters->GetArray());
633  if(!clust) {
634  AliErrorStream() << "Associated constituent cluster not found\n";
635  continue;
636  }
637  TLorentzVector clusterp;
638  clust->GetMomentum(clusterp, fVertex, (AliVCluster::VCluUserDefEnergy_t)clusters->GetDefaultClusterEnergy());
639  num += clusterp.Pt() * clusterp.Pt();
640  den += clusterp.Pt();
641  }
642  }
643  return TMath::Sqrt(num)/den;
644 }
645 
647  for(int icl = 0; icl < jet->GetNumberOfClusters(); icl++){
648  auto clust = jet->ClusterAt(icl, clusters->GetArray());
649  AliDebugStream(3) << "cluster time " << clust->GetTOF() << std::endl;
650  fQAHistos->FillTH2("hClusterConstE", jet->Pt(),clust->GetUserDefEnergy(clusters->GetDefaultClusterEnergy()));
651  fQAHistos->FillTH2("hClusterConstTime", jet->Pt(), clust->GetTOF());
652  fQAHistos->FillTH2("hClusterConstM02", jet->Pt(), clust->GetM02());
653  fQAHistos->FillTH2("hClusterConstNcell", jet->Pt(), clust->GetNCells());
654 
655 #ifdef EXPERIMENTAL_JETCONSTITUENTS
656  fQAHistos->FillTH2("hClusterIndexENLC", jet->Pt(), clust->GetNonLinCorrEnergy());
657  fQAHistos->FillTH2("hClusterIndexEHC", jet->Pt(), clust->GetHadCorrEnergy());
658 #endif
659  }
660 
661 #ifdef EXPERIMENTAL_JETCONSTITUENTS
662  // Loop over charged particles - fill test histogram
663  for(int itrk = 0; itrk < jet->GetNumberOfTracks(); itrk++){
664  auto part = jet->TrackAt(itrk, cont->GetArray());
665  fQAHistos->FillTH2("hChargedIndexPt", jet->Pt(), part->Pt());
666  }
667 
668  // Look over charged constituents
669  AliDebugStream(2) << "Jet: Number of particle constituents: " << jet->GetParticleConstituents().GetEntriesFast() << std::endl;
670  for(auto pconst : jet->GetParticleConstituents()) {
671  auto part = static_cast<PWG::JETFW::AliEmcalParticleJetConstituent *>(pconst);
672  AliDebugStream(3) << "Found particle constituent with pt " << part->Pt() << ", from VParticle " << part->GetParticle()->Pt() << std::endl;
673  fQAHistos->FillTH2("hChargedConstituentPt", jet->Pt(), part->Pt());
674  }
675 
676  // Loop over neutral constituents
677  AliDebugStream(2) << "Jet: Number of cluster constituents: " << jet->GetClusterConstituents().GetEntriesFast() << std::endl;
678  for(auto cconst : jet->GetClusterConstituents()){
679  auto clust = static_cast<PWG::JETFW::AliEmcalClusterJetConstituent *>(cconst);
680  AliDebugStream(3) << "Found cluster constituent with energy " << clust->E() << " using energy definition " << static_cast<int>(clust->GetDefaultEnergyType()) << std::endl;
681  fQAHistos->FillTH2("hClusterConstituentEDefault", jet->Pt(), clust->E());
682  fQAHistos->FillTH2("hClusterConstituentENLC", jet->Pt(), clust->GetCluster()->GetNonLinCorrEnergy());
683  fQAHistos->FillTH2("hClusterConstituentEHC", jet->Pt(), clust->GetCluster()->GetHadCorrEnergy());
684  }
685 #endif
686 }
687 
688 std::vector<Triggerinfo> AliAnalysisTaskEmcalJetSubstructureTree::DecodeTriggerString(const std::string &triggerstring) const {
689  std::vector<Triggerinfo> result;
690  std::stringstream triggerparser(triggerstring);
691  std::string currenttrigger;
692  while(std::getline(triggerparser, currenttrigger, ' ')){
693  if(!currenttrigger.length()) continue;
694  std::vector<std::string> tokens;
695  std::stringstream triggerdecoder(currenttrigger);
696  std::string token;
697  while(std::getline(triggerdecoder, token, '-')) tokens.emplace_back(token);
698  result.emplace_back(Triggerinfo({tokens[0], tokens[1], tokens[2], tokens[3]}));
699  }
700  return result;
701 }
702 
704  std::unique_ptr<TObjArray> tokens(fInputEvent->GetFiredTriggerClasses().Tokenize(","));
705  TString result;
706  for(auto t : *tokens) {
707  TString &triggerclass = static_cast<TObjString *>(t)->String();
708  if(triggerclass.Contains(triggertoken)) {
709  // take first occurrence - downscale factor should normally be the same
710  result = triggerclass;
711  break;
712  }
713  }
714  return result;
715 }
716 
718  return branchname.Contains("Sim") || branchname.Contains("True");
719 }
720 
722  return branchname.Contains("Eta") || branchname.Contains("Phi");
723 }
724 
726  return branchname.Contains("Rho");
727 }
728 
730  return branchname.Contains("Mass"); // also disable rho mass branch
731 }
732 
734  return branchname.Contains("gMeasured") || branchname.Contains("gTrue") || branchname.Contains("NDropped");
735 }
736 
738  return branchname.Contains("Subjettiness");
739 }
740 
742  return branchname.Contains("Angularity") || branchname.Contains("PtD");
743 }
744 
746  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
747 
748  Bool_t isAOD(kFALSE);
749  AliInputEventHandler *inputhandler = static_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
750  if(inputhandler) {
751  if(inputhandler->IsA() == AliAODInputHandler::Class()){
752  std::cout << "Analysing AOD events\n";
753  isAOD = kTRUE;
754  } else {
755  std::cout << "Analysing ESD events\n";
756  }
757  }
758 
759  AliAnalysisTaskEmcalJetSubstructureTree *treemaker = new AliAnalysisTaskEmcalJetSubstructureTree("JetSubstructureTreemaker_" + TString::Format("R%02d_", int(jetradius * 10.)) + trigger);
760  mgr->AddTask(treemaker);
761  treemaker->SetMakeGeneralHistograms(kTRUE);
762 
763  // Adding containers
764  if(isMC) {
765  AliParticleContainer *particles = treemaker->AddMCParticleContainer("mcparticles");
766  particles->SetMinPt(0.);
767 
768  AliJetContainer *mcjets = treemaker->AddJetContainer(
769  jettype,
771  recombinationScheme,
772  jetradius,
774  particles, nullptr);
775  mcjets->SetName("mcjets");
776  mcjets->SetJetPtCut(20.);
777  }
778 
779  if(isData) {
780  AliTrackContainer *tracks(nullptr);
781  if((jettype == AliJetContainer::kChargedJet) || (jettype == AliJetContainer::kFullJet)){
783  std::cout << "Track container name: " << tracks->GetName() << std::endl;
784  tracks->SetMinPt(0.15);
785  }
786  AliClusterContainer *clusters(nullptr);
788  std::cout << "Using full or neutral jets ..." << std::endl;
790  std::cout << "Cluster container name: " << clusters->GetName() << std::endl;
791  clusters->SetClusHadCorrEnergyCut(0.3); // 300 MeV E-cut
792  clusters->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
793  } else {
794  std::cout << "Using charged jets ... " << std::endl;
795  }
796 
797  AliJetContainer *datajets = treemaker->AddJetContainer(
798  jettype,
800  recombinationScheme,
801  jetradius,
803  tracks, clusters);
804  datajets->SetName("datajets");
805  datajets->SetJetPtCut(20.);
806 
807  treemaker->SetUseAliAnaUtils(true, true);
808  treemaker->SetVzRange(-10., 10);
809 
810  // configure trigger selection
811  TString triggerstring(trigger);
812  if(triggerstring.Contains("INT7")) {
813  treemaker->SetTriggerBits(AliVEvent::kINT7);
814  } else if(triggerstring.Contains("EJ1")) {
815  treemaker->SetTriggerBits(AliVEvent::kEMCEJE);
816  treemaker->SetTriggerString("EJ1");
817  } else if(triggerstring.Contains("EJ2")) {
818  treemaker->SetTriggerBits(AliVEvent::kEMCEJE);
819  treemaker->SetTriggerString("EJ2");
820  }
821  }
822 
823  // Connecting containers
824  TString outputfile = mgr->GetCommonFileName();
825  outputfile += TString::Format(":JetSubstructure_R%02d_%s", int(jetradius * 10.), trigger);
826  mgr->ConnectInput(treemaker, 0, mgr->GetCommonInputContainer());
827  mgr->ConnectOutput(treemaker, 1, mgr->CreateContainer("JetSubstructureHistos_" + TString::Format("R%02d_", int(jetradius * 10.)) + trigger, AliEmcalList::Class(), AliAnalysisManager::kOutputContainer, outputfile));
828  mgr->ConnectOutput(treemaker, 2, mgr->CreateContainer("JetSubstructureTree_" + TString::Format("R%02d_", int(jetradius * 10.)) + trigger, TTree::Class(), AliAnalysisManager::kOutputContainer, mgr->GetCommonFileName()));
829 
830  return treemaker;
831 }
832 
833 std::string Triggerinfo::ExpandClassName() const {
834  std::string result = fTriggerClass + "-" + fBunchCrossing + "-" + fPastFutureProtection + "-" + fTriggerCluster;
835  return result;
836 }
837 
838 bool Triggerinfo::IsTriggerClass(const std::string &triggerclass) const {
839  return fTriggerClass.substr(1) == triggerclass; // remove C from trigger class part
840 }
841 
842 } /* namespace EmcalTriggerJets */
Double_t Area() const
Definition: AliEmcalJet.h:130
bool IsEventSelected(const char *name) const
Checks whether the events is selected for a given trigger type.
double Double_t
Definition: External.C:58
static AliAnalysisTaskEmcalJetSubstructureTree * AddEmcalJetSubstructureTreeMaker(Bool_t isMC, Bool_t isData, Double_t jetradius, AliJetContainer::EJetType_t jettype, AliJetContainer::ERecoScheme_t recombinationScheme, const char *name)
Class creating a linear binning, used in the histogram manager.
Double_t MakePtD(const AliEmcalJet &jet, const AliParticleContainer *const particles, const AliClusterContainer *const clusters) const
AliEmcalJet * ClosestJet() const
Definition: AliEmcalJet.h:327
AliJetContainer * GetJetContainer(Int_t i=0) const
virtual double E() const
Access to constituent energy.
Double_t Eta() const
Definition: AliEmcalJet.h:121
static AliEmcalDownscaleFactorsOCDB * Instance()
Double_t Py() const
Definition: AliEmcalJet.h:107
Double_t Phi() const
Definition: AliEmcalJet.h:117
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
void FillTH2(const char *hname, double x, double y, double weight=1., Option_t *opt="")
Fill a 2D histogram within the container.
Int_t ClusterAt(Int_t idx) const
Definition: AliEmcalJet.h:137
std::vector< Triggerinfo > DecodeTriggerString(const std::string &triggerstring) const
TCanvas * c
Definition: TestFitELoss.C:172
AliJetContainer * AddJetContainer(const char *n, TString defaultCutType, Float_t jetRadius=0.4)
const std::vector< PWG::JETFW::AliEmcalParticleJetConstituent > & GetParticleConstituents() const
Get container with particle (track / MC particle) constituents.
Definition: AliEmcalJet.h:184
Structure for results from the soft drop algorithm.
virtual void UserExecOnce()
Task initializations handled in user tasks.
Double_t E() const
Definition: AliEmcalJet.h:119
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.
Double_t GetDownscaleFactorForTriggerClass(const TString &trigger) const
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:140
Container for particles within the EMCAL framework.
Int_t GetDefaultClusterEnergy() const
Int_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:160
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:139
Double_t Px() const
Definition: AliEmcalJet.h:106
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
TPC fiducial acceptance (each eta edge narrowed by jet R)
Definition: AliEmcalJet.h:68
AliRhoParameter * GetRhoFromEvent(const char *name)
TH2 * CreateTH2(const char *name, const char *title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, Option_t *opt="")
Create a new TH2 within the container.
int Int_t
Definition: External.C:63
UShort_t GetNumberOfClusters() const
Definition: AliEmcalJet.h:138
void SetJetPtCut(Float_t cut)
TPC acceptance.
Definition: AliEmcalJet.h:67
unsigned int UInt_t
Definition: External.C:33
THashList * GetListOfHistograms() const
Get the list of histograms.
Definition: THistManager.h:671
Int_t GetNJets() const
AliNSubjettinessParameters MakeNsubjettinessParameters(const fastjet::PseudoJet &jet, const AliNSubjettinessDefinition &cut) const
TH1 * CreateTH1(const char *name, const char *title, int nbins, double xmin, double xmax, Option_t *opt="")
Create a new TH1 within the container.
Definition for the algorithm obtaining the softdrop parameters.
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Get cluster container attached to this task.
virtual void RunChanged(Int_t newrun)
Process tasks relevant when a file with a different run number is processed.
AliMCParticleContainer * AddMCParticleContainer(const char *n)
Create new container for MC particles and attach it to the task.
void FillTH1(const char *hname, double x, double weight=1., Option_t *opt="")
Fill a 1D histogram within the container.
Double_t MakeAngularity(const AliEmcalJet &jet, const AliParticleContainer *tracks, const AliClusterContainer *clusters) const
Implementation of a jet constituent for constituent clusters.
bool IsTriggerClass(const std::string &triggerclass) const
Double_t Pt() const
Definition: AliEmcalJet.h:109
Bool_t isMC
void DoConstituentQA(const AliEmcalJet *jet, const AliParticleContainer *tracks, const AliClusterContainer *clusters)
Float_t GetJetRadius() const
const std::vector< PWG::JETFW::AliEmcalClusterJetConstituent > & GetClusterConstituents() const
Get container with cluster constituents.
Definition: AliEmcalJet.h:190
virtual double Pt() const
Access to transverse momentum.
AliEmcalList * fOutput
!output list
void LinkOutputBranch(const TString &branchname, Double_t *datalocation)
Double_t fVertex[3]
!event vertex
AliTrackContainer * AddTrackContainer(const char *n)
Create new track container and attach it to the task.
Handler for downscale factors for various triggers obtained from the OCDB.
AliTrackContainer * GetTrackContainer(Int_t i=0) const
void SetMakeGeneralHistograms(Bool_t g)
Base task in the EMCAL jet framework.
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, Double_t *rhoparameters)
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:51
Container class for histograms.
Definition: THistManager.h:99
Double_t Pz() const
Definition: AliEmcalJet.h:108
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:148
void SetDefaultClusterEnergy(Int_t d)
Container structure for EMCAL clusters.
Double_t M() const
Definition: AliEmcalJet.h:120
EMCal fiducial acceptance (each eta, phi edge narrowed by jet R)
Definition: AliEmcalJet.h:70
Container for jet within the EMCAL jet framework.
TList * OpenFile(const char *fname)
Definition: DrawAnaELoss.C:65
void SetClusHadCorrEnergyCut(Double_t cut)
static TString TrackContainerNameFactory(Bool_t isAOD)
Get name of the default track container.
static TString ClusterContainerNameFactory(Bool_t isAOD)
Get name of the default cluster container.