AliPhysics  master (3d17d9d)
AliAnalysisTaskEmcalJetConstituentQA.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 <cmath>
30 #include <iomanip>
31 #include <iostream>
32 #include <sstream>
33 #include <string>
34 #include <THistManager.h>
35 #include <TLinearBinning.h>
36 #include <TLorentzVector.h>
37 #include <TVector3.h>
38 
39 #include "AliAnalysisManager.h"
41 #include "AliAODInputHandler.h"
42 #include "AliClusterContainer.h"
45 #include "AliEmcalJet.h"
46 #include "AliInputEventHandler.h"
47 #include "AliJetContainer.h"
48 #include "AliLog.h"
49 #include "AliTrackContainer.h"
50 #include "AliVCluster.h"
51 #include "AliVEvent.h"
52 #include "AliVTrack.h"
53 
57 
58 using namespace PWGJE::EMCALJetTasks;
59 
62  fHistos(nullptr),
63  fJetType(AliJetContainer::kFullJet),
64  fNameTrackContainer(""),
65  fNameClusterContainer(""),
66  fTriggerSelectionString(""),
67  fUseTriggerSelection(kFALSE),
68  fNameTriggerDecisionContainer("EmcalTriggerDecision"),
69  fDoHighZClusters(kTRUE),
70  fDoCharged(kTRUE),
71  fDoNeutral(kTRUE),
72  fDoLeadingCharged(kTRUE),
73  fDoLeadingNeutral(kTRUE),
74  fDoLeadingCell(kTRUE)
75 {
76 }
77 
79  AliAnalysisTaskEmcalJet(name, true),
81  fJetType(AliJetContainer::kFullJet),
85  fUseTriggerSelection(kFALSE),
86  fNameTriggerDecisionContainer("EmcalTriggerDecision"),
87  fDoHighZClusters(kTRUE),
88  fDoCharged(kTRUE),
89  fDoNeutral(kTRUE),
90  fDoLeadingCharged(kTRUE),
91  fDoLeadingNeutral(kTRUE),
92  fDoLeadingCell(kTRUE)
93 {
94  this->SetMakeGeneralHistograms(true);
95 }
96 
98  if(fHistos) delete fHistos;
99 }
100 
103 
104  TLinearBinning binningz(50, 0., 1), multbinning(51, -0.5, 50.5), binningnef(50, 0., 1.), binningR(60, 0., 0.6), binningptconst(300, 0., 300.), binningptjet(30, 0., 300.),
105  binningNCell(101, -0.5, 100.5), binningFracCellLeading(100, 0., 1.), binningM02(100, 0., 1.), etabinning(100, -0.8, 0.8), phibinning(100, 0., TMath::TwoPi());
106 
107  const TBinning *jetbinning[4] = {&binningptjet, &binningnef, &multbinning, &multbinning},
108  *chargedbinning[7] = {&binningptjet, &binningnef, &multbinning, &multbinning, &binningptconst, &binningz, &binningR},
109  *neutralbinning[9] = {&binningptjet, &binningnef, &multbinning, &multbinning, &binningptconst, &binningptconst, &binningz, &binningR, &binningptconst},
110  *binningHighZClusters[7] = {&binningptjet, &binningnef, &binningptconst, &binningz, &binningNCell, &binningFracCellLeading, &binningM02},
111  *leadingchargedbinning[5] = {&binningptjet, &binningnef, &binningptconst, &binningz, &binningR},
112  *leadingneutralbinning[7] = {&binningptjet, &binningnef, &binningptconst, &binningz, &binningR, &binningptconst, &binningFracCellLeading},
113  *leadingcellbinning[5] = {&binningptjet, &binningnef, &binningptconst, &binningptconst, &binningFracCellLeading},
114  *leadingjetvecbinning[4] = {&binningptjet, &etabinning, &phibinning, &binningptjet};
115 
116  fHistos = new THistManager(Form("histos_%s", GetName()));
117  for(auto c : fNamesJetContainers){
118  auto contname = dynamic_cast<TObjString *>(c);
119  if(!contname) continue;
120  fHistos->CreateTHnSparse(Form("hJetCounter%s", contname->String().Data()), Form("jet counter for jets %s", contname->String().Data()), 4, jetbinning);
121  fHistos->CreateTHnSparse(Form("hPtEtaPhiELeadingJet%s", contname->String().Data()), Form("Momemtum vector of leading jets %s", contname->String().Data()), 4, leadingjetvecbinning);
123  fHistos->CreateTHnSparse(Form("hChargedConstituents%s", contname->String().Data()), Form("charged constituents in jets %s", contname->String().Data()), 7, chargedbinning);
124  if(fDoLeadingCharged){
125  fHistos->CreateTHnSparse(Form("hLeadingTrack%s", contname->String().Data()), Form("leading charged constituent in jets %s", contname->String().Data()), 5, leadingchargedbinning);
126  fHistos->CreateTHnSparse(Form("hLeadingJetLeadingTrack%s", contname->String().Data()), Form("leading charged constituent in jets %s", contname->String().Data()), 5, leadingchargedbinning);
127  }
128  }
130  fHistos->CreateTHnSparse(Form("hNeutralConstituents%s", contname->String().Data()), Form("neutral constituents in jets %s", contname->String().Data()), 9, neutralbinning);
131  if(fDoHighZClusters) fHistos->CreateTHnSparse(Form("hHighZClusters%s", contname->String().Data()), "Properties of high-z clusters", 7, binningHighZClusters);
132  if(fDoLeadingCell) fHistos->CreateTHnSparse(Form("hLeadingCell%s", contname->String().Data()), Form("Leading cell in jets %s", contname->String().Data()), 5, leadingcellbinning);
133  if(fDoLeadingNeutral){
134  fHistos->CreateTHnSparse(Form("hLeadingCluster%s", contname->String().Data()), Form("leading neutral constituent in jets %s", contname->String().Data()), 7, leadingneutralbinning);
135  fHistos->CreateTHnSparse(Form("hLeadingJetLeadingCluster%s", contname->String().Data()), Form("leading neutral constituent in jets %s", contname->String().Data()), 7, leadingneutralbinning);
136  }
137  }
138  }
139 
140  for(auto h : *(fHistos->GetListOfHistograms())) fOutput->Add(h);
141  PostData(1, fOutput);
142 }
143 
146  if(!tracks) tracks = GetParticleContainer(fNameTrackContainer);
147  const auto clusters = GetClusterContainer(fNameClusterContainer);
148  if(fNameTrackContainer.Length() && !tracks){
149  AliErrorStream() << "Track container " << fNameTrackContainer << " required but missing ..." << std::endl;
150  return kFALSE;
151  }
152  if(fNameClusterContainer.Length() && !clusters){
153  AliErrorStream() << "Cluster container " << fNameClusterContainer << " required but missing ..." << std::endl;
154  return kFALSE;
155  }
156 
157  for(auto jc : fNamesJetContainers){
158  auto contname = dynamic_cast<TObjString *>(jc);
159  if(!contname) {
160  AliErrorStream() << "Non-string object in the list of jet container names" << std::endl;
161  continue;
162  }
163  const auto jetcont = GetJetContainer(contname->String().Data());
164  if(!jetcont){
165  AliErrorStream() << "Jet container with name " << contname->String() << " not found in the list of jet containers" << std::endl;
166  continue;
167  }
168  AliDebugStream(2) << "Reading " << jetcont->GetArray()->GetName() << std::endl;
169 
170  AliEmcalJet *leadingjet(nullptr);
171  for(auto jet : jetcont->accepted()){
172  if(!leadingjet || jet->Pt() > leadingjet->Pt()) leadingjet = jet;
173  AliDebugStream(3) << "Next accepted jet, found " << jet->GetNumberOfTracks() << " tracks and " << jet->GetNumberOfClusters() << " clusters." << std::endl;
174  Double_t pointjet[4] = {std::abs(jet->Pt()), jet->NEF(), static_cast<double>(jet->GetNumberOfTracks()), static_cast<double>(jet->GetNumberOfClusters())},
175  pointcharged[7] = {std::abs(jet->Pt()), jet->NEF(), static_cast<double>(jet->GetNumberOfTracks()), static_cast<double>(jet->GetNumberOfClusters()), -1., 1., -1.},
176  pointneutral[9] = {std::abs(jet->Pt()), jet->NEF(), static_cast<double>(jet->GetNumberOfTracks()), static_cast<double>(jet->GetNumberOfClusters()), -1., 1., -1., -1.},
177  pointHighZCluster[7] = {std::abs(jet->Pt()), jet->NEF(), -1., -1., -1., -1., -1.};
178  fHistos->FillTHnSparse(Form("hJetCounter%s", contname->String().Data()), pointjet);
179  TVector3 jetvec{jet->Px(), jet->Py(), jet->Pz()};
181  for(decltype(jet->GetNumberOfTracks()) itrk = 0; itrk < jet->GetNumberOfTracks(); itrk++){
182  const auto trk = jet->TrackAt(itrk, tracks->GetArray());
183  if(!trk) continue;
184  if(trk->Charge()){
185  pointcharged[4] = std::abs(trk->Pt());
186  pointcharged[5] = std::abs(jet->GetZ(trk));
187  pointcharged[6] = jet->DeltaR(trk);
188  fHistos->FillTHnSparse(Form("hChargedConstituents%s", contname->String().Data()), pointcharged);
189  } else {
190  // particle level jets
191  pointneutral[4] = pointneutral[5] = std::abs(trk->E());
192  pointneutral[6] = std::abs(jet->GetZ(trk));
193  pointneutral[7] = jet->DeltaR(trk);
194  fHistos->FillTHnSparse(Form("hNeutralConstituents%s", contname->String().Data()), pointneutral);
195  }
196  }
197  if(fDoLeadingCharged){
198  // Leading track
199  auto leadingtrack = jet->GetLeadingTrack(tracks->GetArray());
200  if(leadingtrack) {
201  double ltrackpoint[5] = {std::abs(jet->Pt()), jet->NEF(), std::abs(leadingtrack->Pt()), jet->GetZ(leadingtrack), jet->DeltaR(leadingtrack)};
202  fHistos->FillTHnSparse(Form("hLeadingTrack%s", contname->String().Data()), ltrackpoint);
203  }
204  }
205  }
207  for(decltype(jet->GetNumberOfClusters()) icl = 0; icl < jet->GetNumberOfClusters(); icl++){
208  const auto clust = jet->ClusterAt(icl, clusters->GetArray());
209  std::vector<double> fracamp(clust->GetNCells());
210  memcpy(fracamp.data(), clust->GetCellsAmplitudeFraction(), sizeof(double) * clust->GetNCells());
211  if(!clust) continue;
212  TLorentzVector ptvec;
213  double maxEcell = 0.;
214  for(auto icell = 0; icell < clust->GetNCells(); icell++) {
215  auto ecell = fInputEvent->GetEMCALCells()->GetCellAmplitude(clust->GetCellAbsId(icell));
216  if(ecell > maxEcell) maxEcell = ecell;
217  }
218  double fracmax = maxEcell / clust->E();
219  clust->GetMomentum(ptvec, this->fVertex, AliVCluster::kHadCorr);
220  pointneutral[4] = std::abs(clust->GetHadCorrEnergy());
221  pointneutral[5] = std::abs(clust->GetNonLinCorrEnergy());
222  pointneutral[6] = jet->GetZ(ptvec.Px(), ptvec.Py(), ptvec.Pz());
223  pointneutral[7] = jetvec.DeltaR(ptvec.Vect());
224  pointneutral[8] = maxEcell;
225  fHistos->FillTHnSparse(Form("hNeutralConstituents%s", contname->String().Data()), pointneutral);
226  if(fDoHighZClusters && (pointneutral[6] > 0.95)) {
227  pointHighZCluster[2] = pointneutral[4];
228  pointHighZCluster[3] = pointneutral[6];
229  pointHighZCluster[4] = clust->GetNCells();
230  pointHighZCluster[5] = fracmax;
231  pointHighZCluster[6] = clust->GetM02();
232  fHistos->FillTHnSparse(Form("hHighZClusters%s", contname->String().Data()), pointHighZCluster);
233  }
234  }
235  // Leading cluster
236  auto leadingcluster = jet->GetLeadingCluster(clusters->GetArray());
237  if(leadingcluster){
238  TLorentzVector pvect;
239  leadingcluster->GetMomentum(pvect, fVertex);
240  double maxEcell = 0.;
241  for(auto icell = 0; icell < leadingcluster->GetNCells(); icell++) {
242  auto ecell = fInputEvent->GetEMCALCells()->GetCellAmplitude(leadingcluster->GetCellAbsId(icell));
243  AliDebugStream(3) << icell << " Pos " << leadingcluster->GetCellAbsId(icell) << " Ecell " << ecell << std::endl;
244  if(ecell > maxEcell) maxEcell = ecell;
245  }
246  double fracmax = maxEcell / leadingcluster->E();
247  AliDebugStream(3) << "leading cluster Max E: " << maxEcell << ", frac " << fracmax << std::endl;
248  double lclusterpoint[7] = {std::abs(jet->Pt()), jet->NEF(), std::abs(pvect.Pt()), jet->GetZ(pvect.Px(), pvect.Py(), pvect.Pz()), jetvec.DeltaR(pvect.Vect()), std::abs(maxEcell), fracmax};
249  fHistos->FillTHnSparse(Form("hLeadingCluster%s", contname->String().Data()), lclusterpoint);
250  double leadingCellE = 0.;
251 
252  double cellpoint[5] = {std::abs(jet->Pt()), jet->NEF(), std::abs(pvect.Pt()), leadingCellE, fracmax};
253  fHistos->FillTHnSparse(Form("hLeadingCell%s", contname->String().Data()), cellpoint);
254  }
255  }
256  }
257 
258  // Look at leading particles in the leading jet
259  double leadingvec[4] = {0., 0., 0., 0.};
260  if(leadingjet) {
261  TVector3 leadingjetvec{leadingjet->Px(), leadingjet->Py(), leadingjet->Pz()};
262  leadingvec[0] = std::abs(leadingjet->Pt());
263  leadingvec[1] = leadingjet->Eta();
264  leadingvec[2] = leadingjet->Phi();
265  if(leadingvec[2] < 0) leadingvec[2] += TMath::TwoPi();
266  leadingvec[3] = leadingjet->E();
268  auto leadingtrack = leadingjet->GetLeadingTrack(tracks->GetArray());
269  if(leadingtrack) {
270  double ltrackpoint[5] = {std::abs(leadingjet->Pt()), leadingjet->NEF(), std::abs(leadingtrack->Pt()), leadingjet->GetZ(leadingtrack), leadingjet->DeltaR(leadingtrack)};
271  fHistos->FillTHnSparse(Form("hLeadingTrack%s", contname->String().Data()), ltrackpoint);
272  }
273  }
275  auto leadingcluster = leadingjet->GetLeadingCluster(clusters->GetArray());
276  if(leadingcluster){
277  TLorentzVector pvect;
278  leadingcluster->GetMomentum(pvect, fVertex);
279  double maxEcell = 0.;
280  for(auto icell = 0; icell < leadingcluster->GetNCells(); icell++) {
281  auto ecell = fInputEvent->GetEMCALCells()->GetCellAmplitude(leadingcluster->GetCellAbsId(icell));
282  if(ecell > maxEcell) maxEcell = ecell;
283  }
284  double fracmax = maxEcell / leadingcluster->E();
285  double lclusterpoint[7] = {std::abs(leadingjet->Pt()), leadingjet->NEF(), std::abs(pvect.Pt()), leadingjet->GetZ(pvect.Px(), pvect.Py(), pvect.Pz()), leadingjetvec.DeltaR(pvect.Vect()), maxEcell, fracmax};
286  fHistos->FillTHnSparse(Form("hLeadingJetLeadingCluster%s", contname->String().Data()), lclusterpoint);
287  }
288  }
289  }
290  fHistos->FillTHnSparse(Form("hPtEtaPhiELeadingJet%s", contname->String().Data()), leadingvec);
291  }
292 
293  return kTRUE;
294 }
295 
297  // Event selection
298  AliDebugStream(1) << "Trigger selection string: " << fTriggerSelectionString << ", fired trigger classes: " << fInputEvent->GetFiredTriggerClasses() << std::endl;
299  if(fTriggerSelectionString.Contains("INT7")){
300  // INT7 trigger
301  if(!(fInputHandler->IsEventSelected() & AliVEvent::kINT7)) return false;
302  } else if(fTriggerSelectionString.Contains("EJ")){
303  auto triggerclass = fTriggerSelectionString(fTriggerSelectionString.Index("EJ"),3); // cleanup trigger string from possible tags
304  AliDebugStream(1) << "Inspecting trigger class " << triggerclass << std::endl;
305  // EMCAL JET trigger
306  if(!fMCEvent){ // Running on Data
307  if(!(fInputHandler->IsEventSelected() & AliVEvent::kEMCEJE)) return false;
308  if(!fInputEvent->GetFiredTriggerClasses().Contains(triggerclass)) return false;
309  }
310 
312  auto triggerdecisions = dynamic_cast<PWG::EMCAL::AliEmcalTriggerDecisionContainer *>(fInputEvent->FindListObject(fNameTriggerDecisionContainer.Data()));
313  if(!triggerdecisions) {
314  AliErrorStream() << "No offline trigger selection available" << std::endl;
315  return false;
316  }
317  else if(!triggerdecisions->IsEventSelected(triggerclass.Data())) return false;
318  }
319  } else return false;
320 
321  AliDebugStream(1) << "Event is selected" << std::endl;
322  return true;
323 }
324 
326  using AnalysisHelpers = EMCalTriggerPtAnalysis::AliEmcalAnalysisFactory;
327  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
328  if(!mgr) {
329  std::cerr << "[AliAnalysisTaskJetConstituentQA::AddTaskEmcalJetConstituentQA(EE)] No analysis manager provided ..." << std::endl;
330  return nullptr;
331  }
332 
333  std::string jettypestring;
334  switch(jettype){
335  case AliJetContainer::kFullJet: jettypestring = "fulljets"; break;
336  case AliJetContainer::kChargedJet: jettypestring = "chargedjets"; break;
337  case AliJetContainer::kNeutralJet: jettypestring = "neutraljets"; break;
338  };
339 
340  std::stringstream taskname;
341  taskname << "constituentQA_" << jettypestring << "_" << trigger;
342  auto task = new AliAnalysisTaskEmcalJetConstituentQA(taskname.str().data());
343  task->SetTriggerSelection(trigger);
344  task->SetJetType(jettype);
345  mgr->AddTask(task);
346 
347  auto inputhandler = mgr->GetInputEventHandler();
348  auto isAOD = false;
349  if(inputhandler->IsA() == AliAODInputHandler::Class()) isAOD = true;
350 
351  TString tracksname, clustername;
352  AliParticleContainer *tracks(nullptr);
353  AliClusterContainer *clusters(nullptr);
354  if(!partmode) {
355  if(jettype == AliJetContainer::kChargedJet || jettype == AliJetContainer::kFullJet){
356  tracksname = AnalysisHelpers::TrackContainerNameFactory(isAOD);
357  tracks = task->AddTrackContainer(tracksname);
358  task->SetNameTrackContainer(tracksname);
359  tracks->SetMinPt(0.15);
360  }
361 
362  if(jettype == AliJetContainer::kNeutralJet || jettype == AliJetContainer::kFullJet){
363  clustername = AnalysisHelpers::ClusterContainerNameFactory(isAOD);
364  clusters = task->AddClusterContainer(clustername);
365  task->SetNameClusterContainer(clustername);
366  clusters->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
367  clusters->SetClusHadCorrEnergyCut(0.3);
368  }
369  } else {
370  tracksname = "mcparticles";
371  tracks = task->AddParticleContainer(tracksname);
372  task->SetNameTrackContainer(tracksname);
373  tracks->SetMinPt(0.);
374  }
375 
376  // create jet containers for R02 and R04 jets
377  std::array<double, 5> jetradii = {{0.2, 0.3, 0.4, 0.5, 0.6}};
378  for(auto r : jetradii) {
379  std::stringstream contname;
380  contname << jettypestring << "_R" << std::setw(2) << std::setfill('0') << int(r*10.);
381  auto jcont = task->AddJetContainer(jettype, AliJetContainer::antikt_algorithm, AliJetContainer::E_scheme, r, AliJetContainer::kEMCALfid, tracks, clusters, "Jet");
382  jcont->SetName(contname.str().data());
383  task->AddNameJetContainer(contname.str().data());
384  jcont->SetMinPt(20.);
385  }
386 
387  std::stringstream contname, outfilename;
388  contname << "JetConstituentQA_" << jettypestring << "_" << trigger;
389  outfilename << mgr->GetCommonFileName() << ":JetConstituentQA_" << trigger;
390  if(partmode) {
391  contname << "_part";
392  outfilename << "_part";
393  }
394  mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
395  mgr->ConnectOutput(task, 1, mgr->CreateContainer(contname.str().data(), AliEmcalList::Class(), AliAnalysisManager::kOutputContainer, outfilename.str().data()));
396 
397  return task;
398 }
EMCal fiducial acceptance (each eta, phi edge narrowed by jet R)
double Double_t
Definition: External.C:58
AliVParticle * GetLeadingTrack(TClonesArray *tracks=0) const
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
Double_t Py() const
Definition: AliEmcalJet.h:107
Double_t Phi() const
Definition: AliEmcalJet.h:117
void SetMinPt(Double_t min)
TCanvas * c
Definition: TestFitELoss.C:172
Double_t E() const
Definition: AliEmcalJet.h:119
Interface for binnings used by the histogram handler.
Definition: TBinning.h:23
Container for particles within the EMCAL framework.
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.
void FillTHnSparse(const char *name, const double *x, double weight=1., Option_t *opt="")
THashList * GetListOfHistograms() const
Get the list of histograms.
Definition: THistManager.h:671
Collection of helper functions used to configure the analysis.
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Get cluster container attached to this task.
TClonesArray * GetArray() const
AliVCluster * GetLeadingCluster(TClonesArray *clusters=0) const
Double_t GetZ(const Double_t trkPx, const Double_t trkPy, const Double_t trkPz) const
Double_t DeltaR(const AliVParticle *part) const
Double_t Pt() const
Definition: AliEmcalJet.h:109
AliEmcalList * fOutput
!output list
Double_t fVertex[3]
!event vertex
AliTrackContainer * GetTrackContainer(Int_t i=0) const
static AliAnalysisTaskEmcalJetConstituentQA * AddTaskEmcalJetConstituentQA(const char *trigger, AliJetContainer::EJetType_t jettype, bool parmode=kFALSE)
void SetMakeGeneralHistograms(Bool_t g)
Enable general histograms.
TString fNameTriggerDecisionContainer
Name of the trigger decision container.
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.
Bool_t fUseTriggerSelection
Use trigger selection in addition to trigger string.
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
Double_t Pz() const
Definition: AliEmcalJet.h:108
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.
Container for jet within the EMCAL jet framework.
void SetClusHadCorrEnergyCut(Double_t cut)