AliPhysics  master (68a99cd)
AliAnalysisTaskEmcalJetEnergySpectrum.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 <algorithm>
28 #include <array>
29 #include <sstream>
30 #include <string>
31 #include <vector>
32 
33 #include <THistManager.h>
34 #include <TLinearBinning.h>
35 #include <TVariableBinning.h>
36 
37 #include "AliAODInputHandler.h"
38 #include "AliAnalysisManager.h"
42 #include "AliEmcalJet.h"
45 #include "AliEventCuts.h"
46 #include "AliInputEventHandler.h"
47 #include "AliJetContainer.h"
48 #include "AliLog.h"
49 #include "AliMultSelection.h"
50 #include "AliVEvent.h"
51 
53 
54 using namespace EmcalTriggerJets;
55 
58  fHistos(nullptr),
59  fEventCuts(nullptr),
60  fIsMC(false),
61  fTriggerSelectionBits(AliVEvent::kAny),
62  fTriggerSelectionString(""),
63  fRequireSubsetMB(false),
64  fMinBiasTrigger(AliVEvent::kAny),
65  fNameTriggerDecisionContainer("EmcalTriggerDecision"),
66  fUseTriggerSelectionForData(false),
67  fUseDownscaleWeight(false),
68  fNameJetContainer("datajets"),
69  fRequestTriggerClusters(true),
70  fRequestCentrality(false),
71  fUseAliEventCuts(false),
72  fUseSumw2(false),
73  fCentralityEstimator("V0M"),
74  fUserPtBinning()
75 {
76  SetUseAliAnaUtils(true);
77 }
78 
80  AliAnalysisTaskEmcalJet(name, true),
83  fIsMC(false),
84  fTriggerSelectionBits(AliVEvent::kAny),
86  fRequireSubsetMB(false),
87  fMinBiasTrigger(AliVEvent::kAny),
88  fNameTriggerDecisionContainer("EmcalTriggerDecision"),
90  fUseDownscaleWeight(false),
91  fNameJetContainer("datajets"),
93  fRequestCentrality(false),
94  fUseAliEventCuts(false),
95  fUseSumw2(false),
96  fCentralityEstimator("V0M"),
98 {
99  SetUseAliAnaUtils(true);
100 }
101 
103  if(fHistos) delete fHistos;
104 }
105 
108 
109  if(!fUserPtBinning.GetSize()) {
110  // binning not set. apply default binning
111  AliInfoStream() << "Using default pt binning";
112  fUserPtBinning.Set(301);
113  double current(0.);
114  for(int istep = 0; istep < 301; istep++) {
115  fUserPtBinning[istep] = current;
116  current += 1;
117  }
118  }
119 
120  TLinearBinning centralitybinning(100, 0., 100.), etabinning(100, -1., 1.), phibinning(100., 0., 7.), nefbinning(100, 0., 1.), trgclusterbinning(kTrgClusterN + 1, -0.5, kTrgClusterN -0.5);
121  TVariableBinning jetptbinning(fUserPtBinning);
122  const TBinning *binnings[6] = {&centralitybinning, &jetptbinning, &etabinning, &phibinning, &nefbinning, &trgclusterbinning};
123  fHistos = new THistManager(Form("Histos_%s", GetName()));
124  fHistos->CreateTH1("hEventCounter", "Event counter histogram", 1, 0.5, 1.5);
125  fHistos->CreateTH1("hEventCounterAbs", "Event counter histogram absolute", 1, 0.5, 1.5);
126  fHistos->CreateTH1("hEventCentrality", "Event centrality", 100., 0., 100.);
127  fHistos->CreateTH1("hEventCentralityAbs", "Event centrality absolute", 100., 0., 100.);
128  fHistos->CreateTH1("hClusterCounter", "Event counter histogram", kTrgClusterN, -0.5, kTrgClusterN - 0.5);
129  fHistos->CreateTH1("hClusterCounterAbs", "Event counter histogram absolute", kTrgClusterN, -0.5, kTrgClusterN - 0.5);
130  fHistos->CreateTHnSparse("hJetTHnSparse", "jet thnsparse", 6, binnings, fUseSumw2 ? "s" : "");
131  fHistos->CreateTHnSparse("hMaxJetTHnSparse", "jet thnsparse", 6, binnings, fUseSumw2 ? "s" : "");
132 
133  for(auto h : *fHistos->GetListOfHistograms()) fOutput->Add(h);
134 
135  if(fUseAliEventCuts) {
136  fEventCuts = new AliEventCuts(true);
137  // Do not perform trigger selection in the AliEvent cuts but let the task do this before
138  fEventCuts->OverrideAutomaticTriggerSelection(AliVEvent::kAny, true);
139  fOutput->Add(fEventCuts);
140  }
141  PostData(1, fOutput);
142 }
143 
145  if(fEventCuts) {
146  if(!IsTriggerSelected()) return false;
147  if(!fEventCuts->AcceptEvent(fInputEvent)) return false;
148  return true;
149  }
151 }
152 
154  if(!fMCRejectFilter) return true;
155  if(!(fIsPythia || fIsHerwig)) return true; // Only relevant for pt-hard production
156  AliDebugStream(1) << "Using custom MC outlier rejection" << std::endl;
157  auto partjets = GetJetContainer("partjets");
158  if(!partjets) return true;
159 
160  // Check whether there is at least one particle level jet with pt above n * event pt-hard
161  auto jetiter = partjets->accepted();
162  auto max = std::max_element(jetiter.begin(), jetiter.end(), [](const AliEmcalJet *lhs, const AliEmcalJet *rhs ) { return lhs->Pt() < rhs->Pt(); });
163  if(max != jetiter.end()) {
164  // At least one jet found with pt > n * pt-hard
165  AliDebugStream(1) << "Found max jet with pt " << (*max)->Pt() << " GeV/c" << std::endl;
166  if((*max)->Pt() > fPtHardAndJetPtFactor * fPtHard) return false;
167  }
168  return true;
169 }
170 
172  auto datajets = this->GetJetContainer(fNameJetContainer);
173  if(!datajets) {
174  AliErrorStream() << "Jet container " << fNameJetContainer << " not found" << std::endl;
175  return false;
176  }
177 
178  double eventCentrality = 99; // without centrality put everything in the peripheral bin
179  if(fRequestCentrality){
180  AliMultSelection *mult = dynamic_cast<AliMultSelection *>(InputEvent()->FindListObject("MultSelection"));
181  if(!mult){
182  AliErrorStream() << GetName() << ": Centrality selection enabled but no centrality estimator found" << std::endl;
183  return false;
184  }
185  if(mult->IsEventSelected()) return false;
186  eventCentrality = mult->GetEstimator(fCentralityEstimator)->GetPercentile();
187  AliDebugStream(1) << GetName() << ": Centrality " << eventCentrality << std::endl;
188  } else {
189  AliDebugStream(1) << GetName() << ": No centrality selection applied" << std::endl;
190  }
191 
192  auto trgclusters = GetTriggerClusterIndices(fInputEvent->GetFiredTriggerClasses());
193  Double_t weight = 1.;
194  if(fUseDownscaleWeight) {
195  weight = 1./PWG::EMCAL::AliEmcalDownscaleFactorsOCDB::Instance()->GetDownscaleFactorForTriggerClass(MatchTrigger(fInputEvent->GetFiredTriggerClasses().Data()));
196  }
197  fHistos->FillTH1("hEventCounterAbs", 1.);
198  fHistos->FillTH1("hEventCounter", weight);
199  fHistos->FillTH1("hEventCentralityAbs", eventCentrality);
200  fHistos->FillTH1("hEventCentrality", eventCentrality, weight);
201  AliEmcalJet *maxjet(nullptr);
202  for(auto t : trgclusters) {
203  fHistos->FillTH1("hClusterCounterAbs", t);
204  fHistos->FillTH1("hClusterCounter", t, weight);
205  }
206  for(auto j : datajets->accepted()){
207  if(!maxjet || (j->E() > maxjet->E())) maxjet = j;
208  double datapoint[6] = {eventCentrality, j->Pt(), j->Eta(), j->Phi(), j->NEF(), 0.};
209  for(auto t : trgclusters){
210  datapoint[5] = static_cast<double>(t);
211  fHistos->FillTHnSparse("hJetTHnSparse", datapoint, weight);
212  }
213  }
214 
215  double maxdata[6];
216  memset(maxdata, 0., sizeof(double) * 5);
217  maxdata[0] = eventCentrality;
218  if(maxjet){
219  maxdata[1] = maxjet->Pt();
220  maxdata[2] = maxjet->Eta();
221  maxdata[3] = maxjet->Phi();
222  maxdata[4] = maxjet->NEF();
223  }
224  for(auto t : trgclusters){
225  maxdata[5] = static_cast<double>(t);
226  fHistos->FillTHnSparse("hMaxJetTHnSparse", maxdata, weight);
227  }
228  return true;
229 }
230 
232  if(fUseDownscaleWeight) {
233  auto downscalehandler = PWG::EMCAL::AliEmcalDownscaleFactorsOCDB::Instance();
234  if(downscalehandler->GetCurrentRun() != newrun){
235  downscalehandler->SetRun(newrun);
236  }
237  }
238 }
239 
240 std::vector<AliAnalysisTaskEmcalJetEnergySpectrum::TriggerCluster_t> AliAnalysisTaskEmcalJetEnergySpectrum::GetTriggerClusterIndices(const TString &triggerstring) const {
241  // decode trigger string in order to determine the trigger clusters
242  std::vector<TriggerCluster_t> result;
243  result.emplace_back(kTrgClusterANY); // cluster ANY always included
245  // Data - separate trigger clusters
246  std::vector<std::string> clusternames;
247  auto triggerinfos = PWG::EMCAL::Triggerinfo::DecodeTriggerString(triggerstring.Data());
248  for(auto t : triggerinfos) {
249  if(std::find(clusternames.begin(), clusternames.end(), t.Triggercluster()) == clusternames.end()) clusternames.emplace_back(t.Triggercluster());
250  }
251  bool isCENT = (std::find(clusternames.begin(), clusternames.end(), "CENT") != clusternames.end()),
252  isCENTNOTRD = (std::find(clusternames.begin(), clusternames.end(), "CENTNOTRD") != clusternames.end()),
253  isCALO = (std::find(clusternames.begin(), clusternames.end(), "CALO") != clusternames.end()),
254  isCALOFAST = (std::find(clusternames.begin(), clusternames.end(), "CALOFAST") != clusternames.end());
255  if(isCENT || isCENTNOTRD) {
256  if(isCENT) {
257  result.emplace_back(kTrgClusterCENT);
258  if(isCENTNOTRD) {
259  result.emplace_back(kTrgClusterCENTNOTRD);
260  result.emplace_back(kTrgClusterCENTBOTH);
261  } else result.emplace_back(kTrgClusterOnlyCENT);
262  } else {
263  result.emplace_back(kTrgClusterCENTNOTRD);
264  result.emplace_back(kTrgClusterOnlyCENTNOTRD);
265  }
266  }
267  if(isCALO || isCALOFAST) {
268  if(isCALO) {
269  result.emplace_back(kTrgClusterCALO);
270  if(isCALOFAST) {
271  result.emplace_back(kTrgClusterCALOFAST);
272  result.emplace_back(kTrgClusterCALOBOTH);
273  } else result.emplace_back(kTrgClusterOnlyCALO);
274  } else {
275  result.emplace_back(kTrgClusterCALOFAST);
276  result.emplace_back(kTrgClusterOnlyCALOFAST);
277  }
278  }
279  }
280  return result;
281 }
282 
284  if(!fIsMC){
285  // Pure data - do EMCAL trigger selection from selection string
286  if(!(fInputHandler->IsEventSelected() & fTriggerSelectionBits)) return false;
287  if(fTriggerSelectionString.Length()) {
288  if(!fInputEvent->GetFiredTriggerClasses().Contains(fTriggerSelectionString)) return false;
289  if(fRequireSubsetMB && !(fInputHandler->IsEventSelected() & fMinBiasTrigger)) return false; // Require EMCAL trigger to be subset of the min. bias trigger (for efficiency studies)
290  if((fTriggerSelectionString.Contains("EJ") || fTriggerSelectionString.Contains("EG") || fTriggerSelectionString.Contains("DJ") || fTriggerSelectionString.Contains("DG")) && fUseTriggerSelectionForData) {
291  auto trgselresult = static_cast<PWG::EMCAL::AliEmcalTriggerDecisionContainer *>(fInputEvent->FindListObject(fNameTriggerDecisionContainer));
292  AliDebugStream(1) << "Found trigger decision object: " << (trgselresult ? "yes" : "no") << std::endl;
293  if(!trgselresult){
294  AliErrorStream() << "Trigger decision container with name " << fNameTriggerDecisionContainer << " not found in event - not possible to select EMCAL triggers" << std::endl;
295  return false;
296  }
297  if(!trgselresult->IsEventSelected(fTriggerSelectionString)) return false;
298  }
299  }
300  } else {
301  if(!(fInputHandler->IsEventSelected() & AliVEvent::kINT7)) return false;
303  // Simulation - do EMCAL trigger selection from trigger selection object
304  auto mctrigger = static_cast<PWG::EMCAL::AliEmcalTriggerDecisionContainer *>(fInputEvent->FindListObject(fNameTriggerDecisionContainer));
305  AliDebugStream(1) << "Found trigger decision object: " << (mctrigger ? "yes" : "no") << std::endl;
306  if(!mctrigger){
307  AliErrorStream() << "Trigger decision container with name " << fNameTriggerDecisionContainer << " not found in event - not possible to select EMCAL triggers" << std::endl;
308  return false;
309  }
310  if(!mctrigger->IsEventSelected(fTriggerSelectionString)) return false;
311  }
312  }
313  return true;
314 }
315 
316 std::string AliAnalysisTaskEmcalJetEnergySpectrum::MatchTrigger(const std::string &triggerstring){
317  auto triggerclasses = PWG::EMCAL::Triggerinfo::DecodeTriggerString(triggerstring);
318  std::string result;
319  for(const auto &t : triggerclasses) {
320  // Use CENT cluster for downscaling
321  if(t.Triggercluster() != "CENT") continue;
322  if(t.Triggerclass().find(fTriggerSelectionString.Data()) == std::string::npos) continue;
323  result = t.ExpandClassName();
324  break;
325  }
326  return result;
327 }
328 
329 bool AliAnalysisTaskEmcalJetEnergySpectrum::IsSelectEmcalTriggers(const std::string &triggerstring) const {
330  const std::array<std::string, 8> kEMCALTriggers = {
331  "EJ1", "EJ2", "DJ1", "DJ2", "EG1", "EG2", "DG1", "DG2"
332  };
333  bool isEMCAL = false;
334  for(auto emcaltrg : kEMCALTriggers) {
335  if(triggerstring.find(emcaltrg) != std::string::npos) {
336  isEMCAL = true;
337  break;
338  }
339  }
340  return isEMCAL;
341 }
342 
343 
345  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
346  if(!mgr) {
347  std::cerr << "Analysis manager not initialized" << std::endl;
348  return nullptr;
349  }
350 
351  Bool_t isAOD(kFALSE);
352  AliInputEventHandler *inputhandler = static_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
353  if(inputhandler) {
354  if(inputhandler->IsA() == AliAODInputHandler::Class()){
355  std::cout << "Analysing AOD events\n";
356  isAOD = kTRUE;
357  } else {
358  std::cout << "Analysing ESD events\n";
359  }
360  }
361 
362  std::string jettypestring;
364  switch(jettype){
365  case AliJetContainer::kChargedJet: jettypestring = "ChargedJets"; acctype = AliJetContainer::kTPCfid; break;
366  case AliJetContainer::kFullJet: jettypestring = "FullJets"; acctype = AliJetContainer::kEMCALfid; break;
367  case AliJetContainer::kNeutralJet: jettypestring = "NeutralJets"; acctype = AliJetContainer::kEMCALfid; break;
369  };
370 
371  std::stringstream tag, outfilename;
372  tag << jettypestring << "_R" << std::setw(2) << std::setfill('0') << int(radius * 10.) << "_" << trigger;
373  if(strlen(suffix)) {
374  tag << "_" << suffix;
375  }
376  auto task = new AliAnalysisTaskEmcalJetEnergySpectrum(Form("JetEnergySpectrum_%s", tag.str().data()));
377  task->SetIsMC(isMC);
378  mgr->AddTask(task);
379 
380  auto contains = [](const std::string &str, const std::string &test) {
381  return str.find(test) != std::string::npos;
382  };
383 
384  std::string trgstr(trigger);
385  if(contains(trgstr, "INT7")) task->SetTriggerSelection(AliVEvent::kINT7, "INT7");
386  else if(contains(trgstr, "EJ1")) task->SetTriggerSelection(AliVEvent::kEMCEJE, "EJ1");
387  else if(contains(trgstr, "EJ2")) task->SetTriggerSelection(AliVEvent::kEMCEJE, "EJ2");
388  else if(contains(trgstr, "EG1")) task->SetTriggerSelection(AliVEvent::kEMCEGA, "EG1");
389  else if(contains(trgstr, "EG2")) task->SetTriggerSelection(AliVEvent::kEMCEGA, "EG2");
390 
391  // Connect particle and cluster container
392  AliTrackContainer *tracks(nullptr);
393  AliClusterContainer *clusters(nullptr);
394  if(jettype == AliJetContainer::kChargedJet || jettype == AliJetContainer::kFullJet) {
396  tracks->SetMinPt(0.15);
397  }
398  if(jettype == AliJetContainer::kNeutralJet || jettype == AliJetContainer::kFullJet){
399  clusters = task->AddClusterContainer(EMCalTriggerPtAnalysis::AliEmcalAnalysisFactory::ClusterContainerNameFactory(isAOD));
400  clusters->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
401  clusters->SetClusHadCorrEnergyCut(0.3);
402  }
403 
404 
405  // Create proper jet container
406  auto jetcont = task->AddJetContainer(jettype, AliJetContainer::antikt_algorithm, recoscheme, radius, acctype, tracks, clusters);
407  jetcont->SetName("datajets");
408  task->SetNameJetContainer("datajets");
409  std::cout << "Adding jet container with underlying array:" << jetcont->GetArrayName() << std::endl;
410 
411  if(isMC){
412  // Create also particle and particle level jet container for outlier rejection
413  TString partcontname = namepartcont;
414  if(partcontname == "usedefault") partcontname = "mcparticles";
415  auto partcont = task->AddMCParticleContainer(partcontname.Data());
416  partcont->SetMinPt(0.);
417 
418  auto pjcont = task->AddJetContainer(jettype, AliJetContainer::antikt_algorithm, recoscheme, radius, AliJetContainer::kTPCfid, partcont, nullptr);
419  pjcont->SetName("partjets");
420  pjcont->SetMinPt(0);
421  pjcont->SetMaxTrackPt(1000.);
422  }
423 
424  // Link input and output container
425  outfilename << mgr->GetCommonFileName() << ":JetSpectrum_" << tag.str().data();
426  mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
427  mgr->ConnectOutput(task, 1, mgr->CreateContainer(Form("JetSpectrum_%s", tag.str().data()), TList::Class(), AliAnalysisManager::kOutputContainer, outfilename.str().data()));
428 
429  return task;
430 }
EMCal fiducial acceptance (each eta, phi edge narrowed by jet R)
Bool_t fIsPythia
trigger, if it is a PYTHIA production
double Double_t
Definition: External.C:58
AliEventCuts * fEventCuts
Event cuts as implemented in AliEventCuts.
Class creating a variable binning, used in the histogram manager.
Class creating a linear binning, used in the histogram manager.
AliJetContainer * GetJetContainer(Int_t i=0) const
Double_t Eta() const
Definition: AliEmcalJet.h:121
Bool_t fUseSumw2
Switch for sumw2 option in THnSparse (should not be used when a downscale weight is applied) ...
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)
Bool_t fRequireSubsetMB
Require for triggers to be a subset of Min. Bias (for efficiency studies)
static AliEmcalDownscaleFactorsOCDB * Instance()
void SetMinPt(Double_t min)
std::vector< TriggerCluster_t > GetTriggerClusterIndices(const TString &triggerstring) const
virtual Bool_t CheckMCOutliers()
Filter the mc tails in pt-hard distributions.
Double_t GetDownscaleFactorForTriggerClass(const TString &trigger) const
Double_t E() const
Definition: AliEmcalJet.h:119
Interface for binnings used by the histogram handler.
Definition: TBinning.h:23
static std::vector< PWG::EMCAL::Triggerinfo > DecodeTriggerString(const std::string &triggerstring)
Decoding trigger string.
void FillTHnSparse(const char *name, const double *x, double weight=1., Option_t *opt="")
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.
int Int_t
Definition: External.C:63
unsigned int UInt_t
Definition: External.C:33
THashList * GetListOfHistograms() const
Get the list of histograms.
Definition: THistManager.h:671
ULong_t fMinBiasTrigger
Min bias trigger for trigger subset (for efficiency studies)
Bool_t fIsHerwig
trigger, if it is a HERWIG production
TH1 * CreateTH1(const char *name, const char *title, int nbins, double xmin, double xmax, Option_t *opt="")
Create a new TH1 within the container.
Float_t fPtHardAndJetPtFactor
Factor between ptHard and jet pT to reject/accept event.
static AliAnalysisTaskEmcalJetEnergySpectrum * AddTaskJetEnergySpectrum(Bool_t isMC, AliJetContainer::EJetType_t jettype, AliJetContainer::ERecoScheme_t recoscheme, double radius, const char *namepartcont, const char *trigger, const char *suffix="")
Bool_t fMCRejectFilter
enable the filtering of events by tail rejection
TPC fiducial acceptance (each eta edge narrowed by jet R)
void FillTH1(const char *hname, double x, double weight=1., Option_t *opt="")
Fill a 1D histogram within the container.
Bool_t fRequestTriggerClusters
Request distinction of trigger clusters.
Double_t Pt() const
Definition: AliEmcalJet.h:109
virtual void RunChanged(Int_t newrun)
Process tasks relevant when a file with a different run number is processed.
virtual Bool_t IsEventSelected()
Performing event selection.
Bool_t fUseTriggerSelectionForData
Use trigger selection on data (require trigger patch in addition to trigger selection string) ...
Bool_t isMC
Float_t fPtHard
!event -hard
AliEmcalList * fOutput
!output list
Base task in the EMCAL jet framework.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:51
Container class for histograms.
Definition: THistManager.h:99
void test(int runnumber=195345)
void UserCreateOutputObjects()
Main initialization function on the worker.
bool Bool_t
Definition: External.C:53
Double_t NEF() const
Definition: AliEmcalJet.h:148
void SetDefaultClusterEnergy(Int_t d)
THnSparse * CreateTHnSparse(const char *name, const char *title, int ndim, const int *nbins, const double *min, const double *max, Option_t *opt="")
Create a new THnSparse within the container.
Container structure for EMCAL clusters.
void SetClusHadCorrEnergyCut(Double_t cut)
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.