AliPhysics  63d3444 (63d3444)
 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 <algorithm>
17 #include <vector>
18 #include <TClonesArray.h>
19 #include <TF1.h>
20 #include <TH1F.h>
21 #include <TH2F.h>
22 #include <TH3F.h>
23 #include <THn.h>
24 #include <TTree.h>
25 #include <TList.h>
26 #include <TLorentzVector.h>
27 
28 #include "AliEmcalPythiaInfo.h"
29 
30 #include "AliVTrack.h"
31 #include "AliVHeader.h"
32 #include "AliEmcalJet.h"
33 #include "AliRhoParameter.h"
34 #include "AliLog.h"
35 #include "AliJetContainer.h"
36 #include "AliTrackContainer.h"
37 #include "AliAODTrack.h"
38 #include "AliPicoTrack.h"
39 #include "AliVParticle.h"
40 #include "TRandom3.h"
42 
44 
48 //________________________________________________________________________
50 {
51 // dummy destructor
52 }
53 
57 //________________________________________________________________________
59 {
60 // dummy destructor
61 }
62 
66 //________________________________________________________________________
69  fJetsCont(0),
70  fTracksCont(0),
71  fJetsTree(0),
72  fJetsTreeBuffer(0),
73  fExtractionPercentage(0),
74  fExtractionMinPt(0),
75  fExtractionMaxPt(0),
76  fEventExtractionPercentage(0),
77  fEventExtractionMinJetPt(0),
78  fEventExtractionMaxJetPt(0),
79  fNumberOfCentralityBins(10),
80  fJetsOutput(),
81  fTracksOutput(),
82  fJetParticleArrayName("JetsDPhiBasicParticles"),
83  fTrackParticleArrayName(""),
84  fJetMatchingArray(),
85  fJetMatchingArrayName(""),
86  fJetMatchingMaxDistance(0.3),
87  fJetMatchingMinSharedFraction(0.5),
88  fJetMatchingMaxSharedFraction(1.5),
89  fJetMatchingMaxEmbeddingOffset(20.),
90  fJetMatchingMinPt(0.0),
91  fJetMatchingMaxPt(999.0),
92  fJetMatchingUseOnlyNLeading(0),
93  fJetVetoArray(),
94  fJetVetoArrayName(""),
95  fJetVetoMinPt(0),
96  fJetVetoMaxPt(0),
97  fMatchedJets(),
98  fRandom(0),
99  fJetOutputMode(0),
100  fMinFakeFactorPercentage(0),
101  fMaxFakeFactorPercentage(0),
102  fPythiaExtractionMode(0),
103  fEventCriteriumMode(0),
104  fEventCriteriumMinBackground(0),
105  fEventCriteriumMaxBackground(0),
106  fEventCriteriumMinLeadingJetPt(0),
107  fEventCriteriumMinSubleadingJetPt(0),
108  fEventCriteriumMinJetDeltaPhi(0),
109  fLeadingJet(0),
110  fSubleadingJet(0),
111  fInitialPartonMatchedJet1(0),
112  fInitialPartonMatchedJet2(0),
113  fAcceptedJets(0),
114  fAcceptedTracks(0)
115 {
116  // Default constructor.
117  SetMakeGeneralHistograms(kTRUE);
118  fRandom = new TRandom3(0);
119 }
120 
121 
122 //________________________________________________________________________
124  AliAnalysisTaskEmcalJet(name, kTRUE),
125  fJetsCont(0),
126  fTracksCont(0),
127  fJetsTree(0),
128  fJetsTreeBuffer(0),
129  fExtractionPercentage(0),
130  fExtractionMinPt(0),
131  fExtractionMaxPt(0),
132  fEventExtractionPercentage(0),
133  fEventExtractionMinJetPt(0),
134  fEventExtractionMaxJetPt(0),
135  fNumberOfCentralityBins(10),
136  fJetsOutput(),
137  fTracksOutput(),
138  fJetParticleArrayName("JetsDPhiBasicParticles"),
139  fTrackParticleArrayName(""),
140  fJetMatchingArray(),
141  fJetMatchingArrayName(""),
142  fJetMatchingMaxDistance(0.3),
143  fJetMatchingMinSharedFraction(0.5),
144  fJetMatchingMaxSharedFraction(1.5),
145  fJetMatchingMaxEmbeddingOffset(20.),
146  fJetMatchingMinPt(0.0),
147  fJetMatchingMaxPt(999.0),
148  fJetMatchingUseOnlyNLeading(0),
149  fJetVetoArray(),
150  fJetVetoArrayName(""),
151  fJetVetoMinPt(0),
152  fJetVetoMaxPt(0),
153  fMatchedJets(),
154  fRandom(0),
155  fJetOutputMode(0),
156  fMinFakeFactorPercentage(0),
157  fMaxFakeFactorPercentage(0),
158  fPythiaExtractionMode(0),
159  fEventCriteriumMode(0),
160  fEventCriteriumMinBackground(0),
161  fEventCriteriumMaxBackground(0),
162  fEventCriteriumMinLeadingJetPt(0),
163  fEventCriteriumMinSubleadingJetPt(0),
164  fEventCriteriumMinJetDeltaPhi(0),
165  fLeadingJet(0),
166  fSubleadingJet(0),
167  fInitialPartonMatchedJet1(0),
168  fInitialPartonMatchedJet2(0),
169  fAcceptedJets(0),
170  fAcceptedTracks(0)
171 {
172  // Constructor
174  fRandom = new TRandom3(0);
175 }
176 
177 //________________________________________________________________________
179 {
180  // Destructor.
181 }
182 
183 //________________________________________________________________________
185 {
187 
188  // ### Basic container settings
190  if(fJetsCont) { //get particles connected to jets
191  fJetsCont->PrintCuts();
193  } else { //no jets, just analysis tracks
195  }
196  if(fTracksCont) fTracksCont->SetClassName("AliVTrack");
197 
198  // ### Create all histograms
199 
200  // Change the event rejection histogram -> Add a custom value
201  fHistEventRejection->GetXaxis()->SetBinLabel(14,"JetCrit");
202 
203  // Track QA plots
204  AddHistogram2D<TH2D>("hTrackPt", "Tracks p_{T} distribution", "", 300, 0., 300., fNumberOfCentralityBins, 0, 100, "p_{T} (GeV/c)", "Centrality", "dN^{Tracks}/dp_{T}");
205  AddHistogram2D<TH2D>("hTrackPhi", "Track angular distribution in #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Tracks}/(d#phi)");
206  AddHistogram2D<TH2D>("hTrackEta", "Track angular distribution in #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta", "Centrality", "dN^{Tracks}/(d#eta)");
207  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");
208 
209  AddHistogram2D<TH2D>("hLeadingTrackPt", "Leading tracks p_{T} distribution", "", 300, 0., 300., fNumberOfCentralityBins, 0, 100, "p_{T} (GeV/c)", "Centrality", "dN^{Tracks}/dp_{T}");
210  AddHistogram2D<TH2D>("hLeadingTrackPhi", "Leading tracks angular distribution in #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Tracks}/(d#phi)");
211  AddHistogram2D<TH2D>("hLeadingTrackEta", "Leading tracks angular distribution in #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta", "Centrality", "dN^{Tracks}/(d#eta)");
212  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");
213 
214  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})");
215  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})");
216 
217 
218  // Jet QA plots
219  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}");
220  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}");
221  AddHistogram2D<TH2D>("hJetPhi", "Jet angular distribution #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Jets}/d#phi");
222  AddHistogram2D<TH2D>("hJetEta", "Jet angular distribution #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta","Centrality","dN^{Jets}/d#eta");
223  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}");
224  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}");
225  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");
226  AddHistogram2D<TH2D>("hJetArea", "Jet area", "LEGO2", 200, 0., 2., fNumberOfCentralityBins, 0, 100, "Jet A", "Centrality", "dN^{Jets}/dA");
227  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}");
228  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}");
229 
230  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}");
231  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}");
232 
233  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}");
234  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}");
235 
236  // Embedding plots
237  if(fJetOutputMode == 4 || fJetOutputMode == 5)
238  {
239  AddHistogram2D<TH2D>("hEmbeddingDeltaR", "Matched jet #Delta R distribution", "", 200, -50., 150., 100, 0, 1.0, "p_{T, jet} (GeV/c)", "#Delta R", "dN^{Matched}/dp_{T}dR");
240  AddHistogram2D<TH2D>("hEmbeddingDeltaEta", "Matched jet #Delta #eta distribution", "", 200, -50., 150., 100, -1.0, 1.0, "p_{T, jet} (GeV/c)", "#Delta #eta", "dN^{Matched}/dp_{T}d#eta");
241  AddHistogram2D<TH2D>("hEmbeddingDeltaPhi", "Matched jet #Delta #phi distribution", "", 200, -50., 150., 100, -1.0, 1.0, "p_{T, jet} (GeV/c)", "#Delta #phi", "dN^{Matched}/dp_{T}d#phi");
242  AddHistogram2D<TH2D>("hEmbeddingPtCorr", "Matched jet p_{T} distributions", "", 200, -50., 150., 200, -50., 150., "p_{T, MC jet} (GeV/c)", "p_{T, emb} (GeV/c)", "dN^{Matched}/dp_{T}d#Delta p_{T}");
243  AddHistogram2D<TH2D>("hEmbeddingPtCorr010", "Matched jet p_{T} distributions (0-10%% centrality)", "", 200, -50., 150., 200, -50., 150., "p_{T, MC jet} (GeV/c)", "p_{T, emb} (GeV/c)", "dN^{Matched}/dp_{T}d#Delta p_{T}");
244  AddHistogram2D<TH2D>("hEmbeddingPtCorr1030", "Matched jet p_{T} distributions (10-30%% centrality)", "", 200, -50., 150., 200, -50., 150., "p_{T, MC jet} (GeV/c)", "p_{T, emb} (GeV/c)", "dN^{Matched}/dp_{T}d#Delta p_{T}");
245  AddHistogram2D<TH2D>("hEmbeddingPtCorr3050", "Matched jet p_{T} distributions (30-50%% centrality)", "", 200, -50., 150., 200, -50., 150., "p_{T, MC jet} (GeV/c)", "p_{T, emb} (GeV/c)", "dN^{Matched}/dp_{T}d#Delta p_{T}");
246  AddHistogram2D<TH2D>("hEmbeddingPtCorr5090", "Matched jet p_{T} distributions (50-90%% centrality)", "", 200, -50., 150., 200, -50., 150., "p_{T, MC jet} (GeV/c)", "p_{T, emb} (GeV/c)", "dN^{Matched}/dp_{T}d#Delta p_{T}");
247 
248  AddHistogram1D<TH1D>("hEmbeddingJetPt", "Embedded jets p_{T} distribution", "", 200, -50., 150., "p_{T, jet} (GeV/c)", "dN/dp_{T}");
249  AddHistogram2D<TH2D>("hEmbeddingJetPhiEta", "Embedded jet angular distribution #phi/#eta", "COLZ", 180, 0., 2*TMath::Pi(), 100, -2.5, 2.5, "#phi", "#eta", "dN^{Jets}/d#phi d#eta");
250  }
251 
252  // Random cone plots
253  AddHistogram2D<TH2D>("hRandomConePt", "Random cone p_{T} distribution", "", 400, -100., 300., fNumberOfCentralityBins, 0, 100, "p_{T, cone} (GeV/c)", "Centrality", "dN^{Tracks}/dp_{T}");
254  AddHistogram2D<TH2D>("hRandomConePtCut3GeV", "Random cone p_{T} distribution, cut p_{T} > 3 GeV/c", "", 400, -100., 300., fNumberOfCentralityBins, 0, 100, "p_{T, cone} (GeV/c)", "Centrality", "dN^{Tracks}/dp_{T}");
255  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}");
256  AddHistogram2D<TH2D>("hRandomConeRawPtCut3GeV", "Random cone p_{T} distribution (no bgrd. correction), cut p_{T} > 3 GeV/c", "", 300, 0., 300., fNumberOfCentralityBins, 0, 100, "p_{T, cone} (GeV/c)", "Centrality", "dN^{Tracks}/dp_{T}");
257 
258  // Leading/subleading, background ...
259 
260  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}");
261  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}");
262  AddHistogram2D<TH2D>("hLeadingJetPhi", "Jet angular distribution #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Jets}/d#phi");
263  AddHistogram2D<TH2D>("hLeadingJetEta", "Jet angular distribution #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta","Centrality","dN^{Jets}/d#eta");
264  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}");
265  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}");
266  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");
267  AddHistogram2D<TH2D>("hLeadingJetArea", "Jet area", "LEGO2", 200, 0., 2., fNumberOfCentralityBins, 0, 100, "Jet A", "Centrality", "dN^{Jets}/dA");
268  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}");
269  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}");
270 
271  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}");
272  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}");
273  AddHistogram2D<TH2D>("hSubleadingJetPhi", "Jet angular distribution #phi", "LEGO2", 180, 0., 2*TMath::Pi(), fNumberOfCentralityBins, 0, 100, "#phi", "Centrality", "dN^{Jets}/d#phi");
274  AddHistogram2D<TH2D>("hSubleadingJetEta", "Jet angular distribution #eta", "LEGO2", 100, -2.5, 2.5, fNumberOfCentralityBins, 0, 100, "#eta","Centrality","dN^{Jets}/d#eta");
275  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}");
276  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}");
277  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");
278  AddHistogram2D<TH2D>("hSubleadingJetArea", "Jet area", "LEGO2", 200, 0., 2., fNumberOfCentralityBins, 0, 100, "Jet A", "Centrality", "dN^{Jets}/dA");
279  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}");
280  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}");
281 
282  AddHistogram2D<TH2D>("hTrackCount", "Number of tracks in acceptance vs. centrality", "LEGO2", 500, 0., 5000., fNumberOfCentralityBins, 0, 100, "N tracks","Centrality", "dN^{Events}/dN^{Tracks}");
283  AddHistogram2D<TH2D>("hJetCount", "Number of jets in acceptance vs. centrality", "LEGO2", 100, 0., 100., fNumberOfCentralityBins, 0, 100, "N Jets","Centrality", "dN^{Events}/dN^{Jets}");
284  AddHistogram2D<TH2D>("hFakeFactor", "Fake factor distribution", "LEGO2", 1000, 0., 100., fNumberOfCentralityBins, 0, 100, "Fake factor","Centrality", "dN^{Jets}/df");
285  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");
286  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");
287 
288  AddHistogram2D<TH2D>("hBackgroundPt", "Background p_{T} distribution", "", 150, 0., 150., fNumberOfCentralityBins, 0, 100, "Background p_{T} (GeV/c)", "Centrality", "dN^{Events}/dp_{T}");
289  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}");
290  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}");
291  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}");
292  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}");
293 
294  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
295 }
296 
297 
298 //________________________________________________________________________
300 
302 
303  // ### Add the jets as basic correlation particles to the event
304  if (!(fInputEvent->FindListObject(Form("%s", fJetParticleArrayName.Data()))))
305  {
306  fJetsOutput = new TClonesArray("AliPicoTrack");
307  fJetsOutput->SetName(fJetParticleArrayName.Data());
308  fInputEvent->AddObject(fJetsOutput);
309  }
310  else
311  AliError(Form("%s: Object with name %s already in event!", GetName(), Form("%s", fJetParticleArrayName.Data())));
312 
313  // ### Add the tracks as basic correlation particles to the event (optional)
314  if(fTrackParticleArrayName != "")
315  {
316  if (!(fInputEvent->FindListObject(Form("%s", fTrackParticleArrayName.Data()))))
317  {
318  fTracksOutput = new TClonesArray("AliPicoTrack");
319  fTracksOutput->SetName(fTrackParticleArrayName.Data());
320  fInputEvent->AddObject(fTracksOutput);
321  }
322  else
323  AliError(Form("%s: Object with name %s already in event!", GetName(), Form("%s", fTrackParticleArrayName.Data())));
324  }
325 
326  // ### Import generated jets from toymodel for matching (optional)
327  if(fJetMatchingArrayName != "")
328  {
329  fJetMatchingArray = static_cast<TClonesArray*>(InputEvent()->FindListObject(Form("%s", fJetMatchingArrayName.Data())));
330  if(!fJetMatchingArray)
331  AliFatal(Form("Importing jets for matching failed! Array '%s' not found!", fJetMatchingArrayName.Data()));
332  }
333  else if(fJetOutputMode==4 || fJetOutputMode==5)
334  AliFatal(Form("fJetMatchingArrayName must be set in jet output mode 4 or 5."));
335 
336  // ### Import veto jets for matching (optional)
337  if(fJetVetoArrayName != "")
338  {
339  fJetVetoArray = static_cast<TClonesArray*>(InputEvent()->FindListObject(Form("%s", fJetVetoArrayName.Data())));
340  if(!fJetVetoArray)
341  AliFatal(Form("Importing jets for veto failed! Array '%s' not found!", fJetVetoArrayName.Data()));
342  }
343 
344  // ### Jets tree (optional)
346  {
347  fJetsTree = new TTree("ExtractedJets", "ExtractedJets");
348  fJetsTree->Branch("Jets", "AliBasicJet", &fJetsTreeBuffer, 1000);
349  fOutput->Add(fJetsTree);
350  }
351 
352 
353 }
354 
355 //________________________________________________________________________
357 {
358 
359  // In case of special selection criteria, trigger on certain events
360  if(fEventCriteriumMode==0) // "minimum bias"
361  {
362  // do nothing
363  }
364  else if(fEventCriteriumMode==1) // background constraints
365  {
367  {
368  fHistEventRejection->Fill("JetCrit", 1);
369  return kFALSE;
370  }
371  }
372  else if(fEventCriteriumMode==2) // Minimum leading jet pT
373  {
374  if(fLeadingJet)
375  {
377  {
378  fHistEventRejection->Fill("JetCrit", 1);
379  return kFALSE;
380  }
381  }
382  }
383  else if(fEventCriteriumMode==3) // Simple dijet trigger
384  {
386  {
389  {
390  fHistEventRejection->Fill("JetCrit", 1);
391  return kFALSE;
392  }
393  else // dijet pT fulfilled, check back-to-back criterium
394  {
395  Double_t deltaPhi = TMath::Min(TMath::Abs(fLeadingJet->Phi()-fSubleadingJet->Phi()),TMath::TwoPi() - TMath::Abs(fLeadingJet->Phi()-fSubleadingJet->Phi()));
396  if(deltaPhi <= fEventCriteriumMinJetDeltaPhi)
397  {
398  fHistEventRejection->Fill("JetCrit", 1);
399  return kFALSE;
400  }
401  }
402  }
403  }
404  return kTRUE;
405 }
406 
407 //________________________________________________________________________
409 {
410  if(fJetOutputMode==3) // output leading&subleading jet
411  {
412  if((jet!=fLeadingJet) && (jet!=fSubleadingJet))
413  return kFALSE;
414  }
415  else if(fJetOutputMode==1) // output the leading jet
416  {
417  if(jet!=fLeadingJet)
418  return kFALSE;
419  }
420  else if(fJetOutputMode==2) // output the subleading jet
421  {
422  if(jet!=fSubleadingJet)
423  return kFALSE;
424  }
425  else if(fJetOutputMode==6)
426  {
428  return kFALSE;
429  }
430 
431  if(fJetOutputMode==4) // matching jets only
432  return (std::find(fMatchedJets.begin(), fMatchedJets.end(), jet) != fMatchedJets.end());
433  else if(fJetOutputMode==5) // non-matching jets only
434  return (std::find(fMatchedJets.begin(), fMatchedJets.end(), jet) == fMatchedJets.end());
435 
436  return kTRUE;
437 }
438 
439 //________________________________________________________________________
441 {
442  // All jets
443  FillHistogram("hJetPtRaw", jet->Pt(), fCent);
444  FillHistogram("hJetPt", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fCent);
445  FillHistogram("hJetPhi", jet->Phi(), fCent);
446  FillHistogram("hJetEta", jet->Eta(), fCent);
447  FillHistogram("hJetEtaPt", jet->Eta(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
448  FillHistogram("hJetPhiPt", jet->Phi(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
449  FillHistogram("hJetPhiEta", jet->Phi(), jet->Eta());
450  FillHistogram("hJetArea", jet->Area(), fCent);
451  FillHistogram("hJetAreaPt", jet->Area(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
452  FillHistogram("hJetPtLeadingHadron", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fJetsCont->GetLeadingHadronPt(jet));
453 
454  FillHistogram("hBackgroundPtJetPt_Cent0_100", fJetsCont->GetRhoVal(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
455  if( (fCent >= 0) && (fCent < 10) )
456  FillHistogram("hBackgroundPtJetPt_Cent0_10", fJetsCont->GetRhoVal(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
457 
458  // Fake jet rejection (0810.1219)
459  Double_t fakeFactor = CalculateFakeFactor(jet);
460  FillHistogram("hFakeFactor", fakeFactor, fCent);
461  FillHistogram("hFakeFactorJetPt_Cent0_100", fakeFactor, jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
462  if( (fCent >= 0) && (fCent < 10) )
463  FillHistogram("hFakeFactorJetPt_Cent0_10", fakeFactor, jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
464 
465 
466  // Leading jet plots
467  if(jet==fLeadingJet)
468  {
469  FillHistogram("hLeadingJetPtRaw", jet->Pt(), fCent);
470  FillHistogram("hLeadingJetPt", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fCent);
471  FillHistogram("hLeadingJetPhi", jet->Phi(), fCent);
472  FillHistogram("hLeadingJetEta", jet->Eta(), fCent);
473  FillHistogram("hLeadingJetEtaPt", jet->Eta(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
474  FillHistogram("hLeadingJetPhiPt", jet->Phi(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
475  FillHistogram("hLeadingJetPhiEta", jet->Phi(), jet->Eta());
476  FillHistogram("hLeadingJetArea", jet->Area(), fCent);
477  FillHistogram("hLeadingJetAreaPt", jet->Area(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
478  FillHistogram("hLeadingJetPtLeadingHadron", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fJetsCont->GetLeadingHadronPt(jet));
479  }
480 
481  // Subleading jet plot
482  else if(jet==fSubleadingJet)
483  {
484  FillHistogram("hSubleadingJetPtRaw", jet->Pt(), fCent);
485  FillHistogram("hSubleadingJetPt", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fCent);
486  FillHistogram("hSubleadingJetPhi", jet->Phi(), fCent);
487  FillHistogram("hSubleadingJetEta", jet->Eta(), fCent);
488  FillHistogram("hSubleadingJetEtaPt", jet->Eta(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
489  FillHistogram("hSubleadingJetPhiPt", jet->Phi(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
490  FillHistogram("hSubleadingJetPhiEta", jet->Phi(), jet->Eta());
491  FillHistogram("hSubleadingJetArea", jet->Area(), fCent);
492  FillHistogram("hSubleadingJetAreaPt", jet->Area(), jet->Pt() - fJetsCont->GetRhoVal()*jet->Area());
493  FillHistogram("hSubleadingJetPtLeadingHadron", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), fJetsCont->GetLeadingHadronPt(jet));
494  }
495 }
496 
497 //________________________________________________________________________
499 {
500  FillHistogram("hTrackPt", track->Pt(), fCent);
501  FillHistogram("hTrackPhi", track->Phi(), fCent);
502  FillHistogram("hTrackEta", track->Eta(), fCent);
503  FillHistogram("hTrackEtaPt", track->Eta(), track->Pt());
504  FillHistogram("hTrackPhiPt", track->Phi(), track->Pt());
505  FillHistogram("hTrackPhiEta", track->Phi(), track->Eta());
506 }
507 
508 //________________________________________________________________________
510 {
511  // Loop over all jet constituents
512  for(Int_t i = 0; i < jet->GetNumberOfTracks(); i++)
513  {
514  AliVParticle* constituent = static_cast<AliVParticle*>(jet->TrackAt(i, fTracksCont->GetArray()));
515  if(!constituent)
516  continue;
517 
518  // Fill jet constituent plots
519  FillHistogram("hJetConstituentPt_Cent0_100", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), constituent->Pt());
520  if( (fCent >= 0) && (fCent < 10) )
521  FillHistogram("hJetConstituentPt_Cent0_10", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), constituent->Pt());
522 
523  }
524 
525  FillHistogram("hJetConstituentCount_Cent0_100", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), jet->GetNumberOfTracks());
526  if( (fCent >= 0) && (fCent < 10) )
527  FillHistogram("hJetConstituentCount_Cent0_10", jet->Pt() - fJetsCont->GetRhoVal()*jet->Area(), jet->GetNumberOfTracks());
528 
529  FillHistogram("hBackgroundPtConstCount_Cent0_100", fJetsCont->GetRhoVal(), jet->GetNumberOfTracks());
530  if( (fCent >= 0) && (fCent < 10) )
531  FillHistogram("hBackgroundPtConstCount_Cent0_10", fJetsCont->GetRhoVal(), jet->GetNumberOfTracks());
532 }
533 
534 //________________________________________________________________________
536 {
537  Double_t tmpPt = jet->Pt() - fJetsCont->GetRhoVal()*jet->Area();
538  new ((*fJetsOutput)[fAcceptedJets]) AliPicoTrack(tmpPt, jet->Eta(), jet->Phi(), jet->Charge(), 0, 0);
539  fAcceptedJets++;
540 }
541 
542 //________________________________________________________________________
544 {
545  if(fTrackParticleArrayName != "")
546  {
547  new ((*fTracksOutput)[fAcceptedTracks]) AliPicoTrack(track->Pt(), track->Eta(), track->Phi(), track->Charge(), 0, 0); // only Pt,Eta,Phi are interesting for correlations;
548  fAcceptedTracks++;
549  }
550 }
551 
552 //________________________________________________________________________
554 {
555  // Check pT threshold
556  if( ((jet->Pt()-jet->Area()*fJetsCont->GetRhoVal()) < fExtractionMinPt) || ((jet->Pt()-jet->Area()*fJetsCont->GetRhoVal()) >= fExtractionMaxPt) )
557  return;
558 
559  // Discard jets statistically
560  if(fRandom->Rndm() >= fExtractionPercentage)
561  return;
562 
563  AliVHeader* eventIDHeader = InputEvent()->GetHeader();
564  Long64_t eventID = 0;
565  if(eventIDHeader)
566  eventID = eventIDHeader->GetEventIdAsLong();
567 
568  // if only the two initial collision partons will be added, get PYTHIA info on them
569  Int_t partid = 0;
570  if(fJetOutputMode==6)
571  {
572  if(!fPythiaInfo)
573  AliError("fPythiaInfo object not available. Is it activated with SetGeneratePythiaInfoObject()?");
574  else if(jet==fInitialPartonMatchedJet1)
575  partid = fPythiaInfo->GetPartonFlag6();
576  else if (jet==fInitialPartonMatchedJet2)
577  partid = fPythiaInfo->GetPartonFlag7();
578 
579  // If fPythiaExtractionMode is set, only extract certain jets
580  if( (fPythiaExtractionMode==1) && not (partid>=1 && partid<=6)) // all quark-jet extraction
581  return;
582  else if( (fPythiaExtractionMode==2) && not (partid==21)) // gluon-jet extraction
583  return;
584  else if( (fPythiaExtractionMode<0) && (fPythiaExtractionMode!=-partid) ) // custom type jet extraction by given a negative number
585  return;
586  }
587 
588  AliBasicJet basicJet(jet->Eta(), jet->Phi(), jet->Pt(), jet->Charge(), fJetsCont->GetJetRadius(), jet->Area(), partid, fJetsCont->GetRhoVal(), eventID, fCent);
589  // Add constituents
590  for(Int_t i = 0; i < jet->GetNumberOfTracks(); i++)
591  {
592  AliVParticle* particle = static_cast<AliVParticle*>(jet->TrackAt(i, fTracksCont->GetArray()));
593  if(!particle) continue;
594 
595  AliAODTrack* aodtrack = static_cast<AliAODTrack*>(jet->TrackAt(i, fTracksCont->GetArray()));
596  Int_t constid = 9; // 9 mean unknown
597  if(fJetOutputMode==6)
598  {
599  // Use same convention as PID in AODs
600  if(TMath::Abs(particle->PdgCode()) == 2212) // proton
601  constid = 4;
602  else if (TMath::Abs(particle->PdgCode()) == 211) // pion
603  constid = 2;
604  else if (TMath::Abs(particle->PdgCode()) == 321) // kaon
605  constid = 3;
606  else if (TMath::Abs(particle->PdgCode()) == 11) // electron
607  constid = 0;
608  else if (TMath::Abs(particle->PdgCode()) == 13) // muon
609  constid = 1;
610  }
611  else if (aodtrack)
612  constid = aodtrack->GetMostProbablePID();
613 
614  basicJet.AddJetConstituent(particle->Eta(), particle->Phi(), particle->Pt(), particle->Charge(), constid);
615  }
616  if(std::find(fMatchedJets.begin(), fMatchedJets.end(), jet) != fMatchedJets.end()) // set the true pT from the matched jets (only possible in modes 4 & 7)
617  basicJet.SetTruePt(fMatchedJetsReference[std::find(fMatchedJets.begin(), fMatchedJets.end(), jet)-fMatchedJets.begin()]->Pt());
618 
619  fJetsTreeBuffer = &basicJet;
620  fJetsTree->Fill();
621 }
622 
623 //________________________________________________________________________
625 {
626  // Check jet pT threshold
628  return;
629 
630  // Discard jets statistically
631  if(fRandom->Rndm() >= fEventExtractionPercentage)
632  return;
633 
634  static Int_t numSavedEvents = 0;
635  numSavedEvents++;
636 
637 
638  AddHistogram2D<TH2D>(Form("Event%i", numSavedEvents), "Event display", "COLZ", 180, 0., 2*TMath::Pi(), 100, -2.5, 2.5, "#phi", "#eta", "dN^{Tracks}/d#phi d#eta");
639  fTracksCont->ResetCurrentID();
640  while(AliVTrack *track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle()))
641  FillHistogram(Form("Event%i", numSavedEvents), track->Phi(), track->Eta(), track->Pt());
642 
643 }
644 
645 //________________________________________________________________________
647 {
649 
651  return kFALSE;
652 
653  // ####### Jet loop
654  fAcceptedJets = 0;
655  fJetsCont->ResetCurrentID();
656  while(AliEmcalJet *jet = fJetsCont->GetNextAcceptJet())
657  {
658  if(!IsJetSelected(jet))
659  continue;
660 
661  // Jet plots
662  FillHistogramsJets(jet);
664 
665  // Add jet to output array
667  AddJetToTree(jet);
668  AddJetToOutputArray(jet);
669  }
670 
671  // ####### Particle loop
672  // Throw random cone
673  Double_t tmpRandConeEta = fJetsCont->GetJetEtaMin() + fRandom->Rndm()*TMath::Abs(fJetsCont->GetJetEtaMax()-fJetsCont->GetJetEtaMin());
674  Double_t tmpRandConePhi = fRandom->Rndm()*TMath::TwoPi();
675  Double_t tmpRandConePt = 0; // to be determined
676  Double_t tmpRandConePt3GeV = 0; // to be determined
677 
678  fAcceptedTracks = 0;
679  fTracksCont->ResetCurrentID();
680  Int_t trackcount = 0;
681  while(AliVTrack *track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle()))
682  {
683  // Track plots
684  FillHistogramsTracks(track);
685 
686  if(IsTrackInCone(track, tmpRandConeEta, tmpRandConePhi, fJetsCont->GetJetRadius()))
687  {
688  tmpRandConePt += track->Pt();
689  if (track->Pt() > 3.0)
690  tmpRandConePt3GeV += track->Pt();
691  }
692 
693  // Add track to output array
694  trackcount++;
695  AddTrackToOutputArray(track);
696  }
697 
698  // ####### Embedding plots
699  if( (fJetOutputMode == 4) || (fJetOutputMode == 5))
700  {
701  for(Int_t i=0; i<fMatchedJets.size(); i++)
702  {
703  Double_t deltaEta = (fMatchedJets[i]->Eta()-fMatchedJetsReference[i]->Eta());
704  Double_t deltaPhi = TMath::Min(TMath::Abs(fMatchedJets[i]->Phi()-fMatchedJetsReference[i]->Phi()),TMath::TwoPi() - TMath::Abs(fMatchedJets[i]->Phi()-fMatchedJetsReference[i]->Phi()));
705  if(fMatchedJets[i]->Phi() < fMatchedJetsReference[i]->Phi())
706  deltaPhi = -deltaPhi;
707 
708  Double_t deltaR = TMath::Sqrt(deltaEta*deltaEta + deltaPhi*deltaPhi);
709 
710  FillHistogram("hEmbeddingDeltaR", fMatchedJets[i]->Pt() - fJetsCont->GetRhoVal()*fMatchedJets[i]->Area(), deltaR);
711  FillHistogram("hEmbeddingDeltaEta", fMatchedJets[i]->Pt() - fJetsCont->GetRhoVal()*fMatchedJets[i]->Area(), deltaPhi);
712  FillHistogram("hEmbeddingDeltaPhi", fMatchedJets[i]->Pt() - fJetsCont->GetRhoVal()*fMatchedJets[i]->Area(), deltaEta);
713  FillHistogram("hEmbeddingPtCorr", fMatchedJetsReference[i]->Pt(), fMatchedJets[i]->Pt() - fJetsCont->GetRhoVal()*fMatchedJets[i]->Area());
714  if(fCent >= 0 && fCent < 10)
715  FillHistogram("hEmbeddingPtCorr010", fMatchedJetsReference[i]->Pt(), fMatchedJets[i]->Pt() - fJetsCont->GetRhoVal()*fMatchedJets[i]->Area());
716  else if (fCent >= 10 && fCent < 30)
717  FillHistogram("hEmbeddingPtCorr1030", fMatchedJetsReference[i]->Pt(), fMatchedJets[i]->Pt() - fJetsCont->GetRhoVal()*fMatchedJets[i]->Area());
718  else if (fCent >= 30 && fCent < 50)
719  FillHistogram("hEmbeddingPtCorr3050", fMatchedJetsReference[i]->Pt(), fMatchedJets[i]->Pt() - fJetsCont->GetRhoVal()*fMatchedJets[i]->Area());
720  else if (fCent >= 50 && fCent < 90)
721  FillHistogram("hEmbeddingPtCorr5090", fMatchedJetsReference[i]->Pt(), fMatchedJets[i]->Pt() - fJetsCont->GetRhoVal()*fMatchedJets[i]->Area());
722  FillHistogram("hEmbeddingJetPt", fMatchedJetsReference[i]->Pt());
723  FillHistogram("hEmbeddingJetPhiEta", fMatchedJetsReference[i]->Phi(), fMatchedJetsReference[i]->Eta());
724  }
725  }
726 
727  // Add event to output tree
729  AddEventToTree();
730 
731  // ####### Event properties
732  FillHistogram("hRandomConePt", tmpRandConePt - fJetsCont->GetRhoVal()*fJetsCont->GetJetRadius()*fJetsCont->GetJetRadius()*TMath::Pi(), fCent);
733  FillHistogram("hRandomConePtCut3GeV", tmpRandConePt3GeV - fJetsCont->GetRhoVal()*fJetsCont->GetJetRadius()*fJetsCont->GetJetRadius()*TMath::Pi(), fCent);
734  FillHistogram("hRandomConeRawPt", tmpRandConePt, fCent);
735  FillHistogram("hRandomConeRawPtCut3GeV", tmpRandConePt3GeV, fCent);
736 
737  FillHistogram("hBackgroundPt", fJetsCont->GetRhoVal(), fCent);
738  FillHistogram("hJetCount", fAcceptedJets, fCent);
739  FillHistogram("hTrackCount", trackcount, fCent);
740  // NOTE: It is possible to use fTracksCont->GetLeadingParticle() since we do not apply additional track cuts
741  AliVTrack* leadTrack = static_cast<AliVTrack*>(fTracksCont->GetLeadingParticle());
742  if(leadTrack)
743  {
744  FillHistogram("hLeadingTrackPt", leadTrack->Pt(), fCent);
745  FillHistogram("hLeadingTrackPhi", leadTrack->Phi(), fCent);
746  FillHistogram("hLeadingTrackEta", leadTrack->Eta(), fCent);
747  FillHistogram("hLeadingTrackPhiEta", leadTrack->Phi(), leadTrack->Eta());
748  }
749 
750  return kTRUE;
751 }
752 
753 //########################################################################
754 // HELPERS
755 //########################################################################
756 
757 //________________________________________________________________________
759 {
760  if(!fPythiaInfo)
761  AliError("fPythiaInfo object not available. Is it activated with SetGeneratePythiaInfoObject()?");
762 
763  Double_t bestMatchDeltaR1 = 999.;
764  Double_t bestMatchDeltaR2 = 999.;
765 
766  fJetsCont->ResetCurrentID();
767  while(AliEmcalJet *jet = fJetsCont->GetNextAcceptJet())
768  {
769  // Check via geometrical matching if jet is connected to the initial collision
770  Double_t deltaEta1 = TMath::Abs(jet->Eta()-fPythiaInfo->GetPartonEta6());
771  Double_t deltaEta2 = TMath::Abs(jet->Eta()-fPythiaInfo->GetPartonEta7());
772  Double_t deltaPhi1 = TMath::Min(TMath::Abs(jet->Phi()-fPythiaInfo->GetPartonPhi6()),TMath::TwoPi() - TMath::Abs(jet->Phi()-fPythiaInfo->GetPartonPhi6()));
773  Double_t deltaPhi2 = TMath::Min(TMath::Abs(jet->Phi()-fPythiaInfo->GetPartonPhi7()),TMath::TwoPi() - TMath::Abs(jet->Phi()-fPythiaInfo->GetPartonPhi7()));
774 
775  Double_t deltaR1 = TMath::Sqrt(deltaEta1*deltaEta1 + deltaPhi1*deltaPhi1);
776  Double_t deltaR2 = TMath::Sqrt(deltaEta2*deltaEta2 + deltaPhi2*deltaPhi2);
777 
778  if(deltaR1 < bestMatchDeltaR1)
779  {
780  bestMatchDeltaR1 = deltaR1;
782  }
783  if(deltaR2 < bestMatchDeltaR2)
784  {
785  bestMatchDeltaR2 = deltaR2;
787  }
788  }
789 
790  if(bestMatchDeltaR1 > 0.3)
792  if(bestMatchDeltaR2 > 0.3)
794 }
795 
796 //________________________________________________________________________
798 {
799  fMatchedJets.clear();
800  fMatchedJetsReference.clear();
801 
802  // Check for a jet veto here
803  if(fJetVetoArray)
804  {
805  for(Int_t i=0; i<fJetVetoArray->GetEntries(); i++)
806  {
807  AliEmcalJet* vetoJet = static_cast<AliEmcalJet*>(fJetVetoArray->At(i));
808  UInt_t dummy = 0;
809  if(!fJetsCont->AcceptJet(vetoJet , dummy))
810  continue;
811  // if veto jet found -> return
812  if((vetoJet->Pt() - fJetsCont->GetRhoVal()*vetoJet->Area() >= fJetVetoMinPt) && (vetoJet->Pt() - fJetsCont->GetRhoVal()*vetoJet->Area() < fJetVetoMaxPt))
813  return;
814  }
815  }
816 
817  // Search for all matches above a certain threshold
818  for(Int_t i=0; i<fJetMatchingArray->GetEntries(); i++)
819  {
820  AliEmcalJet* probeJet = static_cast<AliEmcalJet*>(fJetMatchingArray->At(i));
821  UInt_t dummy = 0;
822  if(!fJetsCont->AcceptJet(probeJet , dummy))
823  continue;
824  if((probeJet->Pt() < fJetMatchingMinPt) || (probeJet->Pt() >= fJetMatchingMaxPt))
825  continue;
826 
827  AliEmcalJet* matchedJet = 0;
828  AliEmcalJet* matchedJetReference = 0;
829  Double_t bestMatchDeltaR = 999.;
830  fJetsCont->ResetCurrentID();
831  // Loop over all embedded jets to find the best match
832  while(AliEmcalJet* embeddedJet = fJetsCont->GetNextAcceptJet())
833  {
834  Double_t deltaEta = (embeddedJet->Eta()-probeJet->Eta());
835  Double_t deltaPhi = TMath::Min(TMath::Abs(embeddedJet->Phi()-probeJet->Phi()),TMath::TwoPi() - TMath::Abs(embeddedJet->Phi()-probeJet->Phi()));
836  Double_t deltaR = TMath::Sqrt(deltaEta*deltaEta + deltaPhi*deltaPhi);
837 
838  // Cut jets too far away
839  if (deltaR > fJetMatchingMaxDistance)
840  continue;
841  // Cut jets with too small pT
842  if(embeddedJet->Pt() - fJetsCont->GetRhoVal()*embeddedJet->Area() < fJetMatchingMinSharedFraction*probeJet->Pt())
843  continue;
844  // Cut jets with too high pT
845  if(embeddedJet->Pt() - fJetsCont->GetRhoVal()*embeddedJet->Area() > (fJetMatchingMaxSharedFraction*probeJet->Pt() + fJetMatchingMaxEmbeddingOffset))
846  continue;
847 
848  // Search for the best match
849  if(deltaR < bestMatchDeltaR)
850  {
851  bestMatchDeltaR = deltaR;
852  matchedJet = embeddedJet;
853  matchedJetReference = probeJet;
854  }
855  }
856  // Put matched jet to a list
857  if(matchedJet && matchedJetReference)
858  {
859  fMatchedJets.push_back(matchedJet);
860  fMatchedJetsReference.push_back(matchedJetReference);
861  }
862  }
863 
864  // ############ On demand, search for matches of leading and subleading jet in MC and delete rest
866  {
867  Int_t jetLeadingIndex = -1;
868  Int_t jetSubLeadingIndex = -1;
869  Double_t tmpLeadingPt = 0;
870  Double_t tmpSubleadingPt = 0;
871 
872  // Search leading/subleading in matched MC jets
873  for(Int_t i=0; i<fMatchedJetsReference.size(); i++)
874  {
875  AliEmcalJet* matchedJet = fMatchedJetsReference[i];
876  if (matchedJet->Pt() > tmpLeadingPt)
877  {
878  jetSubLeadingIndex = jetLeadingIndex;
879  jetLeadingIndex = i;
880  tmpSubleadingPt = tmpLeadingPt;
881  tmpLeadingPt = matchedJet->Pt();
882  }
883  else if (matchedJet->Pt() > tmpSubleadingPt)
884  {
885  jetSubLeadingIndex = i;
886  tmpSubleadingPt = matchedJet->Pt();
887  }
888  }
889 
890  AliEmcalJet* matchedLeading = 0;
891  AliEmcalJet* refLeading = 0;
892  AliEmcalJet* matchedSubLeading = 0;
893  AliEmcalJet* refSubLeading = 0;
894 
895  // Cache leading jet, if found
896  if(jetLeadingIndex >= 0)
897  {
898  matchedLeading = fMatchedJets[jetLeadingIndex];
899  refLeading = fMatchedJetsReference[jetLeadingIndex];
900  }
901  // Cache subleading jet, if found
902  if(jetSubLeadingIndex >= 0)
903  {
904  matchedSubLeading = fMatchedJets[jetSubLeadingIndex];
905  refSubLeading = fMatchedJetsReference[jetSubLeadingIndex];
906  }
907 
908  // Delete old list
909  fMatchedJets.clear();
910  fMatchedJetsReference.clear();
911 
912  // Add jets
913  if(matchedLeading)
914  {
915  fMatchedJets.push_back(matchedLeading);
916  fMatchedJetsReference.push_back(refLeading);
917  }
918  if(matchedSubLeading && fJetMatchingUseOnlyNLeading >= 2)
919  {
920  fMatchedJets.push_back(matchedSubLeading);
921  fMatchedJetsReference.push_back(refSubLeading);
922  }
923  }
924 
925 }
926 
927 //________________________________________________________________________
929 {
930  // This is to use a full cone in phi even at the edges of phi (2pi -> 0) (0 -> 2pi)
931  Double_t trackPhi = 0.0;
932  if (track->Phi() > (TMath::TwoPi() - (radius-phi)))
933  trackPhi = track->Phi() - TMath::TwoPi();
934  else if (track->Phi() < (phi+radius - TMath::TwoPi()))
935  trackPhi = track->Phi() + TMath::TwoPi();
936  else
937  trackPhi = track->Phi();
938 
939  if ( TMath::Abs(trackPhi-phi)*TMath::Abs(trackPhi-phi) + TMath::Abs(track->Eta()-eta)*TMath::Abs(track->Eta()-eta) <= radius*radius)
940  return kTRUE;
941 
942  return kFALSE;
943 }
944 
945 
946 //________________________________________________________________________
948 {
949  // Calculate leading + subleading jet
951  if(fJetOutputMode==6)
953  else if(fJetOutputMode==4 || fJetOutputMode==5)
954  GetMatchingJets();
955 }
956 
957 //________________________________________________________________________
959 {
960  Double_t fakeFactor = 0;
961 
962  // Loop over all jet constituents
963  for(Int_t i = 0; i < jet->GetNumberOfTracks(); i++)
964  {
965  AliVParticle* constituent = static_cast<AliVParticle*>(jet->TrackAt(i, fTracksCont->GetArray()));
966 
967  Double_t deltaPhi = TMath::Min(TMath::Abs(jet->Phi()-constituent->Phi()),TMath::TwoPi() - TMath::Abs(jet->Phi()-constituent->Phi()));
968  Double_t deltaR = TMath::Sqrt( (jet->Eta() - constituent->Eta())*(jet->Eta() - constituent->Eta()) + deltaPhi*deltaPhi );
969  fakeFactor += constituent->Pt() * TMath::Sin(deltaR);
970  }
971 
972  return fakeFactor;
973 }
974 
975 //________________________________________________________________________
977 {
978  fEventCriteriumMode = type;
979 
980  if(fEventCriteriumMode==0)
981  AliWarning("Set event criterium to 'default' -- no further selection criterium.");
982  else if(fEventCriteriumMode==1)
983  AliWarning("Set event criterium to 'background' -- select events with certain backgrounds");
984  else if(fEventCriteriumMode==2)
985  AliWarning("Set event criterium to 'simple jet trigger' -- select events with certain minimum leading jet pT (bgrd corr.)");
986  else if(fEventCriteriumMode==3)
987  AliWarning("Set event criterium to 'simple dijet trigger' -- select events with certain minimum leading + subleading jet pT (bgrd corr.)");
988  else
989  {
990  AliFatal("Event criterium not valid.");
991  }
992 }
993 
994 
995 //________________________________________________________________________
996 void AliAnalysisTaskChargedJetsHadronCF::GetLeadingJets(const char* opt, AliEmcalJet*& jetLeading, AliEmcalJet*& jetSubLeading)
997 {
998  // Customized from AliJetContainer::GetLeadingJet()
999  // Get the leading+subleading jet; if opt contains "rho" the sorting is according to pt-A*rho
1000 
1001  TString option(opt);
1002  option.ToLower();
1003 
1004  jetLeading = 0;
1005  jetSubLeading = 0;
1006 
1007  fJetsCont->ResetCurrentID();
1008  Double_t tmpLeadingPt = 0;
1009  Double_t tmpSubleadingPt = 0;
1010 
1011  if (option.Contains("rho")) {
1012  while (AliEmcalJet* jet = fJetsCont->GetNextAcceptJet()) {
1013  if ( (jet->Pt()-jet->Area()*fJetsCont->GetRhoVal()) > tmpLeadingPt )
1014  {
1015  jetSubLeading = jetLeading;
1016  jetLeading = jet;
1017  tmpSubleadingPt = tmpLeadingPt;
1018  tmpLeadingPt = jet->Pt()-jet->Area()*fJetsCont->GetRhoVal();
1019  }
1020  else if ( (jet->Pt()-jet->Area()*fJetsCont->GetRhoVal()) > tmpSubleadingPt )
1021  {
1022  jetSubLeading = jet;
1023  tmpSubleadingPt = jet->Pt()-jet->Area()*fJetsCont->GetRhoVal();
1024  }
1025  }
1026  }
1027  else {
1028  while (AliEmcalJet* jet = fJetsCont->GetNextAcceptJet()) {
1029  if ( (jet->Pt()) > tmpLeadingPt )
1030  {
1031  jetSubLeading = jetLeading;
1032  jetLeading = jet;
1033  tmpSubleadingPt = tmpLeadingPt;
1034  tmpLeadingPt = jet->Pt();
1035  }
1036  else if ( (jet->Pt()) > tmpSubleadingPt )
1037  {
1038  jetSubLeading = jet;
1039  tmpSubleadingPt = jet->Pt();
1040  }
1041  }
1042  }
1043 }
1044 
1045 //________________________________________________________________________
1047 {
1048  // Method for the correct logarithmic binning of histograms
1049  TAxis *axis = h->GetAxis(axisNumber);
1050  int bins = axis->GetNbins();
1051 
1052  Double_t from = axis->GetXmin();
1053  Double_t to = axis->GetXmax();
1054  Double_t *newBins = new Double_t[bins + 1];
1055 
1056  newBins[0] = from;
1057  Double_t factor = pow(to/from, 1./bins);
1058 
1059  for (int i = 1; i <= bins; i++) {
1060  newBins[i] = factor * newBins[i-1];
1061  }
1062  axis->Set(bins, newBins);
1063  delete [] newBins;
1064 }
1065 
1066 //________________________________________________________________________
1068 {
1069  TH1* tmpHist = static_cast<TH1*>(fOutput->FindObject(key));
1070  if(!tmpHist)
1071  {
1072  AliError(Form("Cannot find histogram <%s> ",key)) ;
1073  return;
1074  }
1075 
1076  tmpHist->Fill(x);
1077 }
1078 
1079 //________________________________________________________________________
1081 {
1082  TH1* tmpHist = static_cast<TH1*>(fOutput->FindObject(key));
1083  if(!tmpHist)
1084  {
1085  AliError(Form("Cannot find histogram <%s> ",key));
1086  return;
1087  }
1088 
1089  if (tmpHist->IsA()->GetBaseClass("TH1"))
1090  static_cast<TH1*>(tmpHist)->Fill(x,y); // Fill x with y
1091  else if (tmpHist->IsA()->GetBaseClass("TH2"))
1092  static_cast<TH2*>(tmpHist)->Fill(x,y); // Fill x,y with 1
1093 }
1094 
1095 //________________________________________________________________________
1097 {
1098  TH2* tmpHist = static_cast<TH2*>(fOutput->FindObject(key));
1099  if(!tmpHist)
1100  {
1101  AliError(Form("Cannot find histogram <%s> ",key));
1102  return;
1103  }
1104 
1105  tmpHist->Fill(x,y,add);
1106 }
1107 
1108 //________________________________________________________________________
1110 {
1111  TH3* tmpHist = static_cast<TH3*>(fOutput->FindObject(key));
1112  if(!tmpHist)
1113  {
1114  AliError(Form("Cannot find histogram <%s> ",key));
1115  return;
1116  }
1117 
1118  if(add)
1119  tmpHist->Fill(x,y,z,add);
1120  else
1121  tmpHist->Fill(x,y,z);
1122 }
1123 
1124 
1125 //________________________________________________________________________
1126 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)
1127 {
1128  T* tmpHist = new T(name, title, xBins, xMin, xMax);
1129 
1130  tmpHist->GetXaxis()->SetTitle(xTitle);
1131  tmpHist->GetYaxis()->SetTitle(yTitle);
1132  tmpHist->SetOption(options);
1133  tmpHist->SetMarkerStyle(kFullCircle);
1134  tmpHist->Sumw2();
1135 
1136  fOutput->Add(tmpHist);
1137 
1138  return tmpHist;
1139 }
1140 
1141 //________________________________________________________________________
1142 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)
1143 {
1144  T* tmpHist = new T(name, title, xBins, xMin, xMax, yBins, yMin, yMax);
1145  tmpHist->GetXaxis()->SetTitle(xTitle);
1146  tmpHist->GetYaxis()->SetTitle(yTitle);
1147  tmpHist->GetZaxis()->SetTitle(zTitle);
1148  tmpHist->SetOption(options);
1149  tmpHist->SetMarkerStyle(kFullCircle);
1150  tmpHist->Sumw2();
1151 
1152  fOutput->Add(tmpHist);
1153 
1154  return tmpHist;
1155 }
1156 
1157 //________________________________________________________________________
1158 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)
1159 {
1160  T* tmpHist = new T(name, title, xBins, xMin, xMax, yBins, yMin, yMax, zBins, zMin, zMax);
1161  tmpHist->GetXaxis()->SetTitle(xTitle);
1162  tmpHist->GetYaxis()->SetTitle(yTitle);
1163  tmpHist->GetZaxis()->SetTitle(zTitle);
1164  tmpHist->SetOption(options);
1165  tmpHist->SetMarkerStyle(kFullCircle);
1166  tmpHist->Sumw2();
1167 
1168  fOutput->Add(tmpHist);
1169 
1170  return tmpHist;
1171 }
1172 
1173 //________________________________________________________________________
1175 {
1176  // Called once at the end of the analysis.
1177 }
1178 
Double_t fEventExtractionMaxJetPt
maximum jet pt of recorded events
Short_t Charge() const
Definition: AliEmcalJet.h:110
Double_t fEventCriteriumMinSubleadingJetPt
Min subleading jet.
Double_t Area() const
Definition: AliEmcalJet.h:117
Double_t GetRhoVal() const
double Double_t
Definition: External.C:58
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)
Float_t GetPartonEta6() const
AliEmcalPythiaInfo * fPythiaInfo
!event parton info
TString fJetMatchingArrayName
Name of array used to match jets.
AliJetContainer * GetJetContainer(Int_t i=0) const
Definition: External.C:244
Float_t GetPartonEta7() const
Double_t Eta() const
Definition: AliEmcalJet.h:108
long long Long64_t
Definition: External.C:43
Double_t Phi() const
Definition: AliEmcalJet.h:104
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.
Int_t fPythiaExtractionMode
Mode which PYTHIA-jets to extract for fJetOutputMode==6: 0: all, 1: quark-jets, 2: gluon jets...
Double_t GetJetEtaMax() const
Float_t GetPartonPhi7() const
virtual Bool_t AcceptJet(Int_t i, UInt_t &rejectionReason) const
Double_t fJetMatchingMaxEmbeddingOffset
An embedded jet must NOT carry more than max fraction + max embedding offset.
Int_t fJetOutputMode
mode which jets are written to array (0: all accepted, 1: leading, 2: subleading, 3: leading+subleadi...
Double_t fEventExtractionMinJetPt
minimum jet pt of recorded events
std::vector< AliEmcalJet * > fMatchedJetsReference
Jets matched in an event (reference)
Double_t fEventExtractionPercentage
percentage of events that is recorded
Simple class containing basic information for a constituent.
Int_t GetPartonFlag7() const
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)
Float_t GetPartonPhi6() const
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:126
UShort_t T(UShort_t m, UShort_t t)
Definition: RingBits.C:60
Double_t fEventCriteriumMinJetDeltaPhi
Min jet delta phi in dijet criterium.
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Int_t GetPartonFlag6() const
void AddJetConstituent(Float_t eta, Float_t phi, Float_t pt, Short_t charge, Short_t pid=0)
AliParticleContainer * GetParticleContainer() const
int Int_t
Definition: External.C:63
Double_t fJetMatchingMaxPt
Max pt cut applied on the matchArray jets.
unsigned int UInt_t
Definition: External.C:33
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="")
std::vector< AliEmcalJet * > fMatchedJets
Jets matched in an event (embedded)
Double_t fExtractionPercentage
percentage that is recorded
Double_t fCent
!event centrality
Double_t fJetVetoMinPt
Min pt cut applied on the fJetVetoArray jets.
Double_t fJetVetoMaxPt
Max pt cut applied on the fJetVetoArray jets.
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 fJetMatchingMaxSharedFraction
An embedded jet must NOT carry more than max fraction + max embedding offset.
Double_t Pt() const
Definition: AliEmcalJet.h:96
Bool_t IsTrackInCone(AliVParticle *track, Double_t eta, Double_t phi, Double_t radius)
TString fJetVetoArrayName
Name of array used for veto jets.
Float_t GetJetRadius() const
AliEmcalList * fOutput
!output list
TClonesArray * fJetMatchingArray
! Array of generated jets imported into task (toy model/embedding)
Short_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:147
AliEmcalJet * fInitialPartonMatchedJet1
! On PYTHIA data and fJetOutputMode=6, this holds the PDG code of the initial collisions that was mat...
AliEmcalJet * fInitialPartonMatchedJet2
! On PYTHIA data and fJetOutputMode=6, this holds the PDG code of the initial collisions that was mat...
Definition: External.C:220
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
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
Declaration of class AliEmcalPythiaInfo.
const char Option_t
Definition: External.C:48
Double_t fExtractionMaxPt
maximum pt of recorded jets
Double_t fJetMatchingMaxDistance
Max distance allowed to accept a matching jet (for embedding)
virtual AliVParticle * GetNextAcceptParticle()
bool Bool_t
Definition: External.C:53
Double_t fJetMatchingMinPt
Min pt cut applied on the matchArray jets.
Int_t fJetMatchingUseOnlyNLeading
Number of matched leading jets that will be used.
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")
Definition: External.C:196
TClonesArray * fJetVetoArray
! Array of jets imported into task used for veto a matching/embedding
Int_t fAcceptedTracks
! number accepted tracks (calculated event-by-event)
Double_t fJetMatchingMinSharedFraction
An embedded jet must carry this pt fraction to be accepted.