AliPhysics  2797316 (2797316)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskChargedJetsHadronCF.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2016, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: R. Haake. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes is hereby granted *
9  * without fee, provided that the above copyright notice appears in all *
10  * copies and that both the copyright notice and this permission notice *
11  * appear in the supporting documentation. The authors make no claims *
12  * about the suitability of this software for any purpose. It is *
13  * provided "as is" without express or implied warranty. *
14  **************************************************************************/
15 
16 #include <TClonesArray.h>
17 #include <TF1.h>
18 #include <TH1F.h>
19 #include <TH2F.h>
20 #include <TH3F.h>
21 #include <THn.h>
22 #include <TTree.h>
23 #include <TList.h>
24 #include <TLorentzVector.h>
25 
26 #include "AliVTrack.h"
27 #include "AliEmcalJet.h"
28 #include "AliRhoParameter.h"
29 #include "AliLog.h"
30 #include "AliJetContainer.h"
31 #include "AliTrackContainer.h"
32 #include "AliPicoTrack.h"
33 #include "AliVParticle.h"
34 #include "TRandom3.h"
36 
38 
42 //________________________________________________________________________
44 {
45 // dummy destructor
46 }
47 
51 //________________________________________________________________________
53 {
54 // dummy destructor
55 }
56 
60 //________________________________________________________________________
63  fJetsCont(0),
64  fTracksCont(0),
65  fJetsTree(0),
66  fJetsTreeBuffer(0),
67  fExtractionPercentage(0),
68  fExtractionMinPt(0),
69  fExtractionMaxPt(0),
70  fNumberOfCentralityBins(10),
71  fJetsOutput(),
72  fTracksOutput(),
73  fJetsInput(),
74  fJetParticleArrayName("JetsDPhiBasicParticles"),
75  fTrackParticleArrayName(""),
76  fJetMatchingArrayName(""),
77  fRandom(0),
78  fJetOutputMode(0),
79  fMinFakeFactorPercentage(0),
80  fMaxFakeFactorPercentage(0),
81  fEventCriteriumMode(0),
82  fEventCriteriumMinBackground(0),
83  fEventCriteriumMaxBackground(0),
84  fEventCriteriumMinLeadingJetPt(0),
85  fEventCriteriumMinSubleadingJetPt(0),
86  fEventCriteriumMinJetDeltaPhi(0),
87  fLeadingJet(0),
88  fSubleadingJet(0),
89  fMatchedJet(0),
90  fAcceptedJets(0),
91  fAcceptedTracks(0)
92 {
93  // Default constructor.
94  SetMakeGeneralHistograms(kTRUE);
95  fRandom = new TRandom3(0);
96 }
97 
98 
99 //________________________________________________________________________
101  AliAnalysisTaskEmcalJet(name, kTRUE),
102  fJetsCont(0),
103  fTracksCont(0),
104  fJetsTree(0),
105  fJetsTreeBuffer(0),
106  fExtractionPercentage(0),
107  fExtractionMinPt(0),
108  fExtractionMaxPt(0),
109  fNumberOfCentralityBins(10),
110  fJetsOutput(),
111  fTracksOutput(),
112  fJetsInput(),
113  fJetParticleArrayName("JetsDPhiBasicParticles"),
114  fTrackParticleArrayName(""),
115  fJetMatchingArrayName(""),
116  fRandom(0),
117  fJetOutputMode(0),
118  fMinFakeFactorPercentage(0),
119  fMaxFakeFactorPercentage(0),
120  fEventCriteriumMode(0),
121  fEventCriteriumMinBackground(0),
122  fEventCriteriumMaxBackground(0),
123  fEventCriteriumMinLeadingJetPt(0),
124  fEventCriteriumMinSubleadingJetPt(0),
125  fEventCriteriumMinJetDeltaPhi(0),
126  fLeadingJet(0),
127  fSubleadingJet(0),
128  fMatchedJet(0),
129  fAcceptedJets(0),
130  fAcceptedTracks(0)
131 {
132  // Constructor
134  fRandom = new TRandom3(0);
135 }
136 
137 //________________________________________________________________________
139 {
140  // Destructor.
141 }
142 
143 //________________________________________________________________________
145 {
147 
148  // ### Basic container settings
150  if(fJetsCont) { //get particles connected to jets
151  fJetsCont->PrintCuts();
153  } else { //no jets, just analysis tracks
155  }
156  if(fTracksCont) fTracksCont->SetClassName("AliVTrack");
157 
158  // ### Create all histograms
159 
160  // Change the event rejection histogram -> Add a custom value
161  fHistEventRejection->GetXaxis()->SetBinLabel(14,"JetCrit");
162 
163  // Track QA plots
164  AddHistogram2D<TH2D>("hTrackPt", "Tracks p_{T} distribution", "", 300, 0., 300., fNumberOfCentralityBins, 0, 100, "p_{T} (GeV/c)", "Centrality", "dN^{Tracks}/dp_{T}");
165  AddHistogram2D<TH2D>("hTrackPhi", "Track angular distribution in #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Tracks}/(d#phi)");
166  AddHistogram2D<TH2D>("hTrackEta", "Track angular distribution in #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta", "Centrality", "dN^{Tracks}/(d#eta)");
167  AddHistogram2D<TH2D>("hTrackPhiEta", "Track angular distribution #phi/#eta", "COLZ", 180, 0., 2*TMath::Pi(), 100, -2.5, 2.5, "#phi", "#eta", "dN^{Tracks}/d#phi d#eta");
168 
169  AddHistogram2D<TH2D>("hLeadingTrackPt", "Leading tracks p_{T} distribution", "", 300, 0., 300., fNumberOfCentralityBins, 0, 100, "p_{T} (GeV/c)", "Centrality", "dN^{Tracks}/dp_{T}");
170  AddHistogram2D<TH2D>("hLeadingTrackPhi", "Leading tracks angular distribution in #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Tracks}/(d#phi)");
171  AddHistogram2D<TH2D>("hLeadingTrackEta", "Leading tracks angular distribution in #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta", "Centrality", "dN^{Tracks}/(d#eta)");
172  AddHistogram2D<TH2D>("hLeadingTrackPhiEta", "Track angular distribution #phi/#eta", "COLZ", 180, 0., 2*TMath::Pi(), 100, -2.5, 2.5, "#phi", "#eta", "dN^{Tracks}/d#phi d#eta");
173 
174  AddHistogram2D<TH2D>("hTrackEtaPt", "Track angular distribution in #eta vs. p_{T}", "LEGO2", 100, -2.5, 2.5, 300, 0., 300., "#eta", "p_{T} (GeV/c)", "dN^{Tracks}/(d#eta dp_{T})");
175  AddHistogram2D<TH2D>("hTrackPhiPt", "Track angular distribution in #phi vs. p_{T}", "LEGO2", 180, 0, 2*TMath::Pi(), 300, 0., 300., "#phi", "p_{T} (GeV/c)", "dN^{Tracks}/(d#phi dp_{T})");
176 
177 
178  // Jet QA plots
179  AddHistogram2D<TH2D>("hJetPtRaw", "Jets p_{T} distribution (no bgrd. corr.)", "", 300, 0., 300., fNumberOfCentralityBins, 0, 100, "p_{T, jet} (GeV/c)", "Centrality", "dN^{Jets}/dp_{T}");
180  AddHistogram2D<TH2D>("hJetPt", "Jets p_{T} distribution (background subtracted)", "", 400, -100., 300., fNumberOfCentralityBins, 0, 100, "p_{T, jet} (GeV/c)", "Centrality", "dN^{Jets}/dp_{T}");
181  AddHistogram2D<TH2D>("hJetPhi", "Jet angular distribution #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Jets}/d#phi");
182  AddHistogram2D<TH2D>("hJetEta", "Jet angular distribution #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta","Centrality","dN^{Jets}/d#eta");
183  AddHistogram2D<TH2D>("hJetPhiPt", "Jet angular distribution #phi vs. p_{T}", "LEGO2", 180, 0., 2*TMath::Pi(), 400, -100., 300., "#phi", "p_{T, jet} (GeV/c)", "dN^{Jets}/d#phi dp_{T}");
184  AddHistogram2D<TH2D>("hJetEtaPt", "Jet angular distribution #eta vs. p_{T}", "LEGO2", 100, -2.5, 2.5, 400, -100., 300., "#eta","p_{T, jet} (GeV/c)","dN^{Jets}/d#eta dp_{T}");
185  AddHistogram2D<TH2D>("hJetPhiEta", "Jet angular distribution #phi/#eta", "COLZ", 180, 0., 2*TMath::Pi(), 100, -2.5, 2.5, "#phi", "#eta", "dN^{Jets}/d#phi d#eta");
186  AddHistogram2D<TH2D>("hJetArea", "Jet area", "LEGO2", 200, 0., 2., fNumberOfCentralityBins, 0, 100, "Jet A", "Centrality", "dN^{Jets}/dA");
187  AddHistogram2D<TH2D>("hJetAreaPt", "Jet area vs. p_{T}", "LEGO2", 200, 0., 2., 400, -100., 300., "Jet A", "p_{T, jet} (GeV/c)", "dN^{Jets}/dA dp_{T}");
188  AddHistogram2D<TH2D>("hJetPtLeadingHadron", "Jet leading hadron p_{T} distribution vs. jet p_{T}", "", 300, 0., 300., 300, 0., 300., "p_{T, jet} (GeV/c)", "p_{T,lead had} (GeV/c)", "dN^{Jets}/dp_{T}dp_{T,had}");
189 
190  AddHistogram2D<TH2D>("hJetConstituentPt_Cent0_100", "Jet constituent p_{T} distribution vs. jet p_T (background subtracted)", "", 400, -100., 300., 300, 0., 300., "p_{T, jet} (GeV/c)", "p_{T, track} (GeV/c)", "dN^{Tracks}/d^{2}p_{T}");
191  AddHistogram2D<TH2D>("hJetConstituentPt_Cent0_10", "Jet constituent p_{T} distribution vs. jet p_T (background subtracted), 0-10 centrality", "", 400, -100., 300., 300, 0., 300., "p_{T, jet} (GeV/c)", "p_{T, track} (GeV/c)", "dN^{Tracks}/d^{2}p_{T}");
192 
193  AddHistogram2D<TH2D>("hJetConstituentCount_Cent0_100", "Jet constituent count vs. jet p_T (background subtracted)", "", 400, -100., 300., 200, 0., 200., "p_{T, jet} (GeV/c)", "Count", "dN^{Jets}/dNdp_{T}");
194  AddHistogram2D<TH2D>("hJetConstituentCount_Cent0_10", "Jet constituent count vs. jet p_T (background subtracted), 0-10 centrality", "", 400, -100., 300., 200, 0., 200., "p_{T, jet} (GeV/c)", "Count", "dN^{Jets}/dNdp_{T}");
195 
196  // Random cone plots
197  AddHistogram2D<TH2D>("hRandomConePt", "Random cone p_{T} distribution", "", 400, -100., 300., fNumberOfCentralityBins, 0, 100, "p_{T, cone} (GeV/c)", "Centrality", "dN^{Tracks}/dp_{T}");
198  AddHistogram2D<TH2D>("hRandomConeRawPt", "Random cone p_{T} distribution (no bgrd. correction)", "", 300, 0., 300., fNumberOfCentralityBins, 0, 100, "p_{T, cone} (GeV/c)", "Centrality", "dN^{Tracks}/dp_{T}");
199 
200  // Leading/subleading, background ...
201 
202  AddHistogram2D<TH2D>("hLeadingJetPtRaw", "Jets p_{T} distribution (no bgrd. corr.)", "", 300, 0., 300., fNumberOfCentralityBins, 0, 100, "p_{T, jet} (GeV/c)", "Centrality", "dN^{Jets}/dp_{T}");
203  AddHistogram2D<TH2D>("hLeadingJetPt", "Jets p_{T} distribution (background subtracted)", "", 400, -100., 300., fNumberOfCentralityBins, 0, 100, "p_{T, jet} (GeV/c)", "Centrality", "dN^{Jets}/dp_{T}");
204  AddHistogram2D<TH2D>("hLeadingJetPhi", "Jet angular distribution #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Jets}/d#phi");
205  AddHistogram2D<TH2D>("hLeadingJetEta", "Jet angular distribution #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta","Centrality","dN^{Jets}/d#eta");
206  AddHistogram2D<TH2D>("hLeadingJetPhiPt", "Jet angular distribution #phi vs. p_{T}", "LEGO2", 180, 0., 2*TMath::Pi(), 400, -100., 300., "#phi", "p_{T, jet} (GeV/c)", "dN^{Jets}/d#phi dp_{T}");
207  AddHistogram2D<TH2D>("hLeadingJetEtaPt", "Jet angular distribution #eta vs. p_{T}", "LEGO2", 100, -2.5, 2.5, 400, -100., 300., "#eta","p_{T, jet} (GeV/c)","dN^{Jets}/d#eta dp_{T}");
208  AddHistogram2D<TH2D>("hLeadingJetPhiEta", "Jet angular distribution #phi/#eta", "COLZ", 180, 0., 2*TMath::Pi(), 100, -2.5, 2.5, "#phi", "#eta", "dN^{Jets}/d#phi d#eta");
209  AddHistogram2D<TH2D>("hLeadingJetArea", "Jet area", "LEGO2", 200, 0., 2., fNumberOfCentralityBins, 0, 100, "Jet A", "Centrality", "dN^{Jets}/dA");
210  AddHistogram2D<TH2D>("hLeadingJetAreaPt", "Jet area vs. p_{T}", "LEGO2", 200, 0., 2., 400, -100., 300., "Jet A", "p_{T, jet} (GeV/c)", "dN^{Jets}/dA dp_{T}");
211  AddHistogram2D<TH2D>("hLeadingJetPtLeadingHadron", "Jet leading hadron p_{T} distribution vs. jet p_{T}", "", 300, 0., 300., 300, 0., 300., "p_{T, jet} (GeV/c)", "p_{T,lead had} (GeV/c)", "dN^{Jets}/dp_{T}dp_{T,had}");
212 
213  AddHistogram2D<TH2D>("hSubleadingJetPtRaw", "Jets p_{T} distribution (no bgrd. corr.)", "", 300, 0., 300., fNumberOfCentralityBins, 0, 100, "p_{T, jet} (GeV/c)", "Centrality", "dN^{Jets}/dp_{T}");
214  AddHistogram2D<TH2D>("hSubleadingJetPt", "Jets p_{T} distribution (background subtracted)", "", 400, -100., 300., fNumberOfCentralityBins, 0, 100, "p_{T, jet} (GeV/c)", "Centrality", "dN^{Jets}/dp_{T}");
215  AddHistogram2D<TH2D>("hSubleadingJetPhi", "Jet angular distribution #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Jets}/d#phi");
216  AddHistogram2D<TH2D>("hSubleadingJetEta", "Jet angular distribution #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta","Centrality","dN^{Jets}/d#eta");
217  AddHistogram2D<TH2D>("hSubleadingJetPhiPt", "Jet angular distribution #phi vs. p_{T}", "LEGO2", 180, 0., 2*TMath::Pi(), 400, -100., 300., "#phi", "p_{T, jet} (GeV/c)", "dN^{Jets}/d#phi dp_{T}");
218  AddHistogram2D<TH2D>("hSubleadingJetEtaPt", "Jet angular distribution #eta vs. p_{T}", "LEGO2", 100, -2.5, 2.5, 400, -100., 300., "#eta","p_{T, jet} (GeV/c)","dN^{Jets}/d#eta dp_{T}");
219  AddHistogram2D<TH2D>("hSubleadingJetPhiEta", "Jet angular distribution #phi/#eta", "COLZ", 180, 0., 2*TMath::Pi(), 100, -2.5, 2.5, "#phi", "#eta", "dN^{Jets}/d#phi d#eta");
220  AddHistogram2D<TH2D>("hSubleadingJetArea", "Jet area", "LEGO2", 200, 0., 2., fNumberOfCentralityBins, 0, 100, "Jet A", "Centrality", "dN^{Jets}/dA");
221  AddHistogram2D<TH2D>("hSubleadingJetAreaPt", "Jet area vs. p_{T}", "LEGO2", 200, 0., 2., 400, -100., 300., "Jet A", "p_{T, jet} (GeV/c)", "dN^{Jets}/dA dp_{T}");
222  AddHistogram2D<TH2D>("hSubleadingJetPtLeadingHadron", "Jet leading hadron p_{T} distribution vs. jet p_{T}", "", 300, 0., 300., 300, 0., 300., "p_{T, jet} (GeV/c)", "p_{T,lead had} (GeV/c)", "dN^{Jets}/dp_{T}dp_{T,had}");
223 
224  AddHistogram2D<TH2D>("hTrackCount", "Number of tracks in acceptance vs. centrality", "LEGO2", 500, 0., 5000., fNumberOfCentralityBins, 0, 100, "N tracks","Centrality", "dN^{Events}/dN^{Tracks}");
225  AddHistogram2D<TH2D>("hJetCount", "Number of jets in acceptance vs. centrality", "LEGO2", 100, 0., 100., fNumberOfCentralityBins, 0, 100, "N Jets","Centrality", "dN^{Events}/dN^{Jets}");
226  AddHistogram2D<TH2D>("hFakeFactor", "Fake factor distribution", "LEGO2", 1000, 0., 100., fNumberOfCentralityBins, 0, 100, "Fake factor","Centrality", "dN^{Jets}/df");
227  AddHistogram2D<TH2D>("hFakeFactorJetPt_Cent0_100", "Fake factor distribution vs. jet p_{T}", "LEGO2", 1000, 0., 100., 400, -100., 300., "Fake factor","Jet p_{T} (GeV/c)", "dN^{Jets}/df");
228  AddHistogram2D<TH2D>("hFakeFactorJetPt_Cent0_10", "Fake factor distribution vs. jet p_{T}", "LEGO2", 1000, 0., 100., 400, -100., 300., "Fake factor","Jet p_{T} (GeV/c)", "dN^{Jets}/df");
229 
230  AddHistogram2D<TH2D>("hBackgroundPt", "Background p_{T} distribution", "", 150, 0., 150., fNumberOfCentralityBins, 0, 100, "Background p_{T} (GeV/c)", "Centrality", "dN^{Events}/dp_{T}");
231  AddHistogram2D<TH2D>("hBackgroundPtJetPt_Cent0_100", "Background p_{T} distribution vs. jet p_{T}", "", 150, 0., 150., 400, -100., 300., "Background p_{T} (GeV/c)", "Jet p_{T} (GeV/c)", "dN^{Events}/dp_{T}");
232  AddHistogram2D<TH2D>("hBackgroundPtJetPt_Cent0_10", "Background p_{T} distribution vs. jet p_{T}", "", 150, 0., 150., 400, -100., 300., "Background p_{T} (GeV/c)", "Jet p_{T} (GeV/c)", "dN^{Events}/dp_{T}");
233  AddHistogram2D<TH2D>("hBackgroundPtConstCount_Cent0_100", "Background p_{T} distribution vs. const. count", "", 150, 0., 150., 200, 0., 200., "Background p_{T} (GeV/c)", "Count", "dN^{Events}/dp_{T}");
234  AddHistogram2D<TH2D>("hBackgroundPtConstCount_Cent0_10", "Background p_{T} distribution vs. const. count", "", 150, 0., 150., 200, 0., 200., "Background p_{T} (GeV/c)", "Count", "dN^{Events}/dp_{T}");
235 
236  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
237 }
238 
239 
240 //________________________________________________________________________
242 
244 
245  // ### Add the jets as basic correlation particles to the event
246  if (!(fInputEvent->FindListObject(Form("%s", fJetParticleArrayName.Data()))))
247  {
248  fJetsOutput = new TClonesArray("AliPicoTrack");
249  fJetsOutput->SetName(fJetParticleArrayName.Data());
250  fInputEvent->AddObject(fJetsOutput);
251  }
252  else
253  AliError(Form("%s: Object with name %s already in event!", GetName(), Form("%s", fJetParticleArrayName.Data())));
254 
255  // ### Add the tracks as basic correlation particles to the event (optional)
256  if(fTrackParticleArrayName != "")
257  {
258  if (!(fInputEvent->FindListObject(Form("%s", fTrackParticleArrayName.Data()))))
259  {
260  fTracksOutput = new TClonesArray("AliPicoTrack");
261  fTracksOutput->SetName(fTrackParticleArrayName.Data());
262  fInputEvent->AddObject(fTracksOutput);
263  }
264  else
265  AliError(Form("%s: Object with name %s already in event!", GetName(), Form("%s", fTrackParticleArrayName.Data())));
266  }
267 
268  // ### Import generated jets from toymodel for matching (optional)
269  if(fJetMatchingArrayName != "")
270  {
271  fJetsInput = static_cast<TClonesArray*>(InputEvent()->FindListObject(Form("%s", fJetMatchingArrayName.Data())));
272  if(!fJetsInput)
273  AliFatal(Form("Importing jets for matching failed! Array '%s' not found!", fJetMatchingArrayName.Data()));
274  }
275 
276  // ### Jets tree (optional)
278  {
279  fJetsTree = new TTree("ExtractedJets", "ExtractedJets");
280  fJetsTree->Branch("Jets", "AliBasicJet", &fJetsTreeBuffer, 1000);
281  fOutput->Add(fJetsTree);
282  }
283 
284 }
285 
286 //________________________________________________________________________
288 {
289 
290  // In case of special selection criteria, trigger on certain events
291  if(fEventCriteriumMode==0) // "minimum bias"
292  {
293  // do nothing
294  }
295  else if(fEventCriteriumMode==1) // background constraints
296  {
298  {
299  fHistEventRejection->Fill("JetCrit", 1);
300  return kFALSE;
301  }
302  }
303  else if(fEventCriteriumMode==2) // Minimum leading jet pT
304  {
305  if(fLeadingJet)
306  {
308  {
309  fHistEventRejection->Fill("JetCrit", 1);
310  return kFALSE;
311  }
312  }
313  }
314  else if(fEventCriteriumMode==3) // Simple dijet trigger
315  {
317  {
320  {
321  fHistEventRejection->Fill("JetCrit", 1);
322  return kFALSE;
323  }
324  else // dijet pT fulfilled, check back-to-back criterium
325  {
326  Double_t deltaPhi = TMath::Min(TMath::Abs(fLeadingJet->Phi()-fSubleadingJet->Phi()),TMath::TwoPi() - TMath::Abs(fLeadingJet->Phi()-fSubleadingJet->Phi()));
327  if(deltaPhi <= fEventCriteriumMinJetDeltaPhi)
328  {
329  fHistEventRejection->Fill("JetCrit", 1);
330  return kFALSE;
331  }
332  }
333  }
334  }
335  return kTRUE;
336 }
337 
338 //________________________________________________________________________
340 {
341  if(fJetOutputMode==3) // output leading&subleading jet
342  {
343  if((jet!=fLeadingJet) && (jet!=fSubleadingJet))
344  return kFALSE;
345  }
346  else if(fJetOutputMode==1) // output the leading jet
347  {
348  if(jet!=fLeadingJet)
349  return kFALSE;
350  }
351  else if(fJetOutputMode==2) // output the subleading jet
352  {
353  if(jet!=fSubleadingJet)
354  return kFALSE;
355  }
356 /*
357  if(fFakeFactorCutProfile)
358  {
359  if( (fakeFactor >= fMinFakeFactorPercentage*fFakeFactorCutProfile->GetBinContent(fFakeFactorCutProfile->GetXaxis()->FindBin(fCent))) && (fakeFactor < fMaxFakeFactorPercentage*fFakeFactorCutProfile->GetBinContent(fFakeFactorCutProfile->GetXaxis()->FindBin(fCent))) )
360  return kFALSE;
361  }
362 */
363 
364  // Jet matching. Only done if SetJetMatchingArrayName() called
365  Bool_t matchedFound = kFALSE;
366  fMatchedJet = 0;
367  if(fJetsInput)
368  {
369  // Search leading jet (in acceptance)
370  AliEmcalJet* leadingJet = 0;
371  Double_t leadingPt = -999.;
372  for(Int_t i=0; i<fJetsInput->GetEntries(); i++)
373  {
374  AliEmcalJet* tmpJet = static_cast<AliEmcalJet*>(fJetsInput->At(i));
375  UInt_t dummy = 0;
376  if(!fJetsCont->AcceptJet(tmpJet , dummy))
377  continue;
378 
379  if(tmpJet->Pt() > leadingPt)
380  {
381  leadingJet = tmpJet;
382  leadingPt = tmpJet->Pt();
383  }
384  }
385 
386  if(leadingJet)
387  {
388  Double_t bestMatchDeltaR = 999.;
389  Double_t deltaPhi = TMath::Min(TMath::Abs(jet->Phi()-leadingJet->Phi()),TMath::TwoPi() - TMath::Abs(jet->Phi()-leadingJet->Phi()));
390  Double_t deltaEta = TMath::Abs(jet->Eta() - leadingJet->Eta());
391  Double_t deltaR = TMath::Sqrt((deltaPhi*deltaPhi) + (deltaEta*deltaEta));
392 
393  if(deltaR < bestMatchDeltaR)
394  bestMatchDeltaR = deltaR;
395 
396  // Check if a matching jet is found.
397  if(bestMatchDeltaR < 0.9*fJetsCont->GetJetRadius())
398  matchedFound = kTRUE;
399 
400  if(matchedFound)
401  fMatchedJet = leadingJet;
402  }
403  }
404 
405  if(fJetOutputMode==4) // matching jets only
406  return matchedFound;
407  else if(fJetOutputMode==5) // non-matching jets only
408  return !matchedFound;
409 
410  return kTRUE;
411 }
412 
413 //________________________________________________________________________
415 {
416  // All jets
417  FillHistogram("hJetPtRaw", jet->Pt(), fCent);
418  FillHistogram("hJetPt", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fCent);
419  FillHistogram("hJetPhi", jet->Phi(), fCent);
420  FillHistogram("hJetEta", jet->Eta(), fCent);
421  FillHistogram("hJetEtaPt", jet->Eta(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
422  FillHistogram("hJetPhiPt", jet->Phi(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
423  FillHistogram("hJetPhiEta", jet->Phi(), jet->Eta());
424  FillHistogram("hJetArea", jet->Area(), fCent);
425  FillHistogram("hJetAreaPt", jet->Area(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
426  FillHistogram("hJetPtLeadingHadron", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fJetsCont->GetLeadingHadronPt(jet));
427 
428  FillHistogram("hBackgroundPtJetPt_Cent0_100", fJetsCont->GetRhoVal(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
429  if( (fCent >= 0) && (fCent < 10) )
430  FillHistogram("hBackgroundPtJetPt_Cent0_10", fJetsCont->GetRhoVal(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
431 
432  // Fake jet rejection (0810.1219)
433  Double_t fakeFactor = CalculateFakeFactor(jet);
434  FillHistogram("hFakeFactor", fakeFactor, fCent);
435  FillHistogram("hFakeFactorJetPt_Cent0_100", fakeFactor, jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
436  if( (fCent >= 0) && (fCent < 10) )
437  FillHistogram("hFakeFactorJetPt_Cent0_10", fakeFactor, jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
438 
439 
440  // Leading jet plots
441  if(jet==fLeadingJet)
442  {
443  FillHistogram("hLeadingJetPtRaw", jet->Pt(), fCent);
444  FillHistogram("hLeadingJetPt", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fCent);
445  FillHistogram("hLeadingJetPhi", jet->Phi(), fCent);
446  FillHistogram("hLeadingJetEta", jet->Eta(), fCent);
447  FillHistogram("hLeadingJetEtaPt", jet->Eta(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
448  FillHistogram("hLeadingJetPhiPt", jet->Phi(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
449  FillHistogram("hLeadingJetPhiEta", jet->Phi(), jet->Eta());
450  FillHistogram("hLeadingJetArea", jet->Area(), fCent);
451  FillHistogram("hLeadingJetAreaPt", jet->Area(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
452  FillHistogram("hLeadingJetPtLeadingHadron", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fJetsCont->GetLeadingHadronPt(jet));
453  }
454 
455  // Subleading jet plot
456  else if(jet==fSubleadingJet)
457  {
458  FillHistogram("hSubleadingJetPtRaw", jet->Pt(), fCent);
459  FillHistogram("hSubleadingJetPt", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fCent);
460  FillHistogram("hSubleadingJetPhi", jet->Phi(), fCent);
461  FillHistogram("hSubleadingJetEta", jet->Eta(), fCent);
462  FillHistogram("hSubleadingJetEtaPt", jet->Eta(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
463  FillHistogram("hSubleadingJetPhiPt", jet->Phi(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
464  FillHistogram("hSubleadingJetPhiEta", jet->Phi(), jet->Eta());
465  FillHistogram("hSubleadingJetArea", jet->Area(), fCent);
466  FillHistogram("hSubleadingJetAreaPt", jet->Area(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
467  FillHistogram("hSubleadingJetPtLeadingHadron", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fJetsCont->GetLeadingHadronPt(jet));
468  }
469 }
470 
471 //________________________________________________________________________
473 {
474  FillHistogram("hTrackPt", track->Pt(), fCent);
475  FillHistogram("hTrackPhi", track->Phi(), fCent);
476  FillHistogram("hTrackEta", track->Eta(), fCent);
477  FillHistogram("hTrackEtaPt", track->Eta(), track->Pt());
478  FillHistogram("hTrackPhiPt", track->Phi(), track->Pt());
479  FillHistogram("hTrackPhiEta", track->Phi(), track->Eta());
480 }
481 
482 //________________________________________________________________________
484 {
485  // Loop over all jet constituents
486  for(Int_t i = 0; i < jet->GetNumberOfTracks(); i++)
487  {
488  AliVParticle* constituent = static_cast<AliVParticle*>(jet->TrackAt(i, fTracksCont->GetArray()));
489  if(!constituent)
490  continue;
491 
492  // Fill jet constituent plots
493  FillHistogram("hJetConstituentPt_Cent0_100", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), constituent->Pt());
494  if( (fCent >= 0) && (fCent < 10) )
495  FillHistogram("hJetConstituentPt_Cent0_10", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), constituent->Pt());
496 
497  }
498 
499  FillHistogram("hJetConstituentCount_Cent0_100", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), jet->GetNumberOfTracks());
500  if( (fCent >= 0) && (fCent < 10) )
501  FillHistogram("hJetConstituentCount_Cent0_10", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), jet->GetNumberOfTracks());
502 
503  FillHistogram("hBackgroundPtConstCount_Cent0_100", fJetsCont->GetRhoVal(), jet->GetNumberOfTracks());
504  if( (fCent >= 0) && (fCent < 10) )
505  FillHistogram("hBackgroundPtConstCount_Cent0_10", fJetsCont->GetRhoVal(), jet->GetNumberOfTracks());
506 }
507 
508 //________________________________________________________________________
510 {
511  new ((*fJetsOutput)[fAcceptedJets]) AliPicoTrack(jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), jet->Eta(), jet->Phi(), jet->Charge(), 0, 0);
512  fAcceptedJets++;
513 }
514 
515 //________________________________________________________________________
517 {
518  if(fTrackParticleArrayName != "")
519  {
520  new ((*fTracksOutput)[fAcceptedTracks]) AliPicoTrack(track->Pt(), track->Eta(), track->Phi(), track->Charge(), 0, 0); // only Pt,Eta,Phi are interesting for correlations;
521  fAcceptedTracks++;
522  }
523 }
524 
525 //________________________________________________________________________
527 {
528  // Check pT threshold
529  if( ((jet->Pt()-jet->Area()*fJetsCont->GetRhoVal()) < fExtractionMinPt) || ((jet->Pt()-jet->Area()*fJetsCont->GetRhoVal()) >= fExtractionMaxPt) )
530  return;
531 
532  // Discard jets statistically
533  if(fRandom->Rndm() >= fExtractionPercentage)
534  return;
535 
536  Long64_t eventID = InputEvent()->GetHeader()->GetEventIdAsLong();
537  AliBasicJet basicJet(jet->Eta(), jet->Phi(), jet->Pt(), jet->Charge(), fJetsCont->GetJetRadius(), jet->Area(), fJetsCont->GetRhoVal(), eventID, fCent);
538  // Add constituents
539  for(Int_t i = 0; i < jet->GetNumberOfTracks(); i++)
540  {
541  AliVParticle* particle = static_cast<AliVParticle*>(jet->TrackAt(i, fTracksCont->GetArray()));
542  if(!particle) continue;
543  basicJet.AddJetConstituent(particle->Eta(), particle->Phi(), particle->Pt(), particle->Charge());
544  }
545  if(fMatchedJet) // set the true pT from the matched jets
546  basicJet.SetTruePt(fMatchedJet->Pt());
547 
548  fJetsTreeBuffer = &basicJet;
549  fJetsTree->Fill();
550 }
551 
552 //________________________________________________________________________
554 {
556 
558  return kFALSE;
559 
560  // ####### Jet loop
561  fAcceptedJets = 0;
562  fJetsCont->ResetCurrentID();
563  while(AliEmcalJet *jet = fJetsCont->GetNextAcceptJet())
564  {
565  if(!IsJetSelected(jet))
566  continue;
567 
568  // Jet plots
569  FillHistogramsJets(jet);
571 
572  // Add jet to output array
574  AddJetToTree(jet);
575  AddJetToOutputArray(jet);
576  }
577 
578 
579  // ####### Particle loop
580  // Throw random cone
581  Double_t tmpRandConeEta = fJetsCont->GetJetEtaMin() + fRandom->Rndm()*TMath::Abs(fJetsCont->GetJetEtaMax()-fJetsCont->GetJetEtaMin());
582  Double_t tmpRandConePhi = fRandom->Rndm()*TMath::TwoPi();
583  Double_t tmpRandConePt = 0; // to be determined
584 
585  fAcceptedTracks = 0;
586  fTracksCont->ResetCurrentID();
587  Int_t trackcount = 0;
588  while(AliVTrack *track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle()))
589  {
590  // Track plots
591  FillHistogramsTracks(track);
592 
593  if(IsTrackInCone(track, tmpRandConeEta, tmpRandConePhi, fJetsCont->GetJetRadius()))
594  tmpRandConePt += track->Pt();
595 
596  // Add track to output array
597  trackcount++;
598  AddTrackToOutputArray(track);
599  }
600 
601  // ####### Event properties
602  FillHistogram("hRandomConePt", tmpRandConePt - fJetsCont->GetRhoVal()*fJetsCont->GetJetRadius()*fJetsCont->GetJetRadius()*TMath::Pi(), fCent);
603  FillHistogram("hRandomConeRawPt", tmpRandConePt, fCent);
604 
605  FillHistogram("hBackgroundPt", fJetsCont->GetRhoVal(), fCent);
606  FillHistogram("hJetCount", fAcceptedJets, fCent);
607  FillHistogram("hTrackCount", trackcount, fCent);
608  // NOTE: It is possible to use fTracksCont->GetLeadingParticle() since we do not apply additional track cuts
609  AliVTrack* leadTrack = static_cast<AliVTrack*>(fTracksCont->GetLeadingParticle());
610  if(leadTrack)
611  {
612  FillHistogram("hLeadingTrackPt", leadTrack->Pt(), fCent);
613  FillHistogram("hLeadingTrackPhi", leadTrack->Phi(), fCent);
614  FillHistogram("hLeadingTrackEta", leadTrack->Eta(), fCent);
615  FillHistogram("hLeadingTrackPhiEta", leadTrack->Phi(), leadTrack->Eta());
616  }
617 
618  return kTRUE;
619 }
620 
621 //########################################################################
622 // HELPERS
623 //########################################################################
624 
625 
626 //________________________________________________________________________
627 inline Bool_t AliAnalysisTaskChargedJetsHadronCF::IsTrackInCone(AliVParticle* track, Double_t eta, Double_t phi, Double_t radius)
628 {
629  // This is to use a full cone in phi even at the edges of phi (2pi -> 0) (0 -> 2pi)
630  Double_t trackPhi = 0.0;
631  if (track->Phi() > (TMath::TwoPi() - (radius-phi)))
632  trackPhi = track->Phi() - TMath::TwoPi();
633  else if (track->Phi() < (phi+radius - TMath::TwoPi()))
634  trackPhi = track->Phi() + TMath::TwoPi();
635  else
636  trackPhi = track->Phi();
637 
638  if ( TMath::Abs(trackPhi-phi)*TMath::Abs(trackPhi-phi) + TMath::Abs(track->Eta()-eta)*TMath::Abs(track->Eta()-eta) <= radius*radius)
639  return kTRUE;
640 
641  return kFALSE;
642 }
643 
644 
645 //________________________________________________________________________
647 {
648  // Calculate leading + subleading jet
650 }
651 
652 //________________________________________________________________________
654 {
655  Double_t fakeFactor = 0;
656 
657  // Loop over all jet constituents
658  for(Int_t i = 0; i < jet->GetNumberOfTracks(); i++)
659  {
660  AliVParticle* constituent = static_cast<AliVParticle*>(jet->TrackAt(i, fTracksCont->GetArray()));
661 
662  Double_t deltaPhi = TMath::Min(TMath::Abs(jet->Phi()-constituent->Phi()),TMath::TwoPi() - TMath::Abs(jet->Phi()-constituent->Phi()));
663  Double_t deltaR = TMath::Sqrt( (jet->Eta() - constituent->Eta())*(jet->Eta() - constituent->Eta()) + deltaPhi*deltaPhi );
664  fakeFactor += constituent->Pt() * TMath::Sin(deltaR);
665  }
666 
667  return fakeFactor;
668 }
669 
670 //________________________________________________________________________
672 {
673  fEventCriteriumMode = type;
674 
675  if(fEventCriteriumMode==0)
676  AliWarning("Set event criterium to 'default' -- no further selection criterium.");
677  else if(fEventCriteriumMode==1)
678  AliWarning("Set event criterium to 'background' -- select events with certain backgrounds");
679  else if(fEventCriteriumMode==2)
680  AliWarning("Set event criterium to 'simple jet trigger' -- select events with certain minimum leading jet pT (bgrd corr.)");
681  else if(fEventCriteriumMode==3)
682  AliWarning("Set event criterium to 'simple dijet trigger' -- select events with certain minimum leading + subleading jet pT (bgrd corr.)");
683  else
684  {
685  AliFatal("Event criterium not valid.");
686  }
687 }
688 
689 
690 //________________________________________________________________________
691 void AliAnalysisTaskChargedJetsHadronCF::GetLeadingJets(const char* opt, AliEmcalJet*& jetLeading, AliEmcalJet*& jetSubLeading)
692 {
693  // Customized from AliJetContainer::GetLeadingJet()
694  // Get the leading+subleading jet; if opt contains "rho" the sorting is according to pt-A*rho
695 
696  TString option(opt);
697  option.ToLower();
698 
699  jetLeading = 0;
700  jetSubLeading = 0;
701 
702  fJetsCont->ResetCurrentID();
703  Double_t tmpLeadingPt = 0;
704  Double_t tmpSubleadingPt = 0;
705 
706  if (option.Contains("rho")) {
707  while (AliEmcalJet* jet = fJetsCont->GetNextAcceptJet()) {
708  if ( (jet->Pt()-jet->Area()*fJetsCont->GetRhoVal()) > tmpLeadingPt )
709  {
710  jetSubLeading = jetLeading;
711  jetLeading = jet;
712  tmpSubleadingPt = tmpLeadingPt;
713  tmpLeadingPt = jet->Pt()-jet->Area()*fJetsCont->GetRhoVal();
714  }
715  else if ( (jet->Pt()-jet->Area()*fJetsCont->GetRhoVal()) > tmpSubleadingPt )
716  {
717  jetSubLeading = jet;
718  tmpSubleadingPt = jet->Pt()-jet->Area()*fJetsCont->GetRhoVal();
719  }
720  }
721  }
722  else {
723  while (AliEmcalJet* jet = fJetsCont->GetNextAcceptJet()) {
724  if ( (jet->Pt()) > tmpLeadingPt )
725  {
726  jetSubLeading = jetLeading;
727  jetLeading = jet;
728  tmpSubleadingPt = tmpLeadingPt;
729  tmpLeadingPt = jet->Pt();
730  }
731  else if ( (jet->Pt()) > tmpSubleadingPt )
732  {
733  jetSubLeading = jet;
734  tmpSubleadingPt = jet->Pt();
735  }
736  }
737  }
738 }
739 
740 //________________________________________________________________________
741 void AliAnalysisTaskChargedJetsHadronCF::BinLogAxis(const THn *h, Int_t axisNumber)
742 {
743  // Method for the correct logarithmic binning of histograms
744  TAxis *axis = h->GetAxis(axisNumber);
745  int bins = axis->GetNbins();
746 
747  Double_t from = axis->GetXmin();
748  Double_t to = axis->GetXmax();
749  Double_t *newBins = new Double_t[bins + 1];
750 
751  newBins[0] = from;
752  Double_t factor = pow(to/from, 1./bins);
753 
754  for (int i = 1; i <= bins; i++) {
755  newBins[i] = factor * newBins[i-1];
756  }
757  axis->Set(bins, newBins);
758  delete [] newBins;
759 }
760 
761 //________________________________________________________________________
762 inline void AliAnalysisTaskChargedJetsHadronCF::FillHistogram(const char * key, Double_t x)
763 {
764  TH1* tmpHist = static_cast<TH1*>(fOutput->FindObject(key));
765  if(!tmpHist)
766  {
767  AliError(Form("Cannot find histogram <%s> ",key)) ;
768  return;
769  }
770 
771  tmpHist->Fill(x);
772 }
773 
774 //________________________________________________________________________
775 inline void AliAnalysisTaskChargedJetsHadronCF::FillHistogram(const char * key, Double_t x, Double_t y)
776 {
777  TH1* tmpHist = static_cast<TH1*>(fOutput->FindObject(key));
778  if(!tmpHist)
779  {
780  AliError(Form("Cannot find histogram <%s> ",key));
781  return;
782  }
783 
784  if (tmpHist->IsA()->GetBaseClass("TH1"))
785  static_cast<TH1*>(tmpHist)->Fill(x,y); // Fill x with y
786  else if (tmpHist->IsA()->GetBaseClass("TH2"))
787  static_cast<TH2*>(tmpHist)->Fill(x,y); // Fill x,y with 1
788 }
789 
790 //________________________________________________________________________
791 inline void AliAnalysisTaskChargedJetsHadronCF::FillHistogram(const char * key, Double_t x, Double_t y, Double_t add)
792 {
793  TH2* tmpHist = static_cast<TH2*>(fOutput->FindObject(key));
794  if(!tmpHist)
795  {
796  AliError(Form("Cannot find histogram <%s> ",key));
797  return;
798  }
799 
800  tmpHist->Fill(x,y,add);
801 }
802 
803 //________________________________________________________________________
804 inline void AliAnalysisTaskChargedJetsHadronCF::FillHistogram3D(const char * key, Double_t x, Double_t y, Double_t z, Double_t add)
805 {
806  TH3* tmpHist = static_cast<TH3*>(fOutput->FindObject(key));
807  if(!tmpHist)
808  {
809  AliError(Form("Cannot find histogram <%s> ",key));
810  return;
811  }
812 
813  if(add)
814  tmpHist->Fill(x,y,z,add);
815  else
816  tmpHist->Fill(x,y,z);
817 }
818 
819 
820 //________________________________________________________________________
821 template <class T> T* AliAnalysisTaskChargedJetsHadronCF::AddHistogram1D(const char* name, const char* title, const char* options, Int_t xBins, Double_t xMin, Double_t xMax, const char* xTitle, const char* yTitle)
822 {
823  T* tmpHist = new T(name, title, xBins, xMin, xMax);
824 
825  tmpHist->GetXaxis()->SetTitle(xTitle);
826  tmpHist->GetYaxis()->SetTitle(yTitle);
827  tmpHist->SetOption(options);
828  tmpHist->SetMarkerStyle(kFullCircle);
829  tmpHist->Sumw2();
830 
831  fOutput->Add(tmpHist);
832 
833  return tmpHist;
834 }
835 
836 //________________________________________________________________________
837 template <class T> T* AliAnalysisTaskChargedJetsHadronCF::AddHistogram2D(const char* name, const char* title, const char* options, Int_t xBins, Double_t xMin, Double_t xMax, Int_t yBins, Double_t yMin, Double_t yMax, const char* xTitle, const char* yTitle, const char* zTitle)
838 {
839  T* tmpHist = new T(name, title, xBins, xMin, xMax, yBins, yMin, yMax);
840  tmpHist->GetXaxis()->SetTitle(xTitle);
841  tmpHist->GetYaxis()->SetTitle(yTitle);
842  tmpHist->GetZaxis()->SetTitle(zTitle);
843  tmpHist->SetOption(options);
844  tmpHist->SetMarkerStyle(kFullCircle);
845  tmpHist->Sumw2();
846 
847  fOutput->Add(tmpHist);
848 
849  return tmpHist;
850 }
851 
852 //________________________________________________________________________
853 template <class T> T* AliAnalysisTaskChargedJetsHadronCF::AddHistogram3D(const char* name, const char* title, const char* options, Int_t xBins, Double_t xMin, Double_t xMax, Int_t yBins, Double_t yMin, Double_t yMax, Int_t zBins, Double_t zMin, Double_t zMax, const char* xTitle, const char* yTitle, const char* zTitle)
854 {
855  T* tmpHist = new T(name, title, xBins, xMin, xMax, yBins, yMin, yMax, zBins, zMin, zMax);
856  tmpHist->GetXaxis()->SetTitle(xTitle);
857  tmpHist->GetYaxis()->SetTitle(yTitle);
858  tmpHist->GetZaxis()->SetTitle(zTitle);
859  tmpHist->SetOption(options);
860  tmpHist->SetMarkerStyle(kFullCircle);
861  tmpHist->Sumw2();
862 
863  fOutput->Add(tmpHist);
864 
865  return tmpHist;
866 }
867 
868 //________________________________________________________________________
870 {
871  // Called once at the end of the analysis.
872 }
873 
Short_t Charge() const
Definition: AliEmcalJet.h:107
Double_t fEventCriteriumMinSubleadingJetPt
Min subleading jet.
Double_t Area() const
Definition: AliEmcalJet.h:114
Double_t fEventCriteriumMinBackground
Minimum background.
Double_t GetRhoVal() const
Double_t GetJetEtaMin() const
T * AddHistogram1D(const char *name="CustomHistogram", const char *title="NO_TITLE", const char *options="", Int_t xBins=100, Double_t xMin=0.0, Double_t xMax=20.0, const char *xTitle="x axis", const char *yTitle="y axis")
const char * title
Definition: MakeQAPdf.C:26
void GetLeadingJets(const char *opt, AliEmcalJet *&jetLeading, AliEmcalJet *&jetSubLeading)
TString fJetMatchingArrayName
Name of array used to match jets.
AliEmcalJet * fMatchedJet
! jet matched to input jet (calculated event-by-event)
AliJetContainer * GetJetContainer(Int_t i=0) const
Double_t Eta() const
Definition: AliEmcalJet.h:105
Double_t Phi() const
Definition: AliEmcalJet.h:101
void * fJetsTreeBuffer
! buffer for one jet (that will be saved to the tree)
Container with name, TClonesArray and cuts for particles.
Support task for (charged) jet-hadron correlations.
Double_t GetJetEtaMax() const
virtual Bool_t AcceptJet(Int_t i, UInt_t &rejectionReason) const
void BinLogAxis(const THn *h, Int_t axisNumber)
Int_t fJetOutputMode
mode which jets are written to array (0: all accepted, 1: leading, 2: subleading, 3: leading+subleadi...
Simple class containing basic information for a constituent.
AliEmcalJet * fSubleadingJet
! subleading jet (calculated event-by-event)
Simple class containing basic information for a jet.
void FillHistogram3D(const char *key, Double_t x, Double_t y, Double_t z, Double_t add=0)
Double_t GetJetRadius(Int_t i=0) const
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:123
Double_t fEventCriteriumMinJetDeltaPhi
Min jet delta phi in dijet criterium.
AliParticleContainer * GetParticleContainer(Int_t i=0) const
AliParticleContainer * GetParticleContainer() const
Double_t fEventCriteriumMaxBackground
Maximum background.
TString fJetParticleArrayName
Name of fJetsOutput array.
Double_t GetLeadingHadronPt(const AliEmcalJet *jet) const
T * AddHistogram3D(const char *name="CustomHistogram", const char *title="NO_TITLE", const char *options="", Int_t xBins=100, Double_t xMin=0.0, Double_t xMax=20.0, Int_t yBins=100, Double_t yMin=0.0, Double_t yMax=20.0, Int_t zBins=100, Double_t zMin=0.0, Double_t zMax=20.0, const char *xTitle="x axis", const char *yTitle="y axis", const char *zTitle="z axis")
Int_t fNumberOfCentralityBins
Number of centrality bins.
virtual AliVParticle * GetLeadingParticle(const char *opt="")
Double_t fExtractionPercentage
percentage that is recorded
Double_t fCent
!event centrality
TClonesArray * fJetsOutput
! Array of basic correlation particles attached to the event (jets)
TString fTrackParticleArrayName
Name of fTracksOutput array.
TClonesArray * fTracksOutput
! Array of basic correlation particles attached to the event (tracks)
AliEmcalJet * fLeadingJet
! leading jet (calculated event-by-event)
Double_t fExtractionMinPt
minimum pt of recorded jets
AliEmcalJet * GetNextAcceptJet()
TTree * fJetsTree
! Jets that will be saved to a tree (optionally)
Double_t Pt() const
Definition: AliEmcalJet.h:93
Bool_t IsTrackInCone(AliVParticle *track, Double_t eta, Double_t phi, Double_t radius)
void AddJetConstituent(Float_t eta, Float_t phi, Float_t pt, Short_t charge)
Float_t GetJetRadius() const
AliEmcalList * fOutput
!output list
Short_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:144
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
TClonesArray * fJetsInput
! Array of generated jets imported into task (toy model)
TH1 * fHistEventRejection
!book keep reasons for rejecting event
void SetMakeGeneralHistograms(Bool_t g)
Base task in the EMCAL jet framework.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
Double_t fExtractionMaxPt
maximum pt of recorded jets
virtual AliVParticle * GetNextAcceptParticle()
Int_t fAcceptedJets
! number accepted jets (calculated event-by-event)
T * AddHistogram2D(const char *name="CustomHistogram", const char *title="NO_TITLE", const char *options="", Int_t xBins=100, Double_t xMin=0.0, Double_t xMax=20.0, Int_t yBins=100, Double_t yMin=0.0, Double_t yMax=20.0, const char *xTitle="x axis", const char *yTitle="y axis", const char *zTitle="z axis")
Int_t fAcceptedTracks
! number accepted tracks (calculated event-by-event)