]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGJE/AliAnalysisTaskPartonDisc.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Added event printout
[u/mrichter/AliRoot.git] / PWGJE / AliAnalysisTaskPartonDisc.cxx
CommitLineData
0c9acc4c 1/*************************************************************************
2* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
3* *
4* Author: The ALICE Off-line Project. *
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////////////////////////////////////////////////////////
17// //
18// Analysis task for parton discrimination studies //
19// //
20// Author: //
21// Hermes Leon Vargas (hleon@ikf.uni-frankfurt.de) //
22// //
23////////////////////////////////////////////////////////
24
25#include "TROOT.h"
26#include "TDirectory.h"
27#include "TKey.h"
28#include "TList.h"
29#include "TSystem.h"
30#include "TChain.h"
31#include "TTree.h"
32#include "TFile.h"
33#include "TString.h"
34#include "TH1F.h"
35#include "TH1I.h"
36#include "TH2F.h"
37#include "TH2I.h"
38#include "TH3F.h"
39#include "TProfile.h"
40#include "TCanvas.h"
41#include "AliAnalysisTask.h"
42#include "AliAnalysisManager.h"
43#include "AliAODHandler.h"
44#include "AliVEvent.h"
45#include "AliAODEvent.h"
46#include "AliAODInputHandler.h"
47#include "AliVParticle.h"
48#include "AliAODMCParticle.h"
49#include "AliGenEventHeader.h"
50#include "AliGenPythiaEventHeader.h"
51#include "AliGenDPMjetEventHeader.h"
52#include "AliAODMCHeader.h"
53#include "AliMCEventHandler.h"
54#include "AliMCEvent.h"
55#include <algorithm>
56#include "AliLog.h"
57#include "AliAODVertex.h"
58#include "AliAODHeader.h"
59#include "AliESDtrack.h"
60#include "AliAnalysisHelperJetTasks.h"
61#include "AliAnalysisTaskPartonDisc.h"
62#include "AliAODVZERO.h"
17f4943e 63#include "TRandom3.h"
64#include "TDatime.h"
0c9acc4c 65
66// Analysis task for parton discrimination
67
68ClassImp(AliAnalysisTaskPartonDisc)
69
8dcbcbbb 70Double_t *AliAnalysisTaskPartonDisc::fgContainer = 0x0;
0c9acc4c 71
72//________________________________________________________________________
73AliAnalysisTaskPartonDisc::AliAnalysisTaskPartonDisc()
17f4943e 74 : AliAnalysisTaskSE(), fAOD(0), fUseAODMC(kFALSE), fPhojetMC(kFALSE), fBranchMC("jetsMC"), fBranchRec("jetsREC"), fBranchSecRec(""), fSqrts(0), fNtX(0), fJetRadius(0.), fFlavorRadius(0.), fFilterBit(0xFF), fOutputList(0), fJetPt(0), fJetPtSec(0), fJetPtMC(0), fJetEta(0), fJetEtaSec(0), fJetPhi(0), fJetPhiSec(0), fJetEtaMC(0), fJetPhiMC(0), fPtAODMC(0), fPtAOD(0), fEtaAODMC(0), fPhiAODMC(0), fEtaAOD(0), fPhiAOD(0), fFlavor(0), fNJetsMC(0), fNJetsRD(0), fNJetsRDSeco(0), fJetsMultPtMC(0), fJetsMultPtRD(0), fNChTrRD(0), fProfNChTrRD(0), fFracQQ(0), fFracGQ(0), fFracGG(0), fFracOutGoingQQ(0), fFracOutGoingGQ(0), fFracOutGoingGG(0), fh1Xsec(0), fh1Trials(0), fMpdg(0), fProcessJetPt(0), fFlavorLead(0), fProcessLeadJetPt(0), fPDGMothLPart(0), fFlavProc(0), fAvgTrials(1), fUseAODJetInput(kFALSE), fMinTrackPtInNTX(0), fMaxTrackPtInNTX(0), fSCMRD(0), fMinpTVal(0), fZVertex(0), fh1Events(0), fUseOnlyMC(kFALSE), fCheckMCStatus(kTRUE), fEvtCount(0), fNAccJetsMC(0), fNAccJetsRD(0), fNAccJetsRDSeco(0), fEnablePrints(kFALSE), fRecJetPtInclusive(0), fMCJetPtInclusive(0), fRecJetPtLeading(0), fMCJetPtLeading(0), fSecRecJetPtInclusive(0), fSecRecJetPtLeading(0), fHasPerpCone(kTRUE), fEtaPerpCoord(0), fPhiPerpCoord(0), fPtPerpCoord(0), fJetEvent(kFALSE), fPerpCone(0), fNChTrMCPerp(0), fNChTrRecPerp(0), fSCMMCPerp(0), fSCMRecPerp(0), fIsHIevent(kFALSE), fCurrentJetMinPtNT90(0), fBckgSbsJet(0), fCurrentJetMinPtNT90Recalc(0), fNChTrCorrMCQuark(0), fNChTrCorrMCGluon(0), fNChTrCorrMCPerp(0), fIsPossibleToSubstBckg(kTRUE), fNChTrRecECorr(0), fNChTrRecPerpECorr(0), fRefMult(0), fCurrentJetCharge(0), fRefMultWOJet(0), fVZEROMult(0), fMultWOJetVZero(0), fVZero(0), fRefMultFullV0(0), fRefMultV0Corr(0), fFullV0V0Corr(0), fNTXV0MultPt(0), fNTXCBMultPt(0), fMinpTValUE(2.0), fRefMultFullV0UJ(0), fRefMultV0CorrUJ(0), fFullV0V0CorrUJ(0), fMultWOJetVZeroUJ(0), fRefMultWOJetUJ(0), fMaxpTValUE(2.0), fRefAODTrackCount(0), fRefAODTrackCountUJ(0), fTrackCountWOJet(0), fTrackCountWOJetUJ(0), fTrackCountWOJetUJMC(0), fFullV0V0CorrUJMC(0), fMinpTValMC(2.0), fIncExcR(0.0), fForceNotTR(kFALSE), fNotExtDiJEx(kFALSE), fMinTrackPtInNTXRecalc(0), fMaxTrackPtInNTXRecalc(0), fPtDistInJetConeRaw(0), fPtDistInPerpConeRaw(0), fPtInPerpCon(0), fMinTrackPtInNTXR(0), fMaxTrackPtInNTXR(0), fEventCent(0), fJetEtaAll(0), fJetEtaOnlyTPCcut(0), fNChTrRecECorrPPMult(0), fNChTrRecPerpECorrPPMult(0), fForceSkipSJ(kFALSE), fJetPtCentPbPbRaw(0), fJetPtCentPbPbCorr(0), fJetAcceptance(0.5), fIncreasingExcl(kFALSE), fTotTracksCone(0), fTotTracksInCone(0), fTTrackRandomRejection(0), fJTrackRandomRejection(0), fMinPtInGlobMult(0)
0c9acc4c 75{
0c9acc4c 76 // Constructor
77
78 for(Int_t a=0; a<16;a++)
79 {
80 fJetFlags[a]=kTRUE;
81 if(a<12)
82 {
83 fNChTr[a]=0;
84 fHistPtParton[a]=0;
85 fSCM[a]=0;
86 if(a<8)
87 {
88 fNChTrRDMult[a]=0;
89 fNAccJetsRDMult[a]=0;
90 fTotalJetCharge[a]=0;
91 fSCMRDMult[a]=0;
92 fNChTrRDMultMC[a]=0;
93 fSCMRDMultMC[a]=0;
94 fNChTrRDMultSE[a]=0;
95 fNAccJetsRDMultSE[a]=0;
96 fTotalJetChargeSE[a]=0;
97 fSCMRDMultSE[a]=0;
98 fNChTrRDMultOJ[a]=0;
99 fSCMRDMultOJ[a]=0;
100 fNChTrRDMultSEOJ[a]=0;
101 fSCMRDMultSEOJ[a]=0;
102 fNChTrRDMultOJMC[a]=0;
103 fSCMRDMultOJMC[a]=0;
104 fNChTrRDMultSEOJMC[a]=0;
105 fSCMRDMultSEOJMC[a]=0;
106 fNChTrRecPerpMultSEOJ[a]=0;
17f4943e 107 fJEtaMCMultOJ[a]=0;
108 fJEtaMCMultSEOJ[a]=0;
109 fJEtaRDMultOJ[a]=0;
110 fJEtaRDMultSEOJ[a]=0;
111 fJetPtMCMultOJ[a]=0;
112 fJetPtMCMultSEOJ[a]=0;
113 fJetPtRDMultOJ[a]=0;
114 fJetPtRDMultSEOJ[a]=0;
115 fEntriesQuark[a]=0;
116 fEntriesGluon[a]=0;
0c9acc4c 117 }
118 if(a<6)
119 {
120 fProcessPDG[a]=0;
121 fFragPion[a]=0;
122 fFragKaon[a]=0;
123 fFragProton[a]=0;
124 fFragChargedR4[a]=0;
125 fFragChargedR3[a]=0;
126 fFragChargedR2[a]=0;
127 fHistContainerR4[a]=0;
128 fHistContainerR3[a]=0;
129 fHistContainerR2[a]=0;
130 if(a<3)
131 {
132 fJetEtaJetPt[a]=0;
133 if(a<2)
134 {
135 fFragCandidates[a]=0;
136 fMinTrackPtInNTXh[a]=0;
137 fMaxTrackPtInNTXh[a]=0;
138 }
139 }
140 }
141 }
142 }
143}
144//________________________________________________________________________
145AliAnalysisTaskPartonDisc::AliAnalysisTaskPartonDisc(const char *name)
17f4943e 146 : AliAnalysisTaskSE(name), fAOD(0), fUseAODMC(kFALSE), fPhojetMC(kFALSE), fBranchMC("jetsMC"), fBranchRec("jetsREC"), fBranchSecRec(""), fSqrts(0), fNtX(0), fJetRadius(0.), fFlavorRadius(0.), fFilterBit(0xFF), fOutputList(0), fJetPt(0), fJetPtSec(0), fJetPtMC(0), fJetEta(0), fJetEtaSec(0), fJetPhi(0), fJetPhiSec(0), fJetEtaMC(0), fJetPhiMC(0), fPtAODMC(0), fPtAOD(0), fEtaAODMC(0), fPhiAODMC(0), fEtaAOD(0), fPhiAOD(0), fFlavor(0), fNJetsMC(0), fNJetsRD(0), fNJetsRDSeco(0), fJetsMultPtMC(0), fJetsMultPtRD(0), fNChTrRD(0), fProfNChTrRD(0), fFracQQ(0), fFracGQ(0), fFracGG(0), fFracOutGoingQQ(0), fFracOutGoingGQ(0), fFracOutGoingGG(0), fh1Xsec(0), fh1Trials(0), fMpdg(0), fProcessJetPt(0), fFlavorLead(0), fProcessLeadJetPt(0), fPDGMothLPart(0), fFlavProc(0), fAvgTrials(1), fUseAODJetInput(kFALSE), fMinTrackPtInNTX(0), fMaxTrackPtInNTX(0), fSCMRD(0), fMinpTVal(0), fZVertex(0), fh1Events(0), fUseOnlyMC(kFALSE), fCheckMCStatus(kTRUE), fEvtCount(0), fNAccJetsMC(0), fNAccJetsRD(0), fNAccJetsRDSeco(0), fEnablePrints(kFALSE), fRecJetPtInclusive(0), fMCJetPtInclusive(0), fRecJetPtLeading(0), fMCJetPtLeading(0), fSecRecJetPtInclusive(0), fSecRecJetPtLeading(0), fHasPerpCone(kTRUE), fEtaPerpCoord(0), fPhiPerpCoord(0), fPtPerpCoord(0), fJetEvent(kFALSE), fPerpCone(0), fNChTrMCPerp(0), fNChTrRecPerp(0), fSCMMCPerp(0), fSCMRecPerp(0), fIsHIevent(kFALSE), fCurrentJetMinPtNT90(0), fBckgSbsJet(0), fCurrentJetMinPtNT90Recalc(0), fNChTrCorrMCQuark(0), fNChTrCorrMCGluon(0), fNChTrCorrMCPerp(0), fIsPossibleToSubstBckg(kTRUE), fNChTrRecECorr(0), fNChTrRecPerpECorr(0), fRefMult(0), fCurrentJetCharge(0), fRefMultWOJet(0), fVZEROMult(0), fMultWOJetVZero(0), fVZero(0), fRefMultFullV0(0), fRefMultV0Corr(0), fFullV0V0Corr(0), fNTXV0MultPt(0), fNTXCBMultPt(0), fMinpTValUE(2.0), fRefMultFullV0UJ(0), fRefMultV0CorrUJ(0), fFullV0V0CorrUJ(0), fMultWOJetVZeroUJ(0), fRefMultWOJetUJ(0), fMaxpTValUE(2.0), fRefAODTrackCount(0), fRefAODTrackCountUJ(0), fTrackCountWOJet(0), fTrackCountWOJetUJ(0), fTrackCountWOJetUJMC(0), fFullV0V0CorrUJMC(0), fMinpTValMC(2.0), fIncExcR(0.0), fForceNotTR(kFALSE), fNotExtDiJEx(kFALSE), fMinTrackPtInNTXRecalc(0), fMaxTrackPtInNTXRecalc(0), fPtDistInJetConeRaw(0), fPtDistInPerpConeRaw(0), fPtInPerpCon(0), fMinTrackPtInNTXR(0), fMaxTrackPtInNTXR(0), fEventCent(0), fJetEtaAll(0), fJetEtaOnlyTPCcut(0), fNChTrRecECorrPPMult(0), fNChTrRecPerpECorrPPMult(0), fForceSkipSJ(kFALSE), fJetPtCentPbPbRaw(0), fJetPtCentPbPbCorr(0), fJetAcceptance(0.5), fIncreasingExcl(kFALSE), fTotTracksCone(0), fTotTracksInCone(0), fTTrackRandomRejection(0), fJTrackRandomRejection(0), fMinPtInGlobMult(0)
0c9acc4c 147{
148
149 // Constructor
150
151 for(Int_t a=0; a<16;a++)
152 {
153 fJetFlags[a]=kTRUE;
154 if(a<12)
155 {
156 fNChTr[a]=0;
157 fHistPtParton[a]=0;
158 fSCM[a]=0;
159 if(a<8)
160 {
161 fNChTrRDMult[a]=0;
162 fNAccJetsRDMult[a]=0;
163 fTotalJetCharge[a]=0;
164 fSCMRDMult[a]=0;
165 fNChTrRDMultMC[a]=0;
166 fSCMRDMultMC[a]=0;
167 fNChTrRDMultSE[a]=0;
168 fNAccJetsRDMultSE[a]=0;
169 fTotalJetChargeSE[a]=0;
170 fSCMRDMultSE[a]=0;
171 fNChTrRDMultOJ[a]=0;
172 fSCMRDMultOJ[a]=0;
173 fNChTrRDMultSEOJ[a]=0;
174 fSCMRDMultSEOJ[a]=0;
175 fNChTrRDMultOJMC[a]=0;
176 fSCMRDMultOJMC[a]=0;
177 fNChTrRDMultSEOJMC[a]=0;
178 fSCMRDMultSEOJMC[a]=0;
179 fNChTrRecPerpMultSEOJ[a]=0;
17f4943e 180 fJEtaMCMultOJ[a]=0;
181 fJEtaMCMultSEOJ[a]=0;
182 fJEtaRDMultOJ[a]=0;
183 fJEtaRDMultSEOJ[a]=0;
184 fJetPtMCMultOJ[a]=0;
185 fJetPtMCMultSEOJ[a]=0;
186 fJetPtRDMultOJ[a]=0;
187 fJetPtRDMultSEOJ[a]=0;
188 fEntriesQuark[a]=0;
189 fEntriesGluon[a]=0;
0c9acc4c 190 }
191 if(a<6)
192 {
193 fProcessPDG[a]=0;
194 fFragPion[a]=0;
195 fFragKaon[a]=0;
196 fFragProton[a]=0;
197 fFragChargedR4[a]=0;
198 fFragChargedR3[a]=0;
199 fFragChargedR2[a]=0;
200 fHistContainerR4[a]=0;
201 fHistContainerR3[a]=0;
202 fHistContainerR2[a]=0;
203 if(a<3)
204 {
205 fJetEtaJetPt[a]=0;
206 if(a<2)
207 {
208 fFragCandidates[a]=0;
209 fMinTrackPtInNTXh[a]=0;
210 fMaxTrackPtInNTXh[a]=0;
211 }
212 }
213 }
214 }
215 }
216
217 // Define input and output slots here
218 // Input slot #0 works with a TChain
219 DefineInput(0, TChain::Class());
220 // Output slot #0 id reserved by the base class for AOD
221 // Output slot #1 writes into a TH1 container
222 DefineOutput(1, TList::Class());
223}
224//________________________________________________________________________
225Bool_t AliAnalysisTaskPartonDisc::UserNotify()
226{
227 //
228 // read the cross sections
229 // and number of trials from pyxsec.root
230 // from AliAnalysisTaskJetSpectrum2
231 //
232
233 TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
234 Float_t xsection = 0;
235 Float_t ftrials = 1;
236 Int_t nevents = 0;
237
238 fAvgTrials = 1;
239 if(tree)
240 {
241 TFile *curfile = tree->GetCurrentFile();
242 if (!curfile)
243 {
244 Error("Notify","No current file");
245 return kFALSE;
246 }
247 if(!fh1Xsec||!fh1Trials)
248 {
249 Printf("%s%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
250 return kFALSE;
251 }
252 AliAnalysisHelperJetTasks::PythiaInfoFromFile(curfile->GetName(),xsection,ftrials);
253 fh1Xsec->Fill("<#sigma>",xsection);
254 // construct a poor man average trials (per event!?)
255 Float_t nEntries = (Float_t)tree->GetTree()->GetEntries();
256 if(ftrials>=nEntries && nEntries>0.)fAvgTrials = ftrials/nEntries;
257 // number of events read out to create the AOD
258 NumberOfReadEventsAOD(curfile->GetName(),nevents);
259 fh1Events->Fill("#sum{nevents}",nevents); // filled once per file
260 }
261 return kTRUE;
262
263}
264//________________________________________________________________________
265void AliAnalysisTaskPartonDisc::UserCreateOutputObjects()
266{
267 // Create histograms
268 // Called once
269
270 fOutputList = new TList();
271 fOutputList->SetOwner(kTRUE);
272
273 fJetPt = new TH1F("fJetPt", "p_{T} distribution of reco jets", 60, 0., 300.);
274 fJetPt->GetXaxis()->SetTitle("p_{T} (GeV/c)");
275 fJetPt->GetYaxis()->SetTitle("dN/dp_{T} (c/GeV)");
276 fJetPt->Sumw2();
277 fOutputList->Add(fJetPt);
278
279 fJetPtSec = new TH1F("fJetPtSec", "p_{T} distribution of reco jets, seconday rec branch", 60, 0., 300.);
280 fJetPtSec->GetXaxis()->SetTitle("p_{T} (GeV/c)");
281 fJetPtSec->GetYaxis()->SetTitle("dN/dp_{T} (c/GeV)");
282 fJetPtSec->Sumw2();
283 fOutputList->Add(fJetPtSec);
284
285 fJetPtMC = new TH1F("fJetPtMC", "p_{T} distribution of mc jets", 60, 0., 300.);
286 fJetPtMC->GetXaxis()->SetTitle("p_{T} (GeV/c)");
287 fJetPtMC->GetYaxis()->SetTitle("dN/dp_{T} (c/GeV)");
288 fJetPtMC->Sumw2();
289 fOutputList->Add(fJetPtMC);
290
291 fJetEta = new TH2F("fJetEta", "Eta distribution of reconstructed jets", 50, -1.5, 1.5, 50, -1.5, 1.5);
292 fJetEta->GetXaxis()->SetTitle("#eta");
293 fJetEta->GetYaxis()->SetTitle("#eta");
294 fJetEta->Sumw2();
295 fOutputList->Add(fJetEta);
296
297 fJetEtaSec = new TH2F("fJetEtaSec", "Eta distribution of reconstructed jets, secondary branch", 50, -1.5, 1.5, 50, -1.5, 1.5);
298 fJetEtaSec->GetXaxis()->SetTitle("#eta");
299 fJetEtaSec->GetYaxis()->SetTitle("#eta");
300 fJetEtaSec->Sumw2();
301 fOutputList->Add(fJetEtaSec);
302
303 fJetPhi = new TH2F("fJetPhi", "Phi distribution of reconstructed jets", 50, 0., TMath::TwoPi(), 50, 0., TMath::TwoPi());
304 fJetPhi->GetXaxis()->SetTitle("#phi");
305 fJetPhi->GetYaxis()->SetTitle("#phi");
306 fJetPhi->Sumw2();
307 fOutputList->Add(fJetPhi);
308
309 fJetPhiSec = new TH2F("fJetPhiSec", "Phi distribution of reconstructed jets, secondary branch", 50, 0., TMath::TwoPi(), 50, 0., TMath::TwoPi());
310 fJetPhiSec->GetXaxis()->SetTitle("#phi");
311 fJetPhiSec->GetYaxis()->SetTitle("#phi");
312 fJetPhiSec->Sumw2();
313 fOutputList->Add(fJetPhiSec);
314
315 fJetEtaMC = new TH2F("fJetEtaMC", "Eta distribution of MC jets", 50, -1.5, 1.5, 50, -1.5, 1.5);
316 fJetEtaMC->GetXaxis()->SetTitle("#eta");
317 fJetEtaMC->GetYaxis()->SetTitle("#eta");
318 fJetEtaMC->Sumw2();
319 fOutputList->Add(fJetEtaMC);
320
321 fJetPhiMC = new TH2F("fJetPhiMC", "Phi distribution of MC jets", 50, 0., TMath::TwoPi(), 50, 0., TMath::TwoPi());
322 fJetPhiMC->GetXaxis()->SetTitle("#phi");
323 fJetPhiMC->GetYaxis()->SetTitle("#phi");
324 fJetPhiMC->Sumw2();
325 fOutputList->Add(fJetPhiMC);
326
327 fPtAODMC = new TH2F("fPtAODMC", "p_{T} distribution of mc tracks", 200, 0., 100., 200, 0., 100.);
328 fPtAODMC->GetXaxis()->SetTitle("p_{T} (GeV/c)");
329 fPtAODMC->GetYaxis()->SetTitle("p_{T} (GeV/c)");
330 fPtAODMC->Sumw2();
331 fOutputList->Add(fPtAODMC);
332
333 fPtAOD = new TH2F("fPtAOD", "p_{T} distribution of aod tracks", 200, 0., 100., 200, 0., 100.);
334 fPtAOD->GetXaxis()->SetTitle("p_{T} (GeV/c)");
335 fPtAOD->GetYaxis()->SetTitle("p_{T} (GeV/c)");
336 fPtAOD->Sumw2();
337 fOutputList->Add(fPtAOD);
338
339 fEtaAODMC = new TH2F("fEtaAODMC", "Eta distribution of MC aod tracks", 50, -1.5, 1.5, 50, -1.5, 1.5);
340 fEtaAODMC->GetXaxis()->SetTitle("#eta");
341 fEtaAODMC->GetYaxis()->SetTitle("#eta");
342 fEtaAODMC->Sumw2();
343 fOutputList->Add(fEtaAODMC);
344
345 fPhiAODMC = new TH2F("fPhiAODMC", "Phi distribution of MC aod tracks", 50, 0., TMath::TwoPi(), 50, 0., TMath::TwoPi());
346 fPhiAODMC->GetXaxis()->SetTitle("#phi");
347 fPhiAODMC->GetYaxis()->SetTitle("#phi");
348 fPhiAODMC->Sumw2();
349 fOutputList->Add(fPhiAODMC);
350
351 fEtaAOD = new TH2F("fEtaAOD", "Eta distribution of aod tracks", 50, -1.5, 1.5, 50, -1.5, 1.5);
352 fEtaAOD->GetXaxis()->SetTitle("#eta");
353 fEtaAOD->GetYaxis()->SetTitle("#eta");
354 fEtaAOD->Sumw2();
355 fOutputList->Add(fEtaAOD);
356
357 fPhiAOD = new TH2F("fPhiAOD", "Phi distribution of aod tracks", 50, 0.,TMath::TwoPi(), 50, 0.,TMath::TwoPi());
358 fPhiAOD->GetXaxis()->SetTitle("#phi");
359 fPhiAOD->GetYaxis()->SetTitle("#phi");
360 fPhiAOD->Sumw2();
361 fOutputList->Add(fPhiAOD);
362
363 fFlavor = new TH2F("fFlavor", "Flavor distribution of jets", 27, -5.5, 21.5, 60, 0., 300.);
364 fFlavor->GetXaxis()->SetTitle("PDG code");
365 fFlavor->GetYaxis()->SetTitle("p_{T}^{JET}");
366 fFlavor->Sumw2();
367 fOutputList->Add(fFlavor);
368
369 fNJetsMC = new TH2F("fNJetsMC", "Number of simulated jets per event, as a function of p_T", 101, -0.5, 100.5, 101, -0.5, 100.5);
370 fNJetsMC->GetXaxis()->SetTitle("Number of jets");
371 fNJetsMC->GetYaxis()->SetTitle("Number of jets");
372 fNJetsMC->Sumw2();
373 fOutputList->Add(fNJetsMC);
374
375 fNJetsRD = new TH2F("fNJetsRD", "Number of jets per event in real data", 101, -0.5, 100.5, 101, -0.5, 100.5);
376 fNJetsRD->GetXaxis()->SetTitle("Number of jets");
377 fNJetsRD->GetYaxis()->SetTitle("Number of jets");
378 fNJetsRD->Sumw2();
379 fOutputList->Add(fNJetsRD);
380
381 fNJetsRDSeco = new TH2F("fNJetsRDSeco", "Number of jets per event in real data, secondary branch", 101, -0.5, 100.5, 101, -0.5, 100.5);
382 fNJetsRDSeco->GetXaxis()->SetTitle("Number of jets");
383 fNJetsRDSeco->GetYaxis()->SetTitle("Number of jets");
384 fNJetsRDSeco->Sumw2();
385 fOutputList->Add(fNJetsRDSeco);
386
387 fJetsMultPtMC = new TH2F("fJetsMultPtMC", "Jet multiplicity associated to jet pT, as a function of p_T MC", 60, 0., 300., 7, -0.5, 6.5);
388 fJetsMultPtMC->GetXaxis()->SetTitle("p_{T}^{JET}");
389 fJetsMultPtMC->GetYaxis()->SetTitle("Number of jets");
390 fJetsMultPtMC->Sumw2();
391 fOutputList->Add(fJetsMultPtMC);
392
393 fJetsMultPtRD = new TH2F("fJetsMultPtRD", "Jet multiplicity associated to jet pT, as a function of p_T Reco Data",60, 0., 300., 7, -0.5, 6.5);
394 fJetsMultPtRD->GetXaxis()->SetTitle("p_{T}^{JET}");
395 fJetsMultPtRD->GetYaxis()->SetTitle("Number of jets");
396 fJetsMultPtRD->Sumw2();
397 fOutputList->Add(fJetsMultPtRD);
398
399 fNChTrRD = new TH2F("fNChTrRD","Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
400 fNChTrRD->GetXaxis()->SetTitle("NTracks");
401 fNChTrRD->GetYaxis()->SetTitle("p_{T}^{JET}");
402 fNChTrRD->Sumw2();
403 fOutputList->Add(fNChTrRD);
404
405 fProfNChTrRD = new TProfile("fProfNChTrRD","Number of tracks to recover transverse energy, jet_{p_{T}}", 50, 0, 250);
406 fProfNChTrRD->GetXaxis()->SetTitle("p_{T}^{JET}");
407 fProfNChTrRD->GetYaxis()->SetTitle("NTracks");
408 fProfNChTrRD->Sumw2();
409 fOutputList->Add(fProfNChTrRD);
410
411 fFracQQ = new TH1F("fFracQQ","QQ",1000,0.,0.5);
412 fFracQQ->GetXaxis()->SetTitle("x_{T}");
413 fFracQQ->GetYaxis()->SetTitle("Entries");
414 fFracQQ->Sumw2();
415 fOutputList->Add(fFracQQ);
416
417 fFracGQ = new TH1F("fFracGQ","GQ",1000,0.,0.5);
418 fFracGQ->GetXaxis()->SetTitle("x_{T}");
419 fFracGQ->GetYaxis()->SetTitle("Entries");
420 fFracGQ->Sumw2();
421 fOutputList->Add(fFracGQ);
422
423 fFracGG = new TH1F("fFracGG","GG",1000,0.,0.5);
424 fFracGG->GetXaxis()->SetTitle("x_{T}");
425 fFracGG->GetYaxis()->SetTitle("Entries");
426 fFracGG->Sumw2();
427 fOutputList->Add(fFracGG);
428
429 fFracOutGoingQQ = new TH1F("fFracOutGoingQQ","QQ",1000,0.,0.5);
430 fFracOutGoingQQ->GetXaxis()->SetTitle("x_{T}");
431 fFracOutGoingQQ->GetYaxis()->SetTitle("Entries");
432 fFracOutGoingQQ->Sumw2();
433 fOutputList->Add(fFracOutGoingQQ);
434
435 fFracOutGoingGQ = new TH1F("fFracOutGoingGQ","GQ",1000,0.,0.5);
436 fFracOutGoingGQ->GetXaxis()->SetTitle("x_{T}");
437 fFracOutGoingGQ->GetYaxis()->SetTitle("Entries");
438 fFracOutGoingGQ->Sumw2();
439 fOutputList->Add(fFracOutGoingGQ);
440
441 fFracOutGoingGG = new TH1F("fFracOutGoingGG","GG",1000,0.,0.5);
442 fFracOutGoingGG->GetXaxis()->SetTitle("x_{T}");
443 fFracOutGoingGG->GetYaxis()->SetTitle("Entries");
444 fFracOutGoingGG->Sumw2();
445 fOutputList->Add(fFracOutGoingGG);
446
447 fh1Xsec = new TProfile("h1Xsec","xsec from pyxsec.root",1,0,1);
448 fh1Xsec->SetXTitle("<#sigma>");
449 fh1Xsec->Sumw2();
450 fOutputList->Add(fh1Xsec);
451
452 fh1Trials = new TH1F("h1Trials","trials from pyxsec.root",1,0,1);
453 fh1Trials->SetXTitle("#sum{ntrials}");
454 fh1Trials->Sumw2();
455 fOutputList->Add(fh1Trials);
456
457 fProcessJetPt = new TH2F("fProcessJetPt","Pythia process number, jet_{p_{T}}",70, 0.5, 70.5, 60, 0., 300.);
458 fProcessJetPt->GetXaxis()->SetTitle("Pythia process");
459 fProcessJetPt->GetYaxis()->SetTitle("p_{T}^{JET}");
460 fProcessJetPt->Sumw2();
461 fOutputList->Add(fProcessJetPt);
462
463 fFlavorLead = new TH2F("fFlavorLead", "Flavor distribution of leading jets", 27, -5.5, 21.5, 60, 0., 300.);
464 fFlavorLead->GetXaxis()->SetTitle("PDG code");
465 fFlavorLead->GetYaxis()->SetTitle("p_{T}^{JET}");
466 fFlavorLead->Sumw2();
467 fOutputList->Add(fFlavorLead);
468
469 fProcessLeadJetPt = new TH2F("fProcessLeadJetPt","Pythia process number for leading, jet_{p_{T}}",70, 0.5, 70.5, 60, 0., 300.);
470 fProcessLeadJetPt->GetXaxis()->SetTitle("Pythia process");
471 fProcessLeadJetPt->GetYaxis()->SetTitle("p_{T}^{JET}");
472 fProcessLeadJetPt->Sumw2();
473 fOutputList->Add(fProcessLeadJetPt);
474
475 fPDGMothLPart = new TH3F("fPDGMothLPart","Mother of leading parton, leading parton, jet p_{T}", 27, -5.5, 21.5, 27, -5.5, 21.5, 60, 0., 300.);
476 fPDGMothLPart->GetXaxis()->SetTitle("Mother of leading parton");
477 fPDGMothLPart->GetYaxis()->SetTitle("Leading parton");
478 fPDGMothLPart->GetZaxis()->SetTitle("p_{T}^{JET}");
479 fPDGMothLPart->Sumw2();
480 fOutputList->Add(fPDGMothLPart);
481
482 fFlavProc = new TH2F("fFlavProc","Flavor, Flavor status code", 27, -5.5, 21.5, 101, -0.5, 100.5);
483 fFlavProc->GetXaxis()->SetTitle("Jet flavor");
484 fFlavProc->GetYaxis()->SetTitle("Parton status code");
485 fFlavProc->Sumw2();
486 fOutputList->Add(fFlavProc);
487
488 fSCMRD = new TH2F("fSCMRD","Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
489 fSCMRD->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
490 fSCMRD->GetYaxis()->SetTitle("p_{T}^{JET}");
491 fSCMRD->Sumw2();
492 fOutputList->Add(fSCMRD);
493
494 fZVertex = new TH2F("fZVertex","Z vertex position, Z vertex position}",40,-20.,20., 40, -20., 20.);
495 fZVertex->GetXaxis()->SetTitle("Vertex z");
496 fZVertex->GetYaxis()->SetTitle("Vertex z");
497 fZVertex->Sumw2();
498 fOutputList->Add(fZVertex);
499
500 fh1Events = new TH1F("fh1Events","nevents from PWG4_JetTasksOutput.root",1,0,1);
501 fh1Events->SetXTitle("#sum{nevents}");
502 fh1Events->Sumw2();
503 fOutputList->Add(fh1Events);
504
505 fNAccJetsMC = new TH2F("fNAccJetsMC", "Number accepted simulated jets per event", 101, -0.5, 100.5, 101, -0.5, 100.5);
506 fNAccJetsMC->GetXaxis()->SetTitle("Number of jets");
507 fNAccJetsMC->GetYaxis()->SetTitle("Number of jets");
508 fNAccJetsMC->Sumw2();
509 fOutputList->Add(fNAccJetsMC);
510
511 fNAccJetsRD = new TH2F("fNAccJetsRD", "Number of accepted jets per event in real data", 101, -0.5, 100.5, 101, -0.5, 100.5);
512 fNAccJetsRD->GetXaxis()->SetTitle("Number of jets");
513 fNAccJetsRD->GetYaxis()->SetTitle("Number of jets");
514 fNAccJetsRD->Sumw2();
515 fOutputList->Add(fNAccJetsRD);
516
517 fNAccJetsRDSeco = new TH2F("fNAccJetsRDSeco", "Number of accepted jets per event in real data, secondary branch", 101, -0.5, 100.5, 101, -0.5, 100.5);
518 fNAccJetsRDSeco->GetXaxis()->SetTitle("Number of jets");
519 fNAccJetsRDSeco->GetYaxis()->SetTitle("Number of jets");
520 fNAccJetsRDSeco->Sumw2();
521 fOutputList->Add(fNAccJetsRDSeco);
522
523 fRecJetPtInclusive = new TH1F("fRecJetPtInclusive", "p_{T} distribution of inclusive reco jets", 60, 0., 300.);
524 fRecJetPtInclusive->GetXaxis()->SetTitle("p_{T} (GeV/c)");
525 fRecJetPtInclusive->GetYaxis()->SetTitle("d#sigma (mb)");
526 fRecJetPtInclusive->Sumw2();
527 fOutputList->Add(fRecJetPtInclusive);
528
529 fMCJetPtInclusive = new TH1F("fMCJetPtInclusive", "p_{T} distribution of inclusive MC jets", 60, 0., 300.);
530 fMCJetPtInclusive->GetXaxis()->SetTitle("p_{T} (GeV/c)");
531 fMCJetPtInclusive->GetYaxis()->SetTitle("d#sigma (mb)");
532 fMCJetPtInclusive->Sumw2();
533 fOutputList->Add(fMCJetPtInclusive);
534
535 fRecJetPtLeading = new TH1F("fRecJetPtLeading", "p_{T} distribution of leading reco jets", 60, 0., 300.);
536 fRecJetPtLeading->GetXaxis()->SetTitle("p_{T} (GeV/c)");
537 fRecJetPtLeading->GetYaxis()->SetTitle("d#sigma (mb)");
538 fRecJetPtLeading->Sumw2();
539 fOutputList->Add(fRecJetPtLeading);
540
541 fMCJetPtLeading = new TH1F("fMCJetPtLeading", "p_{T} distribution of leading MC jets", 60, 0., 300.);
542 fMCJetPtLeading->GetXaxis()->SetTitle("p_{T} (GeV/c)");
543 fMCJetPtLeading->GetYaxis()->SetTitle("d#sigma (mb)");
544 fMCJetPtLeading->Sumw2();
545 fOutputList->Add(fMCJetPtLeading);
546
547 fSecRecJetPtInclusive = new TH1F("fSecRecJetPtInclusive", "p_{T} distribution of inclusive reco jets (2nd branch)", 60, 0., 300.);
548 fSecRecJetPtInclusive->GetXaxis()->SetTitle("p_{T} (GeV/c)");
549 fSecRecJetPtInclusive->GetYaxis()->SetTitle("d#sigma (mb)");
550 fSecRecJetPtInclusive->Sumw2();
551 fOutputList->Add(fSecRecJetPtInclusive);
552
553 fSecRecJetPtLeading = new TH1F("fSecRecJetPtLeading", "p_{T} distribution of leading reco jets (2nd branch)", 60, 0., 300.);
554 fSecRecJetPtLeading->GetXaxis()->SetTitle("p_{T} (GeV/c)");
555 fSecRecJetPtLeading->GetYaxis()->SetTitle("d#sigma (mb)");
556 fSecRecJetPtLeading->Sumw2();
557 fOutputList->Add(fSecRecJetPtLeading);
558
559 fNChTrMCPerp = new TH2F("fNChTrMCPerp","Number of tracks to recover transverse energy of perp. cone, jet_{p_{T} MC}",101,-0.5,100.5, 60, 0., 300.);
560 fNChTrMCPerp->GetXaxis()->SetTitle("NTracks Perp");
561 fNChTrMCPerp->GetYaxis()->SetTitle("p_{T}^{MC JET}");
562 fNChTrMCPerp->Sumw2();
563 fOutputList->Add(fNChTrMCPerp);
564
565 fNChTrRecPerp = new TH2F("fNChTrRecPerp","Number of tracks to recover transverse energy of perp. cone, jet_{p_{T} Rec}",101,-0.5,100.5, 60, 0., 300.);
566 fNChTrRecPerp->GetXaxis()->SetTitle("NTracks Perp");
567 fNChTrRecPerp->GetYaxis()->SetTitle("p_{T}^{RECO JET}");
568 fNChTrRecPerp->Sumw2();
569 fOutputList->Add(fNChTrRecPerp);
570
571 fSCMMCPerp = new TH2F("fSCMMCPerp","Second Central Moment of perp. cone, jet_{p_{T} MC}",200,0.,0.2, 60, 0., 300.);
572 fSCMMCPerp->GetXaxis()->SetTitle("<#delta R_{c}^{2}> Perp");
573 fSCMMCPerp->GetYaxis()->SetTitle("p_{T}^{JET}");
574 fSCMMCPerp->Sumw2();
575 fOutputList->Add(fSCMMCPerp);
576
577 fSCMRecPerp = new TH2F("fSCMRecPerp","Second Central Moment of perp. cone, jet_{p_{T} Reco}",200,0.,0.2, 60, 0., 300.);
578 fSCMRecPerp->GetXaxis()->SetTitle("<#delta R_{c}^{2}> Perp");
579 fSCMRecPerp->GetYaxis()->SetTitle("p_{T}^{JET}");
580 fSCMRecPerp->Sumw2();
581 fOutputList->Add(fSCMRecPerp);
582
583 fNChTrCorrMCQuark = new TH2F("fNChTrCorrMCQuark","Number of tracks to recover corrected transverse energy, MC quarks",101,-0.5,100.5, 60, 0., 300.);
584 fNChTrCorrMCQuark->GetXaxis()->SetTitle("NTracks");
585 fNChTrCorrMCQuark->GetYaxis()->SetTitle("p_{T}^{MC Corr. JET}");
586 fNChTrCorrMCQuark->Sumw2();
587 fOutputList->Add(fNChTrCorrMCQuark);
588
589 fNChTrCorrMCGluon = new TH2F("fNChTrCorrMCGluon","Number of tracks to recover corrected transverse energy, MC gluons",101,-0.5,100.5, 60, 0., 300.);
590 fNChTrCorrMCGluon->GetXaxis()->SetTitle("NTracks");
591 fNChTrCorrMCGluon->GetYaxis()->SetTitle("p_{T}^{MC Corr. JET}");
592 fNChTrCorrMCGluon->Sumw2();
593 fOutputList->Add(fNChTrCorrMCGluon);
594
595 fNChTrCorrMCPerp = new TH2F("fNChTrCorrMCPerp","Number of tracks to recover perp. cone. after corrected jet pT",101,-0.5,100.5, 60, 0., 300.);
596 fNChTrCorrMCPerp->GetXaxis()->SetTitle("NTracks");
597 fNChTrCorrMCPerp->GetYaxis()->SetTitle("p_{T}^{MC Corr. JET}");
598 fNChTrCorrMCPerp->Sumw2();
599 fOutputList->Add(fNChTrCorrMCPerp);
600
601 // 9 selection bins: (nuevo)
602 // 1st. Proton collisions fill 1 Bin1 [0.5,1.5)
603 // 2nd. PbPb collisions, Bin 0-10 fill 2 Bin2 [1.5,2.5)
604 // 3rd. PbPb collisions, Bin 10-20 fill 3 Bin3 [2.5,3.5)
605 // 4rd. PbPb collisions, Bin 20-30 fill 4 Bin4 [3.5,4.5)
606 // 5th. PbPb collisions, Bin 30-40 fill 5 Bin5 [4.5,5.5)
607 // 6th. PbPb collisions, Bin 40-50 fill 6 Bin6 [5.5,6.5)
608 // 7th. PbPb collisions, Bin 50-60 fill 7 Bin7 [6.5,7.5)
609 // 8th. PbPb collisions, Bin 60-70 fill 8 Bin8 [7.5,8.5)
610 // 9th. PbPb collisions, Bin 70-80 fill 9 Bin9 [8.5,9.5)
611 // 10th. PbPb collisions, Bin 80-100.1 fill 10 Bin10 [9.5,10.5)
612
613 fNChTrRecECorr = new TH3F("fNChTrRecECorr","NTX in ener. corr. jet , corr. jet pT, centrality",101,-0.5,100.5, 60, 0., 300.,10,0.5,10.5);
614 fNChTrRecECorr->GetXaxis()->SetTitle("NTracks");
615 fNChTrRecECorr->GetYaxis()->SetTitle("p_{T}^{JET}");
616 fNChTrRecECorr->GetZaxis()->SetTitle("Selection Bin");
617 fNChTrRecECorr->Sumw2();
618 fOutputList->Add(fNChTrRecECorr);
619
620 fNChTrRecPerpECorr = new TH3F("fNChTrRecPerpECorr","Tracks above min in perp.cone , corr. jet pT, centrality",101,-0.5,100.5, 60, 0., 300.,10,0.5,10.5);
621 fNChTrRecPerpECorr->GetXaxis()->SetTitle("NTracks");
622 fNChTrRecPerpECorr->GetYaxis()->SetTitle("p_{T}^{JET}");
623 fNChTrRecPerpECorr->GetZaxis()->SetTitle("Selection Bin");
624 fNChTrRecPerpECorr->Sumw2();
625 fOutputList->Add(fNChTrRecPerpECorr);
626
627 fRefMult = new TH1F("fRefMult", "Reference multiplicity in the AOD", 301, -0.5, 300.5);
628 fRefMult->GetXaxis()->SetTitle("Reference multiplicity");
629 fRefMult->Sumw2();
630 fOutputList->Add(fRefMult);
631
632 fRefMultWOJet = new TH2F("fRefMultWOJet", "Reference multiplicity in the AOD, multiplicity without jets", 301, -0.5, 300.5, 301, -0.5, 300.5);
633 fRefMultWOJet->GetXaxis()->SetTitle("Reference multiplicity");
634 fRefMultWOJet->GetYaxis()->SetTitle("Multiplicity without jets");
635 fRefMultWOJet->Sumw2();
636 fOutputList->Add(fRefMultWOJet);
637
638 fVZEROMult = new TH2F("fVZEROMult", "Multiplicity V0A and V0C", 501, -0.5, 500.5, 501, -0.5, 500.5);
639 fVZEROMult->GetXaxis()->SetTitle("Multiplicity V0A");
640 fVZEROMult->GetYaxis()->SetTitle("Multiplicity V0C");
641 fVZEROMult->Sumw2();
642 fOutputList->Add(fVZEROMult);
643
644 fMultWOJetVZero = new TH2F("fMultWOJetVZero", "Multiplicity without jets and VZERO mult.",301, -0.5, 300.5, 1001, -0.5, 1000.5);
645 fMultWOJetVZero->GetXaxis()->SetTitle("Multiplicity without jets TPC");
646 fMultWOJetVZero->GetYaxis()->SetTitle("Multiplicity full V0");
647 fMultWOJetVZero->Sumw2();
648 fOutputList->Add(fMultWOJetVZero);
649
650 fRefMultFullV0 = new TH2F("fRefMultFullV0", "Reference multiplicity in the AOD, multiplicity from full V0",301, -0.5, 300.5, 1001, -0.5, 1000.5);
651 fRefMultFullV0->GetXaxis()->SetTitle("Reference multiplicity in AOD");
652 fRefMultFullV0->GetYaxis()->SetTitle("Multiplicity full V0");
653 fRefMultFullV0->Sumw2();
654 fOutputList->Add(fRefMultFullV0);
655
656 fRefMultV0Corr = new TH2F("fRefMultV0Corr", "Reference multiplicity in the AOD, multiplicity from corrected V0",301, -0.5, 300.5, 1001, -0.5, 1000.5);
657 fRefMultV0Corr->GetXaxis()->SetTitle("Reference multiplicity in AOD");
658 fRefMultV0Corr->GetYaxis()->SetTitle("Multiplicity V0 no jets");
659 fRefMultV0Corr->Sumw2();
660 fOutputList->Add(fRefMultV0Corr);
661
662 fFullV0V0Corr = new TH2F("fFullV0V0Corr", "Multiplicity from full V0, multiplicity from corrected V0",1001, -0.5, 1000.5, 1001, -0.5, 1000.5);
663 fFullV0V0Corr->GetXaxis()->SetTitle("Multiplicity from full V0");
664 fFullV0V0Corr->GetYaxis()->SetTitle("Multiplicity V0 no jets");
665 fFullV0V0Corr->Sumw2();
666 fOutputList->Add(fFullV0V0Corr);
667
668 fNTXV0MultPt = new TH3F("fNTXV0MultPt", "NTX, Multiplicity from corrected V0, jet pT",101,-0.5,100.5, 1001, -0.5, 1000.5, 60, 0., 300.);
669 fNTXV0MultPt->GetXaxis()->SetTitle("NTracks");
670 fNTXV0MultPt->GetYaxis()->SetTitle("Multiplicity V0 no jets");
671 fNTXV0MultPt->GetZaxis()->SetTitle("p_{T}^{JET}");
672 fNTXV0MultPt->Sumw2();
673 fOutputList->Add(fNTXV0MultPt);
674
675 fNTXCBMultPt = new TH3F("fNTXCBMultPt", "NTX, Multiplicity from corrected Central Barrel, jet pT",101,-0.5,100.5, 301, -0.5, 300.5, 60, 0., 300.);
676 fNTXCBMultPt->GetXaxis()->SetTitle("NTracks");
677 fNTXCBMultPt->GetYaxis()->SetTitle("Multiplicity corrected Central Barrel");
678 fNTXCBMultPt->GetZaxis()->SetTitle("p_{T}^{JET}");
679 fNTXCBMultPt->Sumw2();
680 fOutputList->Add(fNTXCBMultPt);
681
682 fRefMultFullV0UJ = new TH2F("fRefMultFullV0UJ", "Reference multiplicity in the AOD, multiplicity from full V0, 1 jet event",301, -0.5, 300.5, 1001, -0.5, 1000.5);
683 fRefMultFullV0UJ->GetXaxis()->SetTitle("Reference multiplicity in AOD");
684 fRefMultFullV0UJ->GetYaxis()->SetTitle("Multiplicity full V0");
685 fRefMultFullV0UJ->Sumw2();
686 fOutputList->Add(fRefMultFullV0UJ);
687
688 fRefMultV0CorrUJ = new TH2F("fRefMultV0CorrUJ", "Reference multiplicity in the AOD, multiplicity from corrected V0, 1 jet event",301, -0.5, 300.5, 1001, -0.5, 1000.5);
689 fRefMultV0CorrUJ->GetXaxis()->SetTitle("Reference multiplicity in AOD");
690 fRefMultV0CorrUJ->GetYaxis()->SetTitle("Multiplicity V0 no jets");
691 fRefMultV0CorrUJ->Sumw2();
692 fOutputList->Add(fRefMultV0CorrUJ);
693
694 fFullV0V0CorrUJ = new TH2F("fFullV0V0CorrUJ", "Multiplicity from full V0, multiplicity from corrected V0, 1 jet event",1001, -0.5, 1000.5, 1001, -0.5, 1000.5);
695 fFullV0V0CorrUJ->GetXaxis()->SetTitle("Multiplicity from full V0");
696 fFullV0V0CorrUJ->GetYaxis()->SetTitle("Multiplicity V0 no jets");
697 fFullV0V0CorrUJ->Sumw2();
698 fOutputList->Add(fFullV0V0CorrUJ);
699
700 fMultWOJetVZeroUJ = new TH2F("fMultWOJetVZeroUJ", "Multiplicity without jets and VZERO mult., 1 jet event",301, -0.5, 300.5, 1001, -0.5, 1000.5);
701 fMultWOJetVZeroUJ->GetXaxis()->SetTitle("Multiplicity without jets TPC");
702 fMultWOJetVZeroUJ->GetYaxis()->SetTitle("Multiplicity full V0");
703 fMultWOJetVZeroUJ->Sumw2();
704 fOutputList->Add(fMultWOJetVZeroUJ);
705
706 fRefMultWOJetUJ = new TH2F("fRefMultWOJetUJ", "Reference multiplicity in the AOD, multiplicity without jets, 1 jet event", 301, -0.5, 300.5, 301, -0.5, 300.5);
707 fRefMultWOJetUJ->GetXaxis()->SetTitle("Reference multiplicity");
708 fRefMultWOJetUJ->GetYaxis()->SetTitle("Multiplicity without jets");
709 fRefMultWOJetUJ->Sumw2();
710 fOutputList->Add(fRefMultWOJetUJ);
711
712 fRefAODTrackCount = new TH2F("fRefAODTrackCount", "Reference multiplicity in the AOD, my own referece mult.", 301, -0.5, 300.5, 301, -0.5, 300.5);
713 fRefAODTrackCount->GetXaxis()->SetTitle("AOD Reference multiplicity");
714 fRefAODTrackCount->GetYaxis()->SetTitle("My Reference multiplicity");
715 fRefAODTrackCount->Sumw2();
716 fOutputList->Add(fRefAODTrackCount);
717
718 fRefAODTrackCountUJ = new TH2F("fRefAODTrackCountUJ", "Reference multiplicity in the AOD, my own referece mult., 1 jet event", 301, -0.5, 300.5, 301, -0.5, 300.5);
719 fRefAODTrackCountUJ->GetXaxis()->SetTitle("AOD Reference multiplicity");
720 fRefAODTrackCountUJ->GetYaxis()->SetTitle("My Reference multiplicity");
721 fRefAODTrackCountUJ->Sumw2();
722 fOutputList->Add(fRefAODTrackCountUJ);
723
724 fTrackCountWOJet = new TH2F("fTrackCountWOJet", "My own total referece mult., soft mult", 151, -0.5, 150.5, 151, -0.5, 150.5);
725 fTrackCountWOJet->GetXaxis()->SetTitle("Total TPC multiplicity");
726 fTrackCountWOJet->GetYaxis()->SetTitle("Soft TPC multiplicity");
727 fTrackCountWOJet->Sumw2();
728 fOutputList->Add(fTrackCountWOJet);
729
730 fTrackCountWOJetUJ = new TH2F("fTrackCountWOJetUJ", "My own total referece mult., soft mult, 1 jet", 151, -0.5, 150.5, 151, -0.5, 150.5);
731 fTrackCountWOJetUJ->GetXaxis()->SetTitle("Total TPC multiplicity");
732 fTrackCountWOJetUJ->GetYaxis()->SetTitle("Soft TPC multiplicity");
733 fTrackCountWOJetUJ->Sumw2();
734 fOutputList->Add(fTrackCountWOJetUJ);
735
736 fTrackCountWOJetUJMC = new TH2F("fTrackCountWOJetUJMC", "My own total referece mult., soft mult, 1 jet, MC!", 151, -0.5, 150.5, 151, -0.5, 150.5);
737 fTrackCountWOJetUJMC->GetXaxis()->SetTitle("Total TPC (eta) multiplicity");
738 fTrackCountWOJetUJMC->GetYaxis()->SetTitle("Soft TPC (eta) multiplicity");
739 fTrackCountWOJetUJMC->Sumw2();
740 fOutputList->Add(fTrackCountWOJetUJMC);
741
742 fFullV0V0CorrUJMC = new TH2F("fFullV0V0CorrUJMC", "Multiplicity from full V0, multiplicity from corrected V0, 1 jet event, MC!",1001, -0.5, 1000.5, 1001, -0.5, 1000.5);
743 fFullV0V0CorrUJMC->GetXaxis()->SetTitle("Multiplicity from full V0 (acceptance)");
744 fFullV0V0CorrUJMC->GetYaxis()->SetTitle("Multiplicity V0(acceptance) no jets");
745 fFullV0V0CorrUJMC->Sumw2();
746 fOutputList->Add(fFullV0V0CorrUJMC);
747
8dcbcbbb 748 fMinTrackPtInNTXRecalc = new TH3F("fMinTrackPtInNTXRecalc", "Minimum track pT for the jets after pT correction, raw jet pT", 200, 0., 100., 60, 0., 300.,10,0.5,10.5);
0c9acc4c 749 fMinTrackPtInNTXRecalc->GetXaxis()->SetTitle("p_{T}^{TRACK} (GeV/c)");
750 fMinTrackPtInNTXRecalc->GetYaxis()->SetTitle("p_{T}^{JET} (GeV/c)");
8dcbcbbb 751 fMinTrackPtInNTXRecalc->GetZaxis()->SetTitle("Selection Bin"); // 9 selections bins as fNChTrRecECorr
0c9acc4c 752 fMinTrackPtInNTXRecalc->Sumw2();
753 fOutputList->Add(fMinTrackPtInNTXRecalc);
754
755 fMaxTrackPtInNTXRecalc = new TH2F("fMaxTrackPtInNTXRecalc", "Maximum track pT for the jets after pT correction, raw jet pT", 200, 0., 100., 60, 0., 300.);
756 fMaxTrackPtInNTXRecalc->GetXaxis()->SetTitle("p_{T}^{TRACK} (GeV/c)");
757 fMaxTrackPtInNTXRecalc->GetYaxis()->SetTitle("p_{T}^{JET} (GeV/c)");
758 fMaxTrackPtInNTXRecalc->Sumw2();
759 fOutputList->Add(fMaxTrackPtInNTXRecalc);
760
761 fPtDistInJetConeRaw = new TH3F("fPtDistInJetConeRaw","pT of tracks in cone, raw jet pT bin, centrality", 200, 0., 100., 8, 0.5, 8.5, 10, 0.5, 10.5);
762 fPtDistInJetConeRaw->GetXaxis()->SetTitle("p_{T}^{TRACK} (GeV/c)");
763 fPtDistInJetConeRaw->GetYaxis()->SetTitle("p_{T}^{JET} Bin");
764 fPtDistInJetConeRaw->GetZaxis()->SetTitle("Centrality Bin");
765 fPtDistInJetConeRaw->Sumw2();
766 fOutputList->Add(fPtDistInJetConeRaw);
767
768 fPtDistInPerpConeRaw = new TH3F("fPtDistInPerpConeRaw","pT of tracks in cone, raw jet pT bin, centrality", 200, 0., 100., 8, 0.5, 8.5, 10, 0.5, 10.5);
769 fPtDistInPerpConeRaw->GetXaxis()->SetTitle("p_{T}^{TRACK} (GeV/c)");
770 fPtDistInPerpConeRaw->GetYaxis()->SetTitle("p_{T}^{JET} Bin");
771 fPtDistInPerpConeRaw->GetZaxis()->SetTitle("Centrality Bin");
772 fPtDistInPerpConeRaw->Sumw2();
773 fOutputList->Add(fPtDistInPerpConeRaw);
774
775 fPtInPerpCon = new TH3F("fPtInPerpCon","Summed pT of perpendicular cone, raw jet pT bin, centrality", 200, 0., 100., 8, 0.5, 8.5, 10, 0.5, 10.5);
776 fPtInPerpCon->GetXaxis()->SetTitle("p_{T}^{PERP.CONE} (GeV/c)");
777 fPtInPerpCon->GetYaxis()->SetTitle("p_{T}^{JET} Bin");
778 fPtInPerpCon->GetZaxis()->SetTitle("Centrality Bin");
779 fPtInPerpCon->Sumw2();
780 fOutputList->Add(fPtInPerpCon);
781
782 fJetEtaAll = new TH1F("fJetEtaAll", "Eta distribution of reconstructed jets, no cuts", 50, -1.5, 1.5);
783 fJetEtaAll->GetXaxis()->SetTitle("#eta");
784 fJetEtaAll->GetYaxis()->SetTitle("entries");
785 fJetEtaAll->Sumw2();
786 fOutputList->Add(fJetEtaAll);
787
788 fJetEtaOnlyTPCcut = new TH1F("fJetEtaOnlyTPCcut", "Eta distribution of reconstructed jets, only tpc acceptance cut", 50, -1.5, 1.5);
789 fJetEtaOnlyTPCcut->GetXaxis()->SetTitle("#eta");
790 fJetEtaOnlyTPCcut->GetYaxis()->SetTitle("entries");
791 fJetEtaOnlyTPCcut->Sumw2();
792 fOutputList->Add(fJetEtaOnlyTPCcut);
793
794 // 9 multiplicity bins
795 // 1st. <5 TPC tracks fill 1 Bin1 [0.5,1.5)
796 // 2nd. >= 5 <10 TPC tracks fill 2 Bin2 [1.5,2.5)
797 // 3rd. >= 10 <15 TPC tracks fill 3 Bin3 [2.5,3.5)
798 // 4rd. >= 15 <20 TPC tracks fill 4 Bin4 [3.5,4.5)
799 // 5th. >= 20 <30 TPC tracks fill 5 Bin5 [4.5,5.5)
800 // 6th. >= 30 <40 TPC tracks fill 6 Bin6 [5.5,6.5)
801 // 7th. >= 40 <50 TPC tracks fill 7 Bin7 [6.5,7.5)
802 // 8th. >50 TPC tracks fill 8 Bin8 [7.5,8.5)
803
804 fNChTrRecECorrPPMult = new TH3F("fNChTrRecECorrPPMult","NTX in ener. corr. jet , corr. jet pT, pp mult.",101,-0.5,100.5, 60, 0., 300.,8,0.5,8.5);
805 fNChTrRecECorrPPMult->GetXaxis()->SetTitle("NTracks_Corrected");
806 fNChTrRecECorrPPMult->GetYaxis()->SetTitle("p_{T}^{JET}");
807 fNChTrRecECorrPPMult->GetZaxis()->SetTitle("Multiplicity Bin");
808 fNChTrRecECorrPPMult->Sumw2();
809 fOutputList->Add(fNChTrRecECorrPPMult);
810
811 fNChTrRecPerpECorrPPMult = new TH3F("fNChTrRecPerpECorrPPMult","Tracks above min in perp.cone , corr. jet pT, centrality",101,-0.5,100.5, 60, 0., 300.,8,0.5,8.5);
812 fNChTrRecPerpECorrPPMult->GetXaxis()->SetTitle("NTracks_Corrected");
813 fNChTrRecPerpECorrPPMult->GetYaxis()->SetTitle("p_{T}^{JET}");
814 fNChTrRecPerpECorrPPMult->GetZaxis()->SetTitle("Multiplicity Bin");
815 fNChTrRecPerpECorrPPMult->Sumw2();
816 fOutputList->Add(fNChTrRecPerpECorrPPMult);
817
8dcbcbbb 818 fJetPtCentPbPbRaw = new TH2F("fJetPtCentPbPbRaw", "raw p_{T} distribution of reco jets", 60, 0., 300.,10,0.5,10.5);
819 fJetPtCentPbPbRaw->GetXaxis()->SetTitle("p_{T} (GeV/c)");
820 fJetPtCentPbPbRaw->GetYaxis()->SetTitle("Selection Bin");
821 fJetPtCentPbPbRaw->Sumw2();
822 fOutputList->Add(fJetPtCentPbPbRaw);
823
824 fJetPtCentPbPbCorr = new TH2F("fJetPtCentPbPbCorr", "Corrected p_{T} distribution of reco jets", 60, 0., 300.,10,0.5,10.5);
825 fJetPtCentPbPbCorr->GetXaxis()->SetTitle("p_{T} (GeV/c)");
826 fJetPtCentPbPbCorr->GetYaxis()->SetTitle("Selection Bin");
827 fJetPtCentPbPbCorr->Sumw2();
828 fOutputList->Add(fJetPtCentPbPbCorr);
829
17f4943e 830 fTotTracksCone = new TH3F("fTotTracksCone","Total number of tracks in the cone, raw jet pT bin, centrality", 200, 0.5, 200.5, 8, 0.5, 8.5, 10, 0.5, 10.5);
831 fTotTracksCone->GetXaxis()->SetTitle("NTracks");
832 fTotTracksCone->GetYaxis()->SetTitle("p_{T}^{JET} Bin");
833 fTotTracksCone->GetZaxis()->SetTitle("Centrality Bin");
834 fTotTracksCone->Sumw2();
835 fOutputList->Add(fTotTracksCone);
836
0c9acc4c 837 for(Int_t ipt=0;ipt<12;ipt++)
838 {
839 fNChTr[ipt] = new TH2F(Form("fNChTr[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
840 fNChTr[ipt]->GetXaxis()->SetTitle("NTracks");
841 fNChTr[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
842 fNChTr[ipt]->Sumw2();
843 fOutputList->Add(fNChTr[ipt]);
844
845 fHistPtParton[ipt] = new TH1F(Form("fHistPtParton[%i]",ipt),"pT distribution of jets",50,0.,250.);
846 fHistPtParton[ipt]->GetXaxis()->SetTitle("p_{T}^{JET}");
847 fHistPtParton[ipt]->GetYaxis()->SetTitle("Entries");
848 fHistPtParton[ipt]->Sumw2();
849 fOutputList->Add(fHistPtParton[ipt]);
850
851 fSCM[ipt] = new TH2F(Form("fSCM[%i]",ipt),"Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
852 fSCM[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
853 fSCM[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
854 fSCM[ipt]->Sumw2();
855 fOutputList->Add(fSCM[ipt]);
856
857 if(ipt<8)
858 {
859 fNChTrRDMult[ipt] = new TH2F(Form("fNChTrRDMult[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
860 fNChTrRDMult[ipt]->GetXaxis()->SetTitle("NTracks");
861 fNChTrRDMult[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
862 fNChTrRDMult[ipt]->Sumw2();
863 fOutputList->Add(fNChTrRDMult[ipt]);
864
865 fNAccJetsRDMult[ipt] = new TH1F(Form("fNAccJetsRDMult[%i]",ipt),"Number of accepted jets per event in real data", 101, -0.5, 100.5);
866 fNAccJetsRDMult[ipt]->GetXaxis()->SetTitle("Number of jets");
867 fNAccJetsRDMult[ipt]->Sumw2();
868 fOutputList->Add(fNAccJetsRDMult[ipt]);
869
870 fTotalJetCharge[ipt] = new TH1F(Form("fTotalJetCharge[%i]",ipt),"Charge in the jet", 41, -20.5, 20.5);
871 fTotalJetCharge[ipt]->GetXaxis()->SetTitle("Charge in jet");
872 fTotalJetCharge[ipt]->Sumw2();
873 fOutputList->Add(fTotalJetCharge[ipt]);
874
875 fSCMRDMult[ipt] = new TH2F(Form("fSCMRDMult[%i]",ipt),"Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
876 fSCMRDMult[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
877 fSCMRDMult[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
878 fSCMRDMult[ipt]->Sumw2();
879 fOutputList->Add(fSCMRDMult[ipt]);
880
881 fNChTrRDMultMC[ipt] = new TH2F(Form("fNChTrRDMultMC[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
882 fNChTrRDMultMC[ipt]->GetXaxis()->SetTitle("NTracks");
883 fNChTrRDMultMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
884 fNChTrRDMultMC[ipt]->Sumw2();
885 fOutputList->Add(fNChTrRDMultMC[ipt]);
886
887 fSCMRDMultMC[ipt] = new TH2F(Form("fSCMRDMultMC[%i]",ipt),"Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
888 fSCMRDMultMC[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
889 fSCMRDMultMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
890 fSCMRDMultMC[ipt]->Sumw2();
891 fOutputList->Add(fSCMRDMultMC[ipt]);
892
893 //Second multiplicity estimator, removing jets and an area
894 fNChTrRDMultSE[ipt] = new TH2F(Form("fNChTrRDMultSE[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
895 fNChTrRDMultSE[ipt]->GetXaxis()->SetTitle("NTracks");
896 fNChTrRDMultSE[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
897 fNChTrRDMultSE[ipt]->Sumw2();
898 fOutputList->Add(fNChTrRDMultSE[ipt]);
899
900 fNAccJetsRDMultSE[ipt] = new TH1F(Form("fNAccJetsRDMultSE[%i]",ipt),"Number of accepted jets per event in real data", 101, -0.5, 100.5);
901 fNAccJetsRDMultSE[ipt]->GetXaxis()->SetTitle("Number of jets");
902 fNAccJetsRDMultSE[ipt]->Sumw2();
903 fOutputList->Add(fNAccJetsRDMultSE[ipt]);
904
905 fTotalJetChargeSE[ipt] = new TH1F(Form("fTotalJetChargeSE[%i]",ipt),"Charge in the jet", 41, -20.5, 20.5);
906 fTotalJetChargeSE[ipt]->GetXaxis()->SetTitle("Charge in jet");
907 fTotalJetChargeSE[ipt]->Sumw2();
908 fOutputList->Add(fTotalJetChargeSE[ipt]);
909
910 fSCMRDMultSE[ipt] = new TH2F(Form("fSCMRDMultSE[%i]",ipt),"Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
911 fSCMRDMultSE[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
912 fSCMRDMultSE[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
913 fSCMRDMultSE[ipt]->Sumw2();
914 fOutputList->Add(fSCMRDMultSE[ipt]);
915
916 fNChTrRDMultOJ[ipt] = new TH2F(Form("fNChTrRDMultOJ[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}, 1 jet}",101,-0.5,100.5, 60, 0., 300.);
917 fNChTrRDMultOJ[ipt]->GetXaxis()->SetTitle("NTracks");
918 fNChTrRDMultOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
919 fNChTrRDMultOJ[ipt]->Sumw2();
920 fOutputList->Add(fNChTrRDMultOJ[ipt]);
921
922 fSCMRDMultOJ[ipt] = new TH2F(Form("fSCMRDMultOJ[%i]",ipt),"Second Central Moment, jet_{p_{T}}, 1 jet",200,0.,0.2, 60, 0., 300.);
923 fSCMRDMultOJ[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
924 fSCMRDMultOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
925 fSCMRDMultOJ[ipt]->Sumw2();
926 fOutputList->Add(fSCMRDMultOJ[ipt]);
927
928 fNChTrRDMultSEOJ[ipt] = new TH2F(Form("fNChTrRDMultSEOJ[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}, 1 jet",101,-0.5,100.5, 60, 0., 300.);
929 fNChTrRDMultSEOJ[ipt]->GetXaxis()->SetTitle("NTracks");
930 fNChTrRDMultSEOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
931 fNChTrRDMultSEOJ[ipt]->Sumw2();
932 fOutputList->Add(fNChTrRDMultSEOJ[ipt]);
933
934 fSCMRDMultSEOJ[ipt] = new TH2F(Form("fSCMRDMultSEOJ[%i]",ipt),"Second Central Moment, jet_{p_{T}}, 1 jet",200,0.,0.2, 60, 0., 300.);
935 fSCMRDMultSEOJ[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
936 fSCMRDMultSEOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
937 fSCMRDMultSEOJ[ipt]->Sumw2();
938 fOutputList->Add(fSCMRDMultSEOJ[ipt]);
939
940 fNChTrRDMultOJMC[ipt] = new TH2F(Form("fNChTrRDMultOJMC[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}, 1 jet, MC}",101,-0.5,100.5, 60, 0., 300.);
941 fNChTrRDMultOJMC[ipt]->GetXaxis()->SetTitle("NTracks");
942 fNChTrRDMultOJMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
943 fNChTrRDMultOJMC[ipt]->Sumw2();
944 fOutputList->Add(fNChTrRDMultOJMC[ipt]);
945
946 fSCMRDMultOJMC[ipt] = new TH2F(Form("fSCMRDMultOJMC[%i]",ipt),"Second Central Moment, jet_{p_{T}}, 1 jet, MC",200,0.,0.2, 60, 0., 300.);
947 fSCMRDMultOJMC[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
948 fSCMRDMultOJMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
949 fSCMRDMultOJMC[ipt]->Sumw2();
950 fOutputList->Add(fSCMRDMultOJMC[ipt]);
951
952 fNChTrRDMultSEOJMC[ipt] = new TH2F(Form("fNChTrRDMultSEOJMC[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}, 1 jet, MC",101,-0.5,100.5, 60, 0., 300.);
953 fNChTrRDMultSEOJMC[ipt]->GetXaxis()->SetTitle("NTracks");
954 fNChTrRDMultSEOJMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
955 fNChTrRDMultSEOJMC[ipt]->Sumw2();
956 fOutputList->Add(fNChTrRDMultSEOJMC[ipt]);
957
958 fSCMRDMultSEOJMC[ipt] = new TH2F(Form("fSCMRDMultSEOJMC[%i]",ipt),"Second Central Moment, jet_{p_{T}}, 1 jet, MC",200,0.,0.2, 60, 0., 300.);
959 fSCMRDMultSEOJMC[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
960 fSCMRDMultSEOJMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
961 fSCMRDMultSEOJMC[ipt]->Sumw2();
962 fOutputList->Add(fSCMRDMultSEOJMC[ipt]);
963
964 fNChTrRecPerpMultSEOJ[ipt] = new TH2F(Form("fNChTrRecPerpMultSEOJ[%i]",ipt),"Number of tracks above the min pT used in NTX_Raw, jet_{p_{T}}, 1 jet",101,-0.5,100.5, 60, 0., 300.);
965 fNChTrRecPerpMultSEOJ[ipt]->GetXaxis()->SetTitle("NTracks_{Exc.}");
966 fNChTrRecPerpMultSEOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
967 fNChTrRecPerpMultSEOJ[ipt]->Sumw2();
968 fOutputList->Add(fNChTrRecPerpMultSEOJ[ipt]);
17f4943e 969
970 fJEtaMCMultOJ[ipt] = new TH1F(Form("fJEtaMCMultOJ[%i]",ipt), "Eta distribution of MC jets, V0-like mult. bins, 1 jet", 50, -1.5, 1.5);
971 fJEtaMCMultOJ[ipt]->GetXaxis()->SetTitle("#eta");
972 fJEtaMCMultOJ[ipt]->GetYaxis()->SetTitle("entries");
973 fJEtaMCMultOJ[ipt]->Sumw2();
974 fOutputList->Add(fJEtaMCMultOJ[ipt]);
975
976 fJEtaMCMultSEOJ[ipt] = new TH1F(Form("fJEtaMCMultSEOJ[%i]",ipt), "Eta distribution of MC jets, TPC-like mult. bins, 1 jet", 50, -1.5, 1.5);
977 fJEtaMCMultSEOJ[ipt]->GetXaxis()->SetTitle("#eta");
978 fJEtaMCMultSEOJ[ipt]->GetYaxis()->SetTitle("entries");
979 fJEtaMCMultSEOJ[ipt]->Sumw2();
980 fOutputList->Add(fJEtaMCMultSEOJ[ipt]);
981
982 fJEtaRDMultOJ[ipt] = new TH1F(Form("fJEtaRDMultOJ[%i]",ipt), "Eta distribution of reco jets, V0 mult. bins, 1 jet", 50, -1.5, 1.5);
983 fJEtaRDMultOJ[ipt]->GetXaxis()->SetTitle("#eta");
984 fJEtaRDMultOJ[ipt]->GetYaxis()->SetTitle("entries");
985 fJEtaRDMultOJ[ipt]->Sumw2();
986 fOutputList->Add(fJEtaRDMultOJ[ipt]);
987
988 fJEtaRDMultSEOJ[ipt] = new TH1F(Form("fJEtaRDMultSEOJ[%i]",ipt), "Eta distribution of reco jets, TPC mult. bins, 1 jet", 50, -1.5, 1.5);
989 fJEtaRDMultSEOJ[ipt]->GetXaxis()->SetTitle("#eta");
990 fJEtaRDMultSEOJ[ipt]->GetYaxis()->SetTitle("entries");
991 fJEtaRDMultSEOJ[ipt]->Sumw2();
992 fOutputList->Add(fJEtaRDMultSEOJ[ipt]);
993
994 fJetPtMCMultOJ[ipt] = new TH1F(Form("fJetPtMCMultOJ[%i]",ipt), "pT distribution of MC jets, V0-like mult. bins, 1 jet", 60, 0., 300.);
995 fJetPtMCMultOJ[ipt]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
996 fJetPtMCMultOJ[ipt]->GetYaxis()->SetTitle("entries");
997 fJetPtMCMultOJ[ipt]->Sumw2();
998 fOutputList->Add(fJetPtMCMultOJ[ipt]);
999
1000 fJetPtMCMultSEOJ[ipt] = new TH1F(Form("fJetPtMCMultSEOJ[%i]",ipt), "pT distribution of MC jets, TPC-like mult. bins, 1 jet", 60, 0., 300.);
1001 fJetPtMCMultSEOJ[ipt]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
1002 fJetPtMCMultSEOJ[ipt]->GetYaxis()->SetTitle("entries");
1003 fJetPtMCMultSEOJ[ipt]->Sumw2();
1004 fOutputList->Add(fJetPtMCMultSEOJ[ipt]);
1005
1006 fJetPtRDMultOJ[ipt] = new TH1F(Form("fJetPtRDMultOJ[%i]",ipt), "pT distribution of reco jets, V0 mult. bins, 1 jet", 60, 0., 300.);
1007 fJetPtRDMultOJ[ipt]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
1008 fJetPtRDMultOJ[ipt]->GetYaxis()->SetTitle("entries");
1009 fJetPtRDMultOJ[ipt]->Sumw2();
1010 fOutputList->Add(fJetPtRDMultOJ[ipt]);
1011
1012 fJetPtRDMultSEOJ[ipt] = new TH1F(Form("fJetPtRDMultSEOJ[%i]",ipt), "pT distribution of reco jets, TPC mult. bins, 1 jet", 60, 0., 300.);
1013 fJetPtRDMultSEOJ[ipt]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
1014 fJetPtRDMultSEOJ[ipt]->GetYaxis()->SetTitle("entries");
1015 fJetPtRDMultSEOJ[ipt]->Sumw2();
1016 fOutputList->Add(fJetPtRDMultSEOJ[ipt]);
1017
1018 fEntriesQuark[ipt] = new TH2F(Form("fEntriesQuark[%i]",ipt),"NTX of quarks in multiplicity bins, 1 jet, MC",101,-0.5,100.5, 60, 0., 300.);
1019 fEntriesQuark[ipt]->GetXaxis()->SetTitle("NTracks");
1020 fEntriesQuark[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
1021 fEntriesQuark[ipt]->Sumw2();
1022 fOutputList->Add(fEntriesQuark[ipt]);
1023
1024 fEntriesGluon[ipt] = new TH2F(Form("fEntriesGluon[%i]",ipt),"NTX of gluons in multiplicity bins, 1 jet, MC",101,-0.5,100.5, 60, 0., 300.);
1025 fEntriesGluon[ipt]->GetXaxis()->SetTitle("NTracks");
1026 fEntriesGluon[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
1027 fEntriesGluon[ipt]->Sumw2();
1028 fOutputList->Add(fEntriesGluon[ipt]);
0c9acc4c 1029 } // end if <8
1030
1031 if(ipt<6) // only entries for reconstructed || simulated jets
1032 {
1033 fProcessPDG[ipt] = new TH2I(Form("fProcessPDG[%i]",ipt),"Pythia process and jet p_T", 60, 0., 300., 70, 0.5, 70.5);
1034 fProcessPDG[ipt]->GetXaxis()->SetTitle("p_{T}^{JET}");
1035 fProcessPDG[ipt]->GetYaxis()->SetTitle("Pythia process code");
1036 fProcessPDG[ipt]->Sumw2();
1037 fOutputList->Add(fProcessPDG[ipt]);
1038
1039 fFragPion[ipt] = new TH2F(Form("fFragPion[%i]",ipt),"Fragmentation in pions",35,0.,8.,50,0.,250.);
1040 fFragPion[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1041 fFragPion[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1042 fFragPion[ipt]->Sumw2();
1043 fOutputList->Add(fFragPion[ipt]);
1044
1045 fFragKaon[ipt] = new TH2F(Form("fFragKaon[%i]",ipt),"Fragmentation in kaons",35,0.,8.,50,0.,250.);
1046 fFragKaon[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1047 fFragKaon[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1048 fFragKaon[ipt]->Sumw2();
1049 fOutputList->Add(fFragKaon[ipt]);
1050
1051 fFragProton[ipt] = new TH2F(Form("fFragProton[%i]",ipt),"Fragmentation in protons",35,0.,8.,50,0.,250.);
1052 fFragProton[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1053 fFragProton[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1054 fFragProton[ipt]->Sumw2();
1055 fOutputList->Add(fFragProton[ipt]);
1056
1057 fFragChargedR4[ipt] = new TH2F(Form("fFragChargedR4[%i]",ipt),"Fragmentation in charged particles",35,0.,8.,50,0.,250.);
1058 fFragChargedR4[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1059 fFragChargedR4[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1060 fFragChargedR4[ipt]->Sumw2();
1061 fOutputList->Add(fFragChargedR4[ipt]);
1062
1063 fFragChargedR3[ipt] = new TH2F(Form("fFragChargedR3[%i]",ipt),"Fragmentation in charged particles",35,0.,8.,50,0.,250.);
1064 fFragChargedR3[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1065 fFragChargedR3[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1066 fFragChargedR3[ipt]->Sumw2();
1067 fOutputList->Add(fFragChargedR3[ipt]);
1068
1069 fFragChargedR2[ipt] = new TH2F(Form("fFragChargedR2[%i]",ipt),"Fragmentation in charged particles",35,0.,8.,50,0.,250.);
1070 fFragChargedR2[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1071 fFragChargedR2[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1072 fFragChargedR2[ipt]->Sumw2();
1073 fOutputList->Add(fFragChargedR2[ipt]);
1074
1075 // do not add the temporary containers
1076 fHistContainerR4[ipt] = new TH2F(Form("fHistContainerR4[%i]",ipt),"Temporary fragmentation in charged particles",35,0.,8.,50,0.,250.);
1077 fHistContainerR4[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1078 fHistContainerR4[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1079 fHistContainerR4[ipt]->Sumw2();
1080
1081 fHistContainerR3[ipt] = new TH2F(Form("fHistContainerR3[%i]",ipt),"Temporary fragmentation in charged particles",35,0.,8.,50,0.,250.);
1082 fHistContainerR3[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1083 fHistContainerR3[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1084 fHistContainerR3[ipt]->Sumw2();
1085
1086 fHistContainerR2[ipt] = new TH2F(Form("fHistContainerR2[%i]",ipt),"Temporary fragmentation in charged particles",35,0.,8.,50,0.,250.);
1087 fHistContainerR2[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1088 fHistContainerR2[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1089 fHistContainerR2[ipt]->Sumw2();
1090
1091 if(ipt<3)
1092 {
1093 fJetEtaJetPt[ipt] = new TH1F(Form("fJetEtaJetPt[%i]",ipt), "Eta distribution of reconstructed jets, all cut, with pT upper boundary", 50, -1.5, 1.5);
1094 fJetEtaJetPt[ipt]->GetXaxis()->SetTitle("#eta");
1095 fJetEtaJetPt[ipt]->GetYaxis()->SetTitle("entries");
1096 fJetEtaJetPt[ipt]->Sumw2();
1097 fOutputList->Add(fJetEtaJetPt[ipt]);
1098
1099 if(ipt<2)
1100 {
1101 fFragCandidates[ipt] = new TH2F(Form("fFragCandidates[%i]",ipt),"Parton identified candidates",35,0.,8.,50,0.,250.);
1102 fFragCandidates[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1103 fFragCandidates[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1104 fFragCandidates[ipt]->Sumw2();
1105 fOutputList->Add(fFragCandidates[ipt]);
1106
8dcbcbbb 1107 fMinTrackPtInNTXh[ipt] = new TH3F(Form("fMinTrackPtInNTXh[%i]",ipt), "Minimum track pT for the jets", 200, 0., 100., 60, 0., 300.,10,0.5,10.5);
0c9acc4c 1108 fMinTrackPtInNTXh[ipt]->GetXaxis()->SetTitle("p_{T}^{TRACK}");
1109 fMinTrackPtInNTXh[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
8dcbcbbb 1110 fMinTrackPtInNTXh[ipt]->GetZaxis()->SetTitle("Selection Bin"); //9 selection bins as fNChTrRecECorr
0c9acc4c 1111 fMinTrackPtInNTXh[ipt]->Sumw2();
1112 fOutputList->Add(fMinTrackPtInNTXh[ipt]);
1113
1114 fMaxTrackPtInNTXh[ipt] = new TH2F(Form("fMaxTrackPtInNTXh[%i]",ipt), "Maximum track pT for the jets", 200, 0., 100., 60, 0., 300.);
1115 fMaxTrackPtInNTXh[ipt]->GetXaxis()->SetTitle("p_{T}^{TRACK}");
1116 fMaxTrackPtInNTXh[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
1117 fMaxTrackPtInNTXh[ipt]->Sumw2();
1118 fOutputList->Add(fMaxTrackPtInNTXh[ipt]);
1119 } // index < 2
1120 } // index < 3
1121 } // index < 6
1122 } // index < 12
1123
1124 fPerpCone = new AliAODJet();
1125 fBckgSbsJet = new Double_t[3];
1126
1127 PostData(1, fOutputList); // Post data for ALL output slots >0 here, to get at least an empty histogram
1128}
1129
1130//________________________________________________________________________
1131void AliAnalysisTaskPartonDisc::UserExec(Option_t *)
1132{
1133 // Main loop
1134 // Called for each event
1135
1136 // fAOD
1137 if(fUseAODJetInput)
1138 {
1139 fAOD = dynamic_cast<AliAODEvent*>(InputEvent());
1140 if(!fAOD)
1141 {
1142 Printf("%s:%d AODEvent not found in Input Manager %d",(char*)__FILE__,__LINE__,fUseAODJetInput);
1143 return;
1144 }
1145 // fetch the header
1146 }
1147 else
1148 {
1149 // assume that the AOD is in the general output...
1150 fAOD = AODEvent();
1151 if(!fAOD)
1152 {
1153 Printf("%s:%d AODEvent not found in the Output",(char*)__FILE__,__LINE__);
1154 return;
1155 }
1156 }
1157
1158 // fin de test para fAOD
1159
1160 if(!fInputEvent)
1161 {
1162 Error("UserExec","No event found!");
1163 return;
1164 }
1165
1166 AliAODHandler *aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
1167 if(!aodHandler)
1168 {
1169 AliError("No AOD Handler!");
1170 return;
1171 }
1172
1173 fEventCent=900; //dummy val for debugging
1174
1175 if(fIsHIevent)
1176 {
0a918d8d 1177 AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
1178 if(!aodHeader) AliFatal("Not a standard AOD");
0c9acc4c 1179 fEventCent = aodHeader->GetCentrality();
1180 }
1181
17f4943e 1182 // Random number generator seeded per event
1183 TDatime dt;
1184 UInt_t curtime = dt.Get();
1185 UInt_t procid = gSystem->GetPid();
1186 UInt_t seed = curtime-procid;
1187 gRandom->SetSeed(seed);
1188
8dcbcbbb 1189 // Jet eta exclusion
1190 if(fIncreasingExcl)
1191 fJetAcceptance = 0.5 - fIncExcR; // if the increase is 0.1 -> only jets within |eta|<0.4
1192
0c9acc4c 1193 // First test of reference multiplicity
0a918d8d 1194 AliAODHeader * header = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
1195 if(!header) AliFatal("Not a standard AOD");
1196
1197 Int_t refMultiplicity = header->GetRefMultiplicity();
0c9acc4c 1198 fRefMult->Fill(refMultiplicity);
1199
1200 // Multiplicity from V0 (V0A+V0C)
1201 fVZero = fAOD->GetVZEROData();
1202 Float_t multV0A = 0.0;
1203 Float_t multV0C = 0.0;
1204 Float_t multFullV0 = 0.0;
1205 if(fVZero)
1206 {
1207 multV0A = fVZero->GetMTotV0A();
1208 multV0C = fVZero->GetMTotV0C();
1209 multFullV0 = multV0A+multV0C;
1210 }
1211 fVZEROMult->Fill(multV0A,multV0C);
1212
1213 fEvtCount++;
1214 Double_t jfr = fJetRadius; // radius used during jet finding
1215 Int_t ntx = fNtX; // NTX value
1216 const Int_t maxJetNum=6; // maximum number of generated jets to process
1217 AliAODJet genJets[6]; // containers for the
1218 AliAODJet recJets[6]; // correlation gen-reco
1219 Int_t nGenJets=0;
1220 Int_t nRecJets=0;
1221 Int_t genJetsFlavor[6]={0}; // flavor of the generated jets
1222 Int_t evtype = 0; //pythia event type
1223 // Variables para la variable de estructura
1224 Double_t deltaPhiPt = 0.0;
1225 Double_t deltaEtaPt = 0.0;
1226 Double_t deltaPhiSqPt = 0.0;
1227 Double_t deltaEtaSqPt = 0.0;
1228 Double_t totalTrackPt = 0.0;
1229 Double_t firstMomDeltPhi = 0.0;
1230 Double_t firstMomDeltEta = 0.0;
1231 Double_t secondMomDeltPhi = 0.0;
1232 Double_t secondMomDeltEta = 0.0;
1233 Double_t secondCentralPhi = 0.0;
1234 Double_t secondCentralEta = 0.0;
1235 Double_t secondCentralR = 0.0;
1236
1237 // Variables para la variable de estructura
1238 // del cono perpendicular
1239 Double_t deltaPhiPtPerp = 0.0;
1240 Double_t deltaEtaPtPerp = 0.0;
1241 Double_t deltaPhiSqPtPerp = 0.0;
1242 Double_t deltaEtaSqPtPerp = 0.0;
1243 Double_t totalTrackPtPerp = 0.0;
1244 Double_t firstMomDeltPhiPerp = 0.0;
1245 Double_t firstMomDeltEtaPerp = 0.0;
1246 Double_t secondMomDeltPhiPerp = 0.0;
1247 Double_t secondMomDeltEtaPerp = 0.0;
1248 Double_t secondCentralPhiPerp = 0.0;
1249 Double_t secondCentralEtaPerp = 0.0;
1250 Double_t secondCentralRPerp = 0.0;
1251
1252 Double_t perpendicularPt;
1253 Float_t px,py,pz,en; // jet 4-vector à la UA1
1254 Float_t pTbs, etabs, phibs; // energy corrected jet properties
1255
1256 // Process the MC info from the AOD
1257 if(fUseAODMC)
1258 {
1259 // Get the MC array
1260 TClonesArray *mcarray = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
1261 if(!mcarray)
1262 {
1263 AliError("ERROR:No MC info in the AOD input");
1264 return;
1265 }
1266
1267 AliMCEvent* mcEvent = MCEvent();
1268 if(mcEvent)
1269 {
1270 if(!fPhojetMC) // if it is pythia
1271 evtype = GetMCEventType(mcEvent);
1272 // From pythia 6.2 manual pp 414
1273 // QCD Hard Processes
1274 // 11 f_{i}+f_{j} -> f_{i}+f_{j} com77, ben84, eic84, chi90
1275 // 12 f_{i}+barf_{i} -> f_{k}+barf_{k}
1276 // 13 f_{i}+barf_{i} -> g+g
1277 // 28 f_{i}+g -> f_{i}+g
1278 // 53 g+g -> f_{k}+barf_{k}
1279 // 68 g+g -> g+g
1280 if(fPhojetMC) // if it is phojet
1281 evtype = GetPhojetEventType(mcEvent);
1282 }
1283 if(!mcEvent) // if a pure AOD event
1284 {
1285 AliDebug(2,Form("%s:%d No MCEvent \n",(char*)__FILE__,__LINE__));
1286 AliDebug(2,Form("Trying to get the MC header \n"));
1287 AliAODMCHeader *genEvH = static_cast<AliAODMCHeader*>(fAOD->FindListObject("mcHeader"));
1288 if(!genEvH)
1289 {
1290 AliDebug(2,Form(" %s:%d No Pythia header!",(char*)__FILE__,__LINE__));
1291 evtype = 0;
1292 }
1293 if(genEvH)
1294 evtype = genEvH->GetEventType();
1295 }
1296 // Get the branch with the MC jets
1297 TClonesArray *aodMCJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchMC.Data()));
1298 if(!aodMCJets)
1299 {
1300 AliDebug(2,Form("%s:%d no MC Jet array with name %s in AOD",(char*)__FILE__,__LINE__,fBranchMC.Data()));
1301 return;
1302 }
1303 AliDebug(2,Form("There are %d MC jets in this event\n", aodMCJets->GetEntries()));
1304 Int_t mcjets = aodMCJets->GetEntries();
1305 fNJetsMC->Fill(mcjets,mcjets); // number of jets FROM the branch, filled per event, this gives the event normalization...
1306 HasOverlapedCones(aodMCJets); // Procedure for tagging usable jets
1307 // Up 16 jets are flagged
1308
1309 // Loop over AODMC physical primary charged particles
1310 // for the complete event
1311 Int_t tracksMC = mcarray->GetEntriesFast();
1312 AliDebug(2,Form("There are %i tracks in the mcarray",tracksMC));
1313 Double_t aodMCTrackEta = 0.0;
1314 perpendicularPt = 0.0;
1315 px=0.0;
1316 py=0.0;
1317 pz=0.0;
1318 en=0.0;
1319 pTbs=0.0;
1320 etabs=0.0;
1321 phibs=0.0;
1322 fBckgSbsJet[0]=0.0;
1323 fBckgSbsJet[1]=0.0;
1324 fBckgSbsJet[2]=0.0;
1325 Int_t softRefMcNoJets = 0;
1326 Int_t myTotalMultiplicityMc = 0;
1327 Int_t v0LikeTotalMcMult = 0;
17f4943e 1328 Double_t randomNum = 0.;
0c9acc4c 1329 for(Int_t aodMCTrack = 0; aodMCTrack < tracksMC; aodMCTrack++ )
1330 {
1331 AliAODMCParticle *mctrackf = (AliAODMCParticle*) mcarray->At(aodMCTrack);
1332 if(!mctrackf) continue;
1333 if(!mctrackf->IsPhysicalPrimary()) continue;
1334 if(mctrackf->Charge()==0||mctrackf->Charge()==-99) continue;
17f4943e 1335 randomNum = gRandom->Rndm();
1336 if(randomNum<fTTrackRandomRejection) continue; //rechaza fTTrackRandomRejection
1337
0c9acc4c 1338 //Lo del V0, voy a contar particulas primarias cargadas
17f4943e 1339 if(mctrackf->Pt()>fMinpTValMC) // cut off en MC para MIPs
0c9acc4c 1340 {
1341 //V0A
1342 if(((mctrackf->Eta())>(2.8))&&((mctrackf->Eta())<(5.1)))
1343 v0LikeTotalMcMult++;
1344 //V0C
1345 if(((mctrackf->Eta())>(-3.7))&&((mctrackf->Eta())<(-1.7)))
1346 v0LikeTotalMcMult++;
1347 }
1348 //Fin de lo del V0
1349 aodMCTrackEta = TMath::Abs(mctrackf->Eta());
1350 if(aodMCTrackEta>0.9) continue;
1351 fPtAODMC->Fill(mctrackf->Pt(),mctrackf->Pt());
1352 fEtaAODMC->Fill(mctrackf->Eta(),mctrackf->Eta());
1353 fPhiAODMC->Fill(mctrackf->Phi(),mctrackf->Phi());
1354 if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
1355 {
1356 if(HasPerpendicularCone()) // If there is a perpendicular cone available
1357 {
1358 if(mctrackf->Pt()>fMinpTVal)
1359 {
1360 if(GetDeltaR(fEtaPerpCoord,fPhiPerpCoord,mctrackf->Eta(),mctrackf->Phi())<fJetRadius)
1361 perpendicularPt = perpendicularPt + mctrackf->Pt();
1362 }
1363 }
1364 } // end IF jet event
17f4943e 1365 if(mctrackf->Pt()>fMinPtInGlobMult) // Min pT used in multiplicity estimation
0c9acc4c 1366 {
1367 myTotalMultiplicityMc++; // total multiplicity TPC like
1368 if(mctrackf->Pt()<fMinpTValUE) continue; // pT cut fMinpTValUE
1369 if(mctrackf->Pt()>fMaxpTValUE) continue; // pT cut fMaxpTValUE
1370 if(!IsTrackInsideExcludedArea(mctrackf->Eta(), mctrackf->Phi(), aodMCJets))
1371 softRefMcNoJets++;
1372 }
1373 } // end loop over particles
1374
1375 Int_t correctedV0LikeMult= v0LikeTotalMcMult-GetV0LikeExcludedMultMC(aodMCJets,mcarray);
1376
1377 //estimadores
1378 if(mcjets==1) // correlation for only monojet events
1379 {
1380 fFullV0V0CorrUJMC->Fill(v0LikeTotalMcMult,correctedV0LikeMult);
1381 fTrackCountWOJetUJMC->Fill(myTotalMultiplicityMc,softRefMcNoJets);
1382 }
1383
1384 if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
1385 {
1386 if(HasPerpendicularCone()) // If there is a perpendicular cone available
1387 {
1388 px = perpendicularPt*TMath::Cos(fPhiPerpCoord);
1389 py = perpendicularPt*TMath::Sin(fPhiPerpCoord);
1390 pz = perpendicularPt/TMath::Tan(2.0*TMath::ATan(TMath::Exp(-fEtaPerpCoord)));
1391 en = TMath::Sqrt(px*px + py*py + pz*pz);
1392 fPerpCone->SetPxPyPzE(px, py, pz, en);
1393 }
1394 if(!HasPerpendicularCone())
1395 AliDebug(2,"No perpendicular cone!!!");
1396 }
1397
1398
1399 fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
1400
1401 Int_t flavor = 0; // flavor of the jet
1402 Int_t nTracksPerc; // ntx for the original jet
1403 Int_t nTracksPercBckgSubst; // ntx for the energy corrected jet
1404 Double_t jetPt=0;
1405 Int_t pdgOfMCt;
1406 Float_t trackxi;
1407 Double_t jetXt;
1408 Double_t jetPts[7]={0}; // to store the pt of the jets
1409 Int_t mcJetCounter=0; // counter of MC jets
1410 Int_t nTracksAboveThresholdPerp=0; // n tracks of the perpendicular cone
1411 Int_t nTrUpThrPerpBckSubs=0; // n tracks of the perpendicular cone, after the minimum pT recalculation
1412 fIsPossibleToSubstBckg = kTRUE; // Initialize before the loop
1413 if(fJetEvent) // si tiene jets validos
1414 {
1415 if(!HasPerpendicularCone()) // pero no encontro un cono perpendicular libre
1416 fIsPossibleToSubstBckg = kFALSE; // if not perpendicular cone, set to kFALSE, so no perpendicular calculations available
1417 }
1418 // Loop to fill a pT spectrum of the mc jets
1419 Int_t imcj=0; // index for montecarlo jets to correlate
1420 for (Int_t indxmc = 0; indxmc < mcjets; indxmc++)
1421 {
1422 AliAODJet *mcjet = dynamic_cast<AliAODJet*>(aodMCJets->At(indxmc));
1423 if (!mcjet)
1424 {
1425 AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxmc));
1426 continue;
1427 }
1428
1429 ///////////////////////////////////////////////////////////////////////////////
1430 ///// Part for Chritians plot of inclusive and leading jets comp at 2.76 TeV //
1431 if(!IsInsideAcceptance(mcjet)) // old condition
1432 continue;
1433 if(indxmc==0) // leading jet
1434 fMCJetPtLeading->Fill(mcjet->Pt());
1435 fMCJetPtInclusive->Fill(mcjet->Pt()); // all
1436 ///// End of Christians Plot MC
1437 ///////////////////////////////////////////////////////////////////////////////
1438
1439 if(indxmc>15)
1440 continue;
1441
1442 if(!fJetFlags[indxmc]) // If the jet is flaged kFALSE, not usable
1443 continue;
1444
1445 //Initialize variables for this jet
1446 //adiciones para la variable de estructura
1447 nTracksPerc = 0;
1448 nTracksPercBckgSubst = 0;
1449 fMinTrackPtInNTX=200.0; //Initialize for each jet, overflown
1450 fMaxTrackPtInNTX=200.0; //Initialize for each jet, overflown
1451 fMinTrackPtInNTXR=200.0; //Initialize for each jet, overflown
1452 fMaxTrackPtInNTXR=200.0; //Initialize for each jet, overflown
1453 deltaPhiPt = 0.0;
1454 deltaEtaPt = 0.0;
1455 deltaPhiSqPt = 0.0;
1456 deltaEtaSqPt = 0.0;
1457 totalTrackPt = 0.0;
1458 firstMomDeltPhi = 0.0;
1459 firstMomDeltEta = 0.0;
1460 secondMomDeltPhi = 0.0;
1461 secondMomDeltEta = 0.0;
1462 secondCentralPhi = 0.0;
1463 secondCentralEta = 0.0;
1464 secondCentralR = 0.0;
1465
1466 if(imcj<maxJetNum)
1467 genJets[imcj]= *mcjet;
1468 if(mcJetCounter<maxJetNum)
1469 jetPts[mcJetCounter]=mcjet->Pt();
1470 mcJetCounter++; // number of jets in the acceptance
1471 jetPt = mcjet->Pt();
1472 flavor = GetJetFlavour(mcjet,tracksMC,mcarray);
1473 if(imcj<maxJetNum)
1474 genJetsFlavor[imcj] = flavor;
1475 fJetPtMC->Fill(mcjet->Pt());
1476 fJetEtaMC->Fill(mcjet->Eta(),mcjet->Eta());
1477 fJetPhiMC->Fill(mcjet->Phi(),mcjet->Phi());
1478 fFlavor->Fill(flavor,jetPt);
1479 AliDebug(4,Form("Sabor del jet con pt=%f es :%d \n",jetPt,flavor));
1480 nTracksPerc = GetNumberOfMcChargedTracks(ntx,mcjet,tracksMC,mcarray,jfr); // este fija el min track pT, si es posible substraer el bckg
1481 if(fIsPossibleToSubstBckg&&!IsEqualRel(fCurrentJetMinPtNT90, 7000.)) //calculating only if there is a perpendicular cone available //IsEqualRel(jetpT, 0.0) //fCurrentJetMinPtNT90!=7000.
1482 { //and only if the method worked
1483 AliDebug(4,Form("For this jet and I have a perpendicular cone available"));
1484 // Aqui lo que debo contar es el numero de tracks arriba del min pT del jet correspondiente
1485 // que es fCurrentJetMinPtNT90
1486 nTracksAboveThresholdPerp = GetNMcChargedTracksAboveThreshold(fPerpCone,tracksMC,mcarray,jfr);
1487 }
1488 // Corrected jet (pT)
1489 if(fIsPossibleToSubstBckg) // for the current jet
1490 {
1491 pTbs= mcjet->Pt()-fPerpCone->Pt();
1492 etabs= mcjet->Eta();
1493 phibs= mcjet->Phi();
1494 fBckgSbsJet[0]=pTbs; //pT
1495 fBckgSbsJet[1]=etabs; //eta
1496 fBckgSbsJet[2]=phibs; //phi
1497 // Now re-calculate nt90 for the energy corrected jet
1498 nTracksPercBckgSubst = GetRecalcNTXMc(ntx,mcjet,tracksMC,mcarray,jfr);
1499 // Now re-calculate the perpendicular cone NT90 background
1500 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.)) //calculating for the current jet, if the previos method worked //!IsEqualRel(fCurrentJetMinPtNT90, 7000.) //fCurrentJetMinPtNT90Recalc!=7000.
1501 {
1502 // Aqui lo que debo contar es el numero de tracks arriba del min pT del jet correspondiente
1503 // despues de la correccion de energia del jet
1504 nTrUpThrPerpBckSubs = GetRecalcNMcChTrUpThr(fPerpCone,tracksMC,mcarray,jfr);
1505 }
1506 }
1507
1508 //check cross sections incoming partons
1509 jetXt= 2*jetPt/fSqrts;
1510 if(evtype==11||evtype==12||evtype==13) //QQ
1511 fFracQQ->Fill(jetXt);
1512 if(evtype==28) //GQ
1513 fFracGQ->Fill(jetXt);
1514 if(evtype==53||evtype==68) //GG
1515 fFracGG->Fill(jetXt);
1516
1517 //check cross sections outgoing partons
1518 if(evtype==11||evtype==12||evtype==53) //QQ
1519 fFracOutGoingQQ->Fill(jetXt);
1520 if(evtype==28) //GQ
1521 fFracOutGoingGQ->Fill(jetXt);
1522 if(evtype==13||evtype==68) //GG
1523 fFracOutGoingGG->Fill(jetXt);
1524
1525 fProcessJetPt->Fill(evtype,jetPt); // pythia process, filled for each jet in acceptance
1526
1527 //Fill jet flavor as a function of pT and the pythia process but only leading jet
1528 if(imcj==0) //leading jet
1529 {
1530 fFlavorLead->Fill(flavor,jetPt);
1531 fProcessLeadJetPt->Fill(evtype,jetPt);
1532 }
1533 AliDebug(4,Form("Before the check of comparison"));
1534 // To check tracks related to this MC jet
1535 // RefTracks check
1536 Bool_t rTrkFlagMC = kFALSE;
1537 Int_t trkinmcjet = mcjet->GetRefTracks()->GetEntriesFast();
1538 if(trkinmcjet!=0&&!fForceNotTR)
1539 rTrkFlagMC = kTRUE;
1540 AliDebug(4,Form("Number of tracks in RefTracks MC jet:%i \n",trkinmcjet));
1541 if(rTrkFlagMC) // If there are tracks refs available
1542 {
1543 AliDebug(4,Form("Checking composition in MC with track refs"));
1544 for(Int_t aodMCT = 0; aodMCT < trkinmcjet; aodMCT++ )
1545 {
1546 pdgOfMCt=0;
1547 trackxi=0;
1548 AliAODMCParticle *mctrack = (AliAODMCParticle*) mcjet->GetRefTracks()->At(aodMCT);
1549 if(!mctrack) continue;
1550 if(!mctrack->IsPhysicalPrimary()) continue;
1551 if(mctrack->Charge()==0||mctrack->Charge()==-99) continue;
1552 if(mctrack->Pt()<fMinpTVal) continue; // MC no cut in the case of track reference, should be in, NO, cut anyhow to be safe
17f4943e 1553 randomNum = gRandom->Rndm();
1554 if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
0c9acc4c 1555 deltaPhiPt += DeltaPhiMC(mcjet, mctrack)*mctrack->Pt();
1556 deltaEtaPt += DeltaEtaMC(mcjet, mctrack)*mctrack->Pt();
1557 deltaPhiSqPt += DeltaPhiSqMC(mcjet, mctrack)*mctrack->Pt();
1558 deltaEtaSqPt += DeltaEtaSqMC(mcjet, mctrack)*mctrack->Pt();
1559 totalTrackPt += mctrack->Pt();
1560
1561 pdgOfMCt=abs(mctrack->GetPdgCode());
1562 if(!IsEqualRel(mctrack->Pt(), 0.0)) //!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.) // mctrack->Pt()!=0
1563 trackxi= log(jetPt/mctrack->Pt());
1564 switch(abs(flavor))
1565 {
1566 case 1:
1567 if(pdgOfMCt==321)
1568 fFragKaon[0]->Fill(trackxi,jetPt);
1569 if(pdgOfMCt==211)
1570 fFragPion[0]->Fill(trackxi,jetPt);
1571 if(pdgOfMCt==2212)
1572 fFragProton[0]->Fill(trackxi,jetPt);
1573 break;
1574 case 2:
1575 if(pdgOfMCt==321)
1576 fFragKaon[1]->Fill(trackxi,jetPt);
1577 if(pdgOfMCt==211)
1578 fFragPion[1]->Fill(trackxi,jetPt);
1579 if(pdgOfMCt==2212)
1580 fFragProton[1]->Fill(trackxi,jetPt);
1581 break;
1582 case 3:
1583 if(pdgOfMCt==321)
1584 fFragKaon[2]->Fill(trackxi,jetPt);
1585 if(pdgOfMCt==211)
1586 fFragPion[2]->Fill(trackxi,jetPt);
1587 if(pdgOfMCt==2212)
1588 fFragProton[2]->Fill(trackxi,jetPt);
1589 break;
1590 case 4:
1591 if(pdgOfMCt==321)
1592 fFragKaon[3]->Fill(trackxi,jetPt);
1593 if(pdgOfMCt==211)
1594 fFragPion[3]->Fill(trackxi,jetPt);
1595 if(pdgOfMCt==2212)
1596 fFragProton[3]->Fill(trackxi,jetPt);
1597 break;
1598 case 5:
1599 if(pdgOfMCt==321)
1600 fFragKaon[4]->Fill(trackxi,jetPt);
1601 if(pdgOfMCt==211)
1602 fFragPion[4]->Fill(trackxi,jetPt);
1603 if(pdgOfMCt==2212)
1604 fFragProton[4]->Fill(trackxi,jetPt);
1605 break;
1606 case 21:
1607 if(pdgOfMCt==321)
1608 fFragKaon[5]->Fill(trackxi,jetPt);
1609 if(pdgOfMCt==211)
1610 fFragPion[5]->Fill(trackxi,jetPt);
1611 if(pdgOfMCt==2212)
1612 fFragProton[5]->Fill(trackxi,jetPt);
1613 break;
1614 default:
1615 break;
1616 } // end switch flavor
1617 }// end loop over AODMC particles of trackrefs
1618 if(!IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) //totalTrackPt!=0.0
1619 {
1620 firstMomDeltPhi = deltaPhiPt/totalTrackPt;
1621 firstMomDeltEta = deltaEtaPt/totalTrackPt;
1622 secondMomDeltPhi = deltaPhiSqPt/totalTrackPt;
1623 secondMomDeltEta = deltaEtaSqPt/totalTrackPt;
1624 secondCentralPhi = secondMomDeltPhi - firstMomDeltPhi*firstMomDeltPhi;
1625 secondCentralEta = secondMomDeltEta - firstMomDeltEta*firstMomDeltEta;
1626 secondCentralR = secondCentralPhi + secondCentralEta;
1627 } // end if totalTrackPt!=0.0
1628 if(IsEqualRel(totalTrackPt, 0.0)) //totalTrackPt==0.0
1629 secondCentralR = 10.0; //overflow
1630 }// end version with ref tracks (flag check)
1631
1632 if(!rTrkFlagMC) // No ref tracks available
1633 {
1634 AliDebug(4,Form("Checking composition in MC without track refs"));
1635 for(Int_t aodMCT = 0; aodMCT < tracksMC; aodMCT++ )
1636 {
1637 pdgOfMCt=0;
1638 trackxi=0;
1639 AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(aodMCT);
1640 if(!mctrack) continue;
1641 if(!mctrack->IsPhysicalPrimary()) continue;
1642 if(mctrack->Charge()==0||mctrack->Charge()==-99) continue;
1643 if(!IsMCTrackInsideThisJet(mctrack, mcjet, jfr)) continue;
1644 if(mctrack->Pt()<fMinpTVal) continue; // MC: HERE PT CUT, NO TRACK REF
17f4943e 1645 randomNum = gRandom->Rndm();
1646 if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
0c9acc4c 1647 deltaPhiPt += DeltaPhiMC(mcjet, mctrack)*mctrack->Pt();
1648 deltaEtaPt += DeltaEtaMC(mcjet, mctrack)*mctrack->Pt();
1649 deltaPhiSqPt += DeltaPhiSqMC(mcjet, mctrack)*mctrack->Pt();
1650 deltaEtaSqPt += DeltaEtaSqMC(mcjet, mctrack)*mctrack->Pt();
1651 totalTrackPt += mctrack->Pt();
1652
1653 pdgOfMCt=abs(mctrack->GetPdgCode());
1654 if(!IsEqualRel(mctrack->Pt(), 0.0)) //!IsEqualRel(mctrack->Pt(), 0.0) // mctrack->Pt()!=0
1655 trackxi= log(jetPt/mctrack->Pt());
1656 switch(flavor)
1657 {
1658 case 1:
1659 if(pdgOfMCt==321)
1660 fFragKaon[0]->Fill(trackxi,jetPt);
1661 if(pdgOfMCt==211)
1662 fFragPion[0]->Fill(trackxi,jetPt);
1663 if(pdgOfMCt==2212)
1664 fFragProton[0]->Fill(trackxi,jetPt);
1665 break;
1666 case 2:
1667 if(pdgOfMCt==321)
1668 fFragKaon[1]->Fill(trackxi,jetPt);
1669 if(pdgOfMCt==211)
1670 fFragPion[1]->Fill(trackxi,jetPt);
1671 if(pdgOfMCt==2212)
1672 fFragProton[1]->Fill(trackxi,jetPt);
1673 break;
1674 case 3:
1675 if(pdgOfMCt==321)
1676 fFragKaon[2]->Fill(trackxi,jetPt);
1677 if(pdgOfMCt==211)
1678 fFragPion[2]->Fill(trackxi,jetPt);
1679 if(pdgOfMCt==2212)
1680 fFragProton[2]->Fill(trackxi,jetPt);
1681 break;
1682 case 4:
1683 if(pdgOfMCt==321)
1684 fFragKaon[3]->Fill(trackxi,jetPt);
1685 if(pdgOfMCt==211)
1686 fFragPion[3]->Fill(trackxi,jetPt);
1687 if(pdgOfMCt==2212)
1688 fFragProton[3]->Fill(trackxi,jetPt);
1689 break;
1690 case 5:
1691 if(pdgOfMCt==321)
1692 fFragKaon[4]->Fill(trackxi,jetPt);
1693 if(pdgOfMCt==211)
1694 fFragPion[4]->Fill(trackxi,jetPt);
1695 if(pdgOfMCt==2212)
1696 fFragProton[4]->Fill(trackxi,jetPt);
1697 break;
1698 case 21:
1699 if(pdgOfMCt==321)
1700 fFragKaon[5]->Fill(trackxi,jetPt);
1701 if(pdgOfMCt==211)
1702 fFragPion[5]->Fill(trackxi,jetPt);
1703 if(pdgOfMCt==2212)
1704 fFragProton[5]->Fill(trackxi,jetPt);
1705 break;
1706 default:
1707 break;
1708 } // end switch flavor
1709 }// end loop over AODMC particles
1710 if(!IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPt!=0.0
1711 {
1712 firstMomDeltPhi = deltaPhiPt/totalTrackPt;
1713 firstMomDeltEta = deltaEtaPt/totalTrackPt;
1714 secondMomDeltPhi = deltaPhiSqPt/totalTrackPt;
1715 secondMomDeltEta = deltaEtaSqPt/totalTrackPt;
1716 secondCentralPhi = secondMomDeltPhi - firstMomDeltPhi*firstMomDeltPhi;
1717 secondCentralEta = secondMomDeltEta - firstMomDeltEta*firstMomDeltEta;
1718 secondCentralR = secondCentralPhi + secondCentralEta;
1719 } // end if totalTrackPt!=0.0
1720 if(IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) //totalTrackPt==0.0
1721 secondCentralR = 10.0; //overflow
1722 } //End old version (no ref tracks)
1723
1724 if(fIsPossibleToSubstBckg)
1725 {
1726 // To make sure, re-initialize
1727 deltaPhiPtPerp = 0.0;
1728 deltaEtaPtPerp = 0.0;
1729 deltaPhiSqPtPerp = 0.0;
1730 deltaEtaSqPtPerp = 0.0;
1731 totalTrackPtPerp = 0.0;
1732 firstMomDeltPhiPerp = 0.0;
1733 firstMomDeltEtaPerp = 0.0;
1734 secondMomDeltPhiPerp = 0.0;
1735 secondMomDeltEtaPerp = 0.0;
1736 secondCentralPhiPerp = 0.0;
1737 secondCentralEtaPerp = 0.0;
1738 secondCentralRPerp = 0.0;
1739
1740 AliDebug(4,Form("Checking SCM in MC for the perpendicular cone"));
1741 for(Int_t aodMCperp = 0; aodMCperp < tracksMC; aodMCperp++ )
1742 {
1743 AliAODMCParticle *mctrackperp = (AliAODMCParticle*) mcarray->At(aodMCperp);
1744 if(!mctrackperp) continue;
1745 if(!mctrackperp->IsPhysicalPrimary()) continue;
1746 if(mctrackperp->Charge()==0||mctrackperp->Charge()==-99) continue;
1747 if(!IsMCTrackInsideThisJet(mctrackperp, fPerpCone, jfr)) continue;
1748 if(mctrackperp->Pt()<fMinpTVal) continue; // MC: HERE PT CUT
17f4943e 1749 randomNum = gRandom->Rndm();
1750 if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
0c9acc4c 1751 deltaPhiPtPerp += DeltaPhiMC(fPerpCone, mctrackperp)*mctrackperp->Pt();
1752 deltaEtaPtPerp += DeltaEtaMC(fPerpCone, mctrackperp)*mctrackperp->Pt();
1753 deltaPhiSqPtPerp += DeltaPhiSqMC(fPerpCone, mctrackperp)*mctrackperp->Pt();
1754 deltaEtaSqPtPerp += DeltaEtaSqMC(fPerpCone, mctrackperp)*mctrackperp->Pt();
1755 totalTrackPtPerp += mctrackperp->Pt();
1756 }// end loop over AODMC particles
1757 if(!IsEqualRel(totalTrackPtPerp, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPtPerp!=0.0
1758 {
1759 firstMomDeltPhiPerp = deltaPhiPtPerp/totalTrackPtPerp;
1760 firstMomDeltEtaPerp = deltaEtaPtPerp/totalTrackPtPerp;
1761 secondMomDeltPhiPerp = deltaPhiSqPtPerp/totalTrackPtPerp;
1762 secondMomDeltEtaPerp = deltaEtaSqPtPerp/totalTrackPtPerp;
1763 secondCentralPhiPerp = secondMomDeltPhiPerp - firstMomDeltPhiPerp*firstMomDeltPhiPerp;
1764 secondCentralEtaPerp = secondMomDeltEtaPerp - firstMomDeltEtaPerp*firstMomDeltEtaPerp;
1765 secondCentralRPerp = secondCentralPhiPerp + secondCentralEtaPerp;
1766 } // end if totalTrackPt!=0.0
1767 if(IsEqualRel(totalTrackPtPerp, 0.0)) //!IsEqualRel(totalTrackPtPerp, 0.0) //totalTrackPtPerp==0.0
1768 secondCentralRPerp = 10.0; //overflow
1769 }
1770 ///// end of adding the SCM for the perpendicular cone
1771
1772 if(mcjets==1) // if only one jet in the whole event, and inside acceptance
1773 {
1774 // reference multiplicity stuff in pp, also filled in PbPb, but does not matter.
1775 // set to: V0 like corrected multiplicity: correctedV0LikeMult
1776 if(correctedV0LikeMult<25)
1777 {
1778 fNChTrRDMultOJMC[0]->Fill(nTracksPerc,jetPt);
1779 fSCMRDMultOJMC[0]->Fill(secondCentralR,jetPt);
17f4943e 1780 fJEtaMCMultOJ[0]->Fill(mcjet->Eta());
1781 fJetPtMCMultOJ[0]->Fill(mcjet->Pt());
0c9acc4c 1782 }
1783 if(correctedV0LikeMult>=25&&correctedV0LikeMult<50)
1784 {
1785 fNChTrRDMultOJMC[1]->Fill(nTracksPerc,jetPt);
1786 fSCMRDMultOJMC[1]->Fill(secondCentralR,jetPt);
17f4943e 1787 fJEtaMCMultOJ[1]->Fill(mcjet->Eta());
1788 fJetPtMCMultOJ[1]->Fill(mcjet->Pt());
0c9acc4c 1789 }
1790 if(correctedV0LikeMult>=50&&correctedV0LikeMult<90)
1791 {
1792 fNChTrRDMultOJMC[2]->Fill(nTracksPerc,jetPt);
1793 fSCMRDMultOJMC[2]->Fill(secondCentralR,jetPt);
17f4943e 1794 fJEtaMCMultOJ[2]->Fill(mcjet->Eta());
1795 fJetPtMCMultOJ[2]->Fill(mcjet->Pt());
0c9acc4c 1796 }
1797 if(correctedV0LikeMult>=90&&correctedV0LikeMult<120)
1798 {
1799 fNChTrRDMultOJMC[3]->Fill(nTracksPerc,jetPt);
1800 fSCMRDMultOJMC[3]->Fill(secondCentralR,jetPt);
17f4943e 1801 fJEtaMCMultOJ[3]->Fill(mcjet->Eta());
1802 fJetPtMCMultOJ[3]->Fill(mcjet->Pt());
0c9acc4c 1803 }
1804 if(correctedV0LikeMult>=120&&correctedV0LikeMult<150)
1805 {
1806 fNChTrRDMultOJMC[4]->Fill(nTracksPerc,jetPt);
1807 fSCMRDMultOJMC[4]->Fill(secondCentralR,jetPt);
17f4943e 1808 fJEtaMCMultOJ[4]->Fill(mcjet->Eta());
1809 fJetPtMCMultOJ[4]->Fill(mcjet->Pt());
0c9acc4c 1810 }
1811 if(correctedV0LikeMult>=150&&correctedV0LikeMult<200)
1812 {
1813 fNChTrRDMultOJMC[5]->Fill(nTracksPerc,jetPt);
1814 fSCMRDMultOJMC[5]->Fill(secondCentralR,jetPt);
17f4943e 1815 fJEtaMCMultOJ[5]->Fill(mcjet->Eta());
1816 fJetPtMCMultOJ[5]->Fill(mcjet->Pt());
0c9acc4c 1817 }
1818 if(correctedV0LikeMult>=200&&correctedV0LikeMult<300)
1819 {
1820 fNChTrRDMultOJMC[6]->Fill(nTracksPerc,jetPt);
1821 fSCMRDMultOJMC[6]->Fill(secondCentralR,jetPt);
17f4943e 1822 fJEtaMCMultOJ[6]->Fill(mcjet->Eta());
1823 fJetPtMCMultOJ[6]->Fill(mcjet->Pt());
0c9acc4c 1824 }
1825 if(correctedV0LikeMult>=300)
1826 {
1827 fNChTrRDMultOJMC[7]->Fill(nTracksPerc,jetPt);
1828 fSCMRDMultOJMC[7]->Fill(secondCentralR,jetPt);
17f4943e 1829 fJEtaMCMultOJ[7]->Fill(mcjet->Eta());
1830 fJetPtMCMultOJ[7]->Fill(mcjet->Pt());
0c9acc4c 1831 }
1832 //Results for inclusive jets
1833 // 2nd. Reference: set to: TPC tracks minus jet, minus dijet area
1834 if(softRefMcNoJets<5)
1835 {
1836 fNChTrRDMultSEOJMC[0]->Fill(nTracksPerc,jetPt);
1837 fSCMRDMultSEOJMC[0]->Fill(secondCentralR,jetPt);
17f4943e 1838 fJEtaMCMultSEOJ[0]->Fill(mcjet->Eta());
1839 fJetPtMCMultSEOJ[0]->Fill(mcjet->Pt());
1840 if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1841 fEntriesQuark[0]->Fill(nTracksPerc,jetPt);
1842 if(abs(flavor)==21) //if gluon jet
1843 fEntriesGluon[0]->Fill(nTracksPerc,jetPt);
0c9acc4c 1844 }
1845 if(softRefMcNoJets>=5&&softRefMcNoJets<10)
1846 {
1847 fNChTrRDMultSEOJMC[1]->Fill(nTracksPerc,jetPt);
17f4943e 1848 fSCMRDMultSEOJMC[1]->Fill(secondCentralR,jetPt);
1849 fJEtaMCMultSEOJ[1]->Fill(mcjet->Eta());
1850 fJetPtMCMultSEOJ[1]->Fill(mcjet->Pt());
1851 if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1852 fEntriesQuark[1]->Fill(nTracksPerc,jetPt);
1853 if(abs(flavor)==21) //if gluon jet
1854 fEntriesGluon[1]->Fill(nTracksPerc,jetPt);
0c9acc4c 1855 }
1856 if(softRefMcNoJets>=10&&softRefMcNoJets<15)
1857 {
1858 fNChTrRDMultSEOJMC[2]->Fill(nTracksPerc,jetPt);
1859 fSCMRDMultSEOJMC[2]->Fill(secondCentralR,jetPt);
17f4943e 1860 fJEtaMCMultSEOJ[2]->Fill(mcjet->Eta());
1861 fJetPtMCMultSEOJ[2]->Fill(mcjet->Pt());
1862 if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1863 fEntriesQuark[2]->Fill(nTracksPerc,jetPt);
1864 if(abs(flavor)==21) //if gluon jet
1865 fEntriesGluon[2]->Fill(nTracksPerc,jetPt);
0c9acc4c 1866 }
1867 if(softRefMcNoJets>=15&&softRefMcNoJets<20)
1868 {
1869 fNChTrRDMultSEOJMC[3]->Fill(nTracksPerc,jetPt);
1870 fSCMRDMultSEOJMC[3]->Fill(secondCentralR,jetPt);
17f4943e 1871 fJEtaMCMultSEOJ[3]->Fill(mcjet->Eta());
1872 fJetPtMCMultSEOJ[3]->Fill(mcjet->Pt());
1873 if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1874 fEntriesQuark[3]->Fill(nTracksPerc,jetPt);
1875 if(abs(flavor)==21) //if gluon jet
1876 fEntriesGluon[3]->Fill(nTracksPerc,jetPt);
0c9acc4c 1877 }
1878 if(softRefMcNoJets>=20&&softRefMcNoJets<30)
1879 {
1880 fNChTrRDMultSEOJMC[4]->Fill(nTracksPerc,jetPt);
1881 fSCMRDMultSEOJMC[4]->Fill(secondCentralR,jetPt);
17f4943e 1882 fJEtaMCMultSEOJ[4]->Fill(mcjet->Eta());
1883 fJetPtMCMultSEOJ[4]->Fill(mcjet->Pt());
1884 if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1885 fEntriesQuark[4]->Fill(nTracksPerc,jetPt);
1886 if(abs(flavor)==21) //if gluon jet
1887 fEntriesGluon[4]->Fill(nTracksPerc,jetPt);
0c9acc4c 1888 }
1889 if(softRefMcNoJets>=30&&softRefMcNoJets<40)
1890 {
1891 fNChTrRDMultSEOJMC[5]->Fill(nTracksPerc,jetPt);
1892 fSCMRDMultSEOJMC[5]->Fill(secondCentralR,jetPt);
17f4943e 1893 fJEtaMCMultSEOJ[5]->Fill(mcjet->Eta());
1894 fJetPtMCMultSEOJ[5]->Fill(mcjet->Pt());
1895 if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1896 fEntriesQuark[5]->Fill(nTracksPerc,jetPt);
1897 if(abs(flavor)==21) //if gluon jet
1898 fEntriesGluon[5]->Fill(nTracksPerc,jetPt);
0c9acc4c 1899 }
1900 if(softRefMcNoJets>=40&&softRefMcNoJets<50)
1901 {
1902 fNChTrRDMultSEOJMC[6]->Fill(nTracksPerc,jetPt);
1903 fSCMRDMultSEOJMC[6]->Fill(secondCentralR,jetPt);
17f4943e 1904 fJEtaMCMultSEOJ[6]->Fill(mcjet->Eta());
1905 fJetPtMCMultSEOJ[6]->Fill(mcjet->Pt());
1906 if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1907 fEntriesQuark[6]->Fill(nTracksPerc,jetPt);
1908 if(abs(flavor)==21) //if gluon jet
1909 fEntriesGluon[6]->Fill(nTracksPerc,jetPt);
0c9acc4c 1910 }
1911 if(softRefMcNoJets>=50)
1912 {
1913 fNChTrRDMultSEOJMC[7]->Fill(nTracksPerc,jetPt);
1914 fSCMRDMultSEOJMC[7]->Fill(secondCentralR,jetPt);
17f4943e 1915 fJEtaMCMultSEOJ[7]->Fill(mcjet->Eta());
1916 fJetPtMCMultSEOJ[7]->Fill(mcjet->Pt());
1917 if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1918 fEntriesQuark[7]->Fill(nTracksPerc,jetPt);
1919 if(abs(flavor)==21) //if gluon jet
1920 fEntriesGluon[7]->Fill(nTracksPerc,jetPt);
0c9acc4c 1921 }
1922 }
1923 //End results for inclusive jets,starts parton by parton
1924
1925 switch(abs(flavor))
1926 {
1927 case 1:
1928 fNChTr[0]->Fill(nTracksPerc,jetPt);
1929 fProcessPDG[0]->Fill(jetPt,evtype);
1930 fHistPtParton[0]->Fill(jetPt);
1931 fSCM[0]->Fill(secondCentralR,jetPt);
8dcbcbbb 1932 fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
0c9acc4c 1933 fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
1934 if(fIsPossibleToSubstBckg)
1935 {
1936 fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
1937 fSCMMCPerp->Fill(secondCentralR,jetPt);
1938 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.)) //!IsEqualRel(mctrack->Pt(), 0.0) // fCurrentJetMinPtNT90!=7000.
1939 fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
1940 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.)) // !IsEqualRel(fCurrentJetMinPtNT90, 7000.) // fCurrentJetMinPtNT90Recalc!=7000.
1941 fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
1942 }
1943 break;
1944 case 2:
1945 fNChTr[1]->Fill(nTracksPerc,jetPt);
1946 fProcessPDG[1]->Fill(jetPt,evtype);
1947 fHistPtParton[1]->Fill(jetPt);
1948 fSCM[1]->Fill(secondCentralR,jetPt);
8dcbcbbb 1949 fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
0c9acc4c 1950 fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
1951 if(fIsPossibleToSubstBckg)
1952 {
1953 fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
1954 fSCMMCPerp->Fill(secondCentralR,jetPt);
1955 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
1956 fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
1957 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
1958 fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
1959 }
1960 break;
1961 case 3:
1962 fNChTr[2]->Fill(nTracksPerc,jetPt);
1963 fProcessPDG[2]->Fill(jetPt,evtype);
1964 fHistPtParton[2]->Fill(jetPt);
1965 fSCM[2]->Fill(secondCentralR,jetPt);
8dcbcbbb 1966 fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
0c9acc4c 1967 fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
1968 if(fIsPossibleToSubstBckg)
1969 {
1970 fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
1971 fSCMMCPerp->Fill(secondCentralR,jetPt);
1972 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
1973 fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
1974 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
1975 fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
1976 }
1977 break;
1978 case 4:
1979 fNChTr[3]->Fill(nTracksPerc,jetPt);
1980 fProcessPDG[3]->Fill(jetPt,evtype);
1981 fHistPtParton[3]->Fill(jetPt);
1982 fSCM[3]->Fill(secondCentralR,jetPt);
8dcbcbbb 1983 fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
0c9acc4c 1984 fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
1985 if(fIsPossibleToSubstBckg)
1986 {
1987 fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
1988 fSCMMCPerp->Fill(secondCentralR,jetPt);
1989 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
1990 fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
1991 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
1992 fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
1993 }
1994 break;
1995 case 5:
1996 fNChTr[4]->Fill(nTracksPerc,jetPt);
1997 fProcessPDG[4]->Fill(jetPt,evtype);
1998 fHistPtParton[4]->Fill(jetPt);
1999 fSCM[4]->Fill(secondCentralR,jetPt);
8dcbcbbb 2000 fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
0c9acc4c 2001 fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
2002 if(fIsPossibleToSubstBckg)
2003 {
2004 fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
2005 fSCMMCPerp->Fill(secondCentralR,jetPt);
2006 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2007 fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
2008 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2009 fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
2010 }
2011 break;
2012 case 21:
2013 fNChTr[5]->Fill(nTracksPerc,jetPt);
2014 fProcessPDG[5]->Fill(jetPt,evtype);
2015 fHistPtParton[5]->Fill(jetPt);
2016 fSCM[5]->Fill(secondCentralR,jetPt);
8dcbcbbb 2017 fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
0c9acc4c 2018 fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
2019 if(fIsPossibleToSubstBckg)
2020 {
2021 fNChTrCorrMCGluon->Fill(nTracksPercBckgSubst,pTbs);
2022 fSCMMCPerp->Fill(secondCentralR,jetPt);
2023 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2024 fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
2025 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2026 fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
2027 }
2028 break;
2029 default:
2030 break;
2031 }
2032 AliDebug(4,Form("Sabor del jet numero:%d es: %d y se necesitaron %d tracks \n",indxmc,flavor,nTracksPerc));
2033 imcj++;
2034 } // MC jets for cycle
2035 nGenJets=imcj;
2036 for(Int_t u=0 ; u<mcJetCounter ;u++)
2037 {
2038 if(u<7)
2039 fJetsMultPtMC->Fill(jetPts[u],mcJetCounter);
2040 }
2041 // if(fEnablePrints)
2042 // {
2043 // if(mcJetCounter>=3)
2044 // printf("%i Jets inside acceptance at event number:%i \n",mcJetCounter,fEvtCount-1);
2045 // }
2046 fNAccJetsMC->Fill(mcJetCounter,mcJetCounter);
2047 } // end if MC info in AOD
2048
2049 if(!fUseOnlyMC)
2050 {
2051 // Primero que todo, debe de ir la seleccion de eventos reconstruidos:
2052 // 1. Que tenga un vertice reconstruido dentro de 10 cm.
2053 // Vertex info for reconstructed events
2054 AliAODVertex *pvx = fAOD->GetPrimaryVertex();
2055 if(!pvx)
2056 {
2057 AliError("No primary vertex!");
2058 return;
2059 }
2060 if(TMath::Abs(pvx->GetZ())>10.) // if the event vertex is larger than 10 cm, reject
2061 return;
2062 fZVertex->Fill(pvx->GetZ(),pvx->GetZ()); // vertex, provide number of accepted events as entries for reco jets
2063
2064 ///////////////////////////////////////
2065 // SECONDARY RECO BRANCH STUFF //
2066 // Get the secondary branch with the reconstructed jets
2067 if(fBranchSecRec!="")
2068 {
2069 AliDebug(4,Form("fBranchSecRec was not default \n"));
2070 TClonesArray *aodSecRecJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchSecRec.Data()));
2071 if(!aodSecRecJets)
2072 {
2073 AliError(Form("%s:%d no reconstructed Secondary Jet array with name %s in AOD",(char*)__FILE__,__LINE__,fBranchSecRec.Data()));
2074 return; //stop the analysis
2075 }
2076 AliDebug(4,Form("There are %d reconstructed jets from the secondary branch in this event \n", aodSecRecJets->GetEntries()));
2077 Int_t recojetsSEC = aodSecRecJets->GetEntries();
2078 fNJetsRDSeco->Fill(recojetsSEC,recojetsSEC); // number of jets in the secondary branch
2079
2080 HasOverlapedCones(aodSecRecJets); // Procedure for tagging usable jets
2081 // Up 16 jets are flagged
2082
2083 AliDebug(4,"Antes de realizar el loop jets reconstruidos del segundo branch \n");
2084 Int_t secondjetacccounter = 0;
2085 for (Int_t IDXS = 0; IDXS < recojetsSEC; IDXS++)
2086 {
2087 AliDebug(4,Form("Number of current jet:%i \n",IDXS));
2088 AliAODJet *rjetsec = dynamic_cast<AliAODJet*>(aodSecRecJets->At(IDXS));
2089 if (!rjetsec)
2090 {
2091 AliDebug(2,Form("ERROR: Could not receive jet %d from the second branch\n", IDXS));
2092 continue;
2093 }
2094
2095 ///////////////////////////////////////////////////////////////////////////////
2096 ///// Part for Chritians plot of inclusive and leading jets comp at 2.76 TeV //
2097 if(!IsInsideAcceptance(rjetsec)) // old condition
2098 continue;
2099 if(IDXS==0) // leading jet
2100 fSecRecJetPtLeading->Fill(rjetsec->Pt());
2101 fSecRecJetPtInclusive->Fill(rjetsec->Pt()); // all
2102 ///// End of Christians Plot reco 2nd branch
2103 ///////////////////////////////////////////////////////////////////////////////
2104
2105 if(IDXS>15)
2106 continue;
2107
2108 if(!fJetFlags[IDXS]) // If the jet is flaged kFALSE, not usable
2109 continue;
2110
2111 fJetPtSec->Fill(rjetsec->Pt());
2112 fJetEtaSec->Fill(rjetsec->Eta(),rjetsec->Eta());
2113 fJetPhiSec->Fill(rjetsec->Phi(),rjetsec->Phi());
2114 secondjetacccounter++;
2115 }
2116 fNAccJetsRDSeco->Fill(secondjetacccounter,secondjetacccounter);
2117 }
2118 // END OF SECONDARY BRANCH STUFF //
2119 ///////////////////////////////////////
2120
2121 // Get the branch with the reconstructed jets
2122 TClonesArray *aodRecJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchRec.Data()));
2123 if(!aodRecJets)
2124 {
2125 AliError(Form("%s:%d no reconstructed Jet array with name %s in AOD",(char*)__FILE__,__LINE__,fBranchRec.Data()));
2126 return;
2127 }
2128
2129 AliDebug(4,Form("There are %d reconstructed jets in this event\n", aodRecJets->GetEntries()));
2130 Int_t recojets = aodRecJets->GetEntries();
2131 fNJetsRD->Fill(recojets,recojets); // numero de jets directamente del branch
2132
2133 HasOverlapedCones(aodRecJets); // Procedure for tagging usable jets
2134 // Up 16 jets are flagged
2135
2136 AliDebug(4,"Antes de realizar el loop sobre AOD tracks \n");
2137 // Loop over AOD tracks
2138 Int_t tracksAOD = fAOD->GetNumberOfTracks();
2139 AliDebug(4,Form("Numero de tracks en el AOD:%d \n",tracksAOD));
2140 Double_t aodtracketa = 0.0;
2141 perpendicularPt = 0.0;
2142 px=0.0;
2143 py=0.0;
2144 pz=0.0;
2145 en=0.0;
2146 pTbs=0.0;
2147 etabs=0.0;
2148 phibs=0.0;
2149 fBckgSbsJet[0]=0.0;
2150 fBckgSbsJet[1]=0.0;
2151 fBckgSbsJet[2]=0.0;
2152 Int_t refNJMult = 0;
2153 Int_t myTotalMultRef = 0;
2154 Int_t myTotalSoftMultRef = 0;
2155 for(Int_t aodT = 0; aodT < tracksAOD; aodT++ )
2156 {
f15c1f69 2157 AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(aodT));
2158 if(!aodtrack) AliFatal("Not a standard AOD");
0c9acc4c 2159 if(!aodtrack) continue;
2160 aodtracketa = TMath::Abs(aodtrack->Eta());
2161 if(aodtracketa>0.9) continue;
2162 if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
0c9acc4c 2163 fEtaAOD->Fill(aodtrack->Eta(),aodtrack->Eta());
2164 fPhiAOD->Fill(aodtrack->Phi(),aodtrack->Phi());
2165 fPtAOD->Fill(aodtrack->Pt(),aodtrack->Pt());
2166 if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
2167 {
2168 if(HasPerpendicularCone()) // If there is a perpendicular cone available
2169 {
2170 if(aodtrack->Pt()>fMinpTVal)
2171 {
2172 if(GetDeltaR(fEtaPerpCoord,fPhiPerpCoord,aodtrack->Eta(),aodtrack->Phi())<fJetRadius)
2173 perpendicularPt = perpendicularPt + aodtrack->Pt();
2174 }
2175 }
2176 } // end if jet event
2177 //Total TPC multiplicity of primaries
17f4943e 2178 if(aodtrack->Pt()>fMinPtInGlobMult) // Min pT used in multiplicity estimation
2179 {
2180 myTotalMultRef++;
2181 if(aodtrack->Pt()<fMinpTValUE) continue; // pT cut fMinpTValUE
2182 if(aodtrack->Pt()>fMaxpTValUE) continue; // pT cut fMaxpTValUE
2183 myTotalSoftMultRef++;
2184 if(!IsTrackInsideExcludedArea(aodtrack->Eta(), aodtrack->Phi(), aodRecJets))
2185 refNJMult++;
2186 }
0c9acc4c 2187 } // end track loop over the event...
2188
2189 fRefMultWOJet->Fill(refMultiplicity,refNJMult);
2190 fMultWOJetVZero->Fill(refNJMult,multFullV0);
2191 Double_t v0CorrMult = multFullV0 - GetV0ExcludedMultiplicity(aodRecJets);
2192 fRefMultFullV0->Fill(refMultiplicity,multFullV0);
2193 fRefMultV0Corr->Fill(refMultiplicity,v0CorrMult);
2194 fFullV0V0Corr->Fill(multFullV0,v0CorrMult);
2195 fRefAODTrackCount->Fill(refMultiplicity,myTotalMultRef);
2196 fTrackCountWOJet->Fill(myTotalMultRef,refNJMult);
2197
2198 if(recojets==1) // correlation for only monojet events
2199 {
2200 fRefMultFullV0UJ->Fill(refMultiplicity,multFullV0);
2201 fRefMultV0CorrUJ->Fill(refMultiplicity,v0CorrMult);
2202 fFullV0V0CorrUJ->Fill(multFullV0,v0CorrMult);
2203 fMultWOJetVZeroUJ->Fill(refNJMult,multFullV0);
2204 fRefMultWOJetUJ->Fill(refMultiplicity,refNJMult);
2205 fRefAODTrackCountUJ->Fill(refMultiplicity,myTotalMultRef);
2206 fTrackCountWOJetUJ->Fill(myTotalMultRef,refNJMult);
2207 }
2208
2209 if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
2210 {
2211 if(HasPerpendicularCone()) // If there is a perpendicular cone available
2212 {
2213 px = perpendicularPt*TMath::Cos(fPhiPerpCoord);
2214 py = perpendicularPt*TMath::Sin(fPhiPerpCoord);
2215 pz = perpendicularPt/TMath::Tan(2.0*TMath::ATan(TMath::Exp(-fEtaPerpCoord)));
2216 en = TMath::Sqrt(px*px + py*py + pz*pz);
2217 fPerpCone->SetPxPyPzE(px, py, pz, en);
2218 }
2219 }
2220
2221 // Loop to fill a pT spectrum of the reco jets
2222 Int_t irecj=0; // index for reconstructed jets to correlate
2223 Int_t nrectracks[6]={0};
2224 Double_t ptrecjet[6]={0};
2225 Double_t scmr[6]={0};
2226 Double_t aodtrackxi=0;
2227 Int_t ntxreco;
2228 Int_t nTRecAboveThresholdPerp=0;
2229 Int_t ntxrecoRecalc;
2230 Int_t nTRecAboveThresholdPerpRecalc=0;
2231
2232 for(Int_t i=0; i<6; i++) // Reset per event
2233 {
2234 fHistContainerR4[i]->Reset();
2235 fHistContainerR3[i]->Reset();
2236 fHistContainerR2[i]->Reset();
2237 }
2238
2239 Double_t jetPtsR[7]={0}; // to store the pt of the jets
2240 Int_t rJetCounter=0; // counter of accepted reco jets
2241 fIsPossibleToSubstBckg = kTRUE; // Initialize before the loop
2242 if(fJetEvent) // si tiene jets validos
2243 {
2244 if(!HasPerpendicularCone()) // pero no encontro un cono perpendicular libre
2245 fIsPossibleToSubstBckg = kFALSE; // if not perpendicular cone, set to kFALSE, so no perpendicular calculations available
2246 }
2247
2248 AliDebug(4,"Antes de realizar el loop jets reconstruidos \n");
2249 for (Int_t indxrec = 0; indxrec < recojets; indxrec++)
2250 {
2251 AliDebug(4,Form("Number of current jet:%i \n",indxrec));
2252 ntxreco = 0;
2253 ntxrecoRecalc = 0;
2254 fMinTrackPtInNTX=200.0; //Initialize for each jet, overflown
2255 fMaxTrackPtInNTX=200.0; //Initialize for each jet, overflown
2256 fMinTrackPtInNTXR=200.0; //Initialize for each jet, overflown
2257 fMaxTrackPtInNTXR=200.0; //Initialize for each jet, overflown
2258 deltaPhiPt = 0.0;
2259 deltaEtaPt = 0.0;
2260 deltaPhiSqPt = 0.0;
2261 deltaEtaSqPt = 0.0;
2262 totalTrackPt = 0.0;
2263 firstMomDeltPhi = 0.0;
2264 firstMomDeltEta = 0.0;
2265 secondMomDeltPhi = 0.0;
2266 secondMomDeltEta = 0.0;
2267 secondCentralPhi = 0.0;
2268 secondCentralEta = 0.0;
2269 secondCentralR = 0.0;
17f4943e 2270 fTotTracksInCone=0; // Underflown at initialization per jet
2271
0c9acc4c 2272 AliAODJet *rjet = dynamic_cast<AliAODJet*>(aodRecJets->At(indxrec));
2273 if (!rjet)
2274 {
2275 AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxrec));
2276 continue;
2277 }
2278 fJetEtaAll->Fill(rjet->Eta());// all jets
2279
2280 ///////////////////////////////////////////////////////////////////////////////
2281 ///// Part for Chritians plot of inclusive and leading jets comp at 2.76 TeV //
2282 if(!IsInsideAcceptance(rjet)) // old condition
2283 continue;
2284 if(indxrec==0) // leading jet
2285 fRecJetPtLeading->Fill(rjet->Pt());
2286 fRecJetPtInclusive->Fill(rjet->Pt()); // all
2287 fJetEtaOnlyTPCcut->Fill(rjet->Eta());// only eta acceptance cut for TPC
2288 ///// End of Christians Plot reco
2289 ///////////////////////////////////////////////////////////////////////////////
2290
2291 if(indxrec>15)
2292 continue;
2293
2294 if(!fJetFlags[indxrec]) // If the jet is flaged kFALSE, not usable
2295 continue;
2296
2297 AliDebug(4,Form("Jet #%i is in the acceptance \n",indxrec));
2298 if(rJetCounter<7)
2299 jetPtsR[rJetCounter]=rjet->Pt();
2300 rJetCounter++;
2301 fJetPt->Fill(rjet->Pt());
2302 fJetEta->Fill(rjet->Eta(),rjet->Eta());
2303 fJetPhi->Fill(rjet->Phi(),rjet->Phi());
2304
2305 if(rjet->Pt()>10.)
2306 fJetEtaJetPt[0]->Fill(rjet->Eta());
2307 if(rjet->Pt()>30.)
2308 fJetEtaJetPt[1]->Fill(rjet->Eta());
2309 if(rjet->Pt()>50.)
2310 fJetEtaJetPt[2]->Fill(rjet->Eta());
2311
2312 // Reco RefTracks check
2313 Bool_t rTrkFlagRec = kFALSE;
2314 Int_t trkinrecjet = rjet->GetRefTracks()->GetEntriesFast();
2315 if(trkinrecjet!=0&&!fForceNotTR)
2316 rTrkFlagRec = kTRUE;
2317 AliDebug(4,Form("Number of tracks in RefTracks reco jet:%i \n",trkinrecjet));
2318 if(rTrkFlagRec)
2319 {
2320 // Check the properties of the tracks in this jet with track refs
2321 AliDebug(4,Form("Checking composition in Reco jets with track refs"));
2322 for(Int_t aodT = 0; aodT <trkinrecjet; aodT++ )
2323 {
2324 aodtrackxi=0;
2325 AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(rjet->GetRefTracks()->At(aodT));
2326 if(!aodtrack)
2327 {
2328 AliError("Error, no AOD Track!");
2329 continue;
2330 }
2331 if(!aodtrack->TestFilterBit(fFilterBit))
2332 {
2333 // printf("Rejecting track from track refs due to wrong filterbit! \n");
2334 continue; //track filter selection
2335 }
0c9acc4c 2336 deltaPhiPt += DeltaPhiTrack(rjet, aodtrack)*aodtrack->Pt();
2337 deltaEtaPt += DeltaEtaTrack(rjet, aodtrack)*aodtrack->Pt();
2338 deltaPhiSqPt += DeltaPhiSqTrack(rjet, aodtrack)*aodtrack->Pt();
2339 deltaEtaSqPt += DeltaEtaSqTrack(rjet, aodtrack)*aodtrack->Pt();
2340 totalTrackPt += aodtrack->Pt();
17f4943e 2341 fTotTracksInCone++; // Counting tracks
0c9acc4c 2342 if(!IsEqualRel(aodtrack->Pt(), 0.0)) //!IsEqualRel(totalTrackPtPerp, 0.0) //aodtrack->Pt()!=0
2343 aodtrackxi= log(rjet->Pt()/aodtrack->Pt());
2344 if(irecj<maxJetNum)
2345 {
2346 fHistContainerR4[irecj]->Fill(aodtrackxi,rjet->Pt());
2347 if(!IsTrackInsideThisJet(aodtrack, rjet, 0.3)) continue;
2348 fHistContainerR3[irecj]->Fill(aodtrackxi,rjet->Pt());
2349 if(!IsTrackInsideThisJet(aodtrack, rjet, 0.2)) continue;
2350 fHistContainerR2[irecj]->Fill(aodtrackxi,rjet->Pt());
2351 }
2352 } //end loop over track references
2353 if(!IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPt!=0.0
2354 {
2355 firstMomDeltPhi = deltaPhiPt/totalTrackPt;
2356 firstMomDeltEta = deltaEtaPt/totalTrackPt;
2357 secondMomDeltPhi = deltaPhiSqPt/totalTrackPt;
2358 secondMomDeltEta = deltaEtaSqPt/totalTrackPt;
2359 secondCentralPhi = secondMomDeltPhi - firstMomDeltPhi*firstMomDeltPhi;
2360 secondCentralEta = secondMomDeltEta - firstMomDeltEta*firstMomDeltEta;
2361 secondCentralR = secondCentralPhi + secondCentralEta;
2362 } // end if totalTrackPt!=0.0
2363 if(IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPt==0.0
2364 secondCentralR = 10.0; //overflow value
2365 } // end if there are track references
2366
2367 if(!rTrkFlagRec)
2368 {
2369 // Check properties of the tracks in this jet without track refs
2370 AliDebug(4,Form("Checking composition in Reco jets without track refs"));
2371 for(Int_t aodT = 0; aodT < tracksAOD; aodT++ )
2372 {
f15c1f69 2373 AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(aodT));
2374 if(!aodtrack) AliFatal("Not a standard AOD");
0c9acc4c 2375 if(!aodtrack) continue;
2376 if(!IsTrackInsideThisJet(aodtrack, rjet, jfr)) continue;
2377 if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
0c9acc4c 2378 if(aodtrack->Pt()<fMinpTVal) continue; //DATA: PT CUT
2379 deltaPhiPt += DeltaPhiTrack(rjet, aodtrack)*aodtrack->Pt();
2380 deltaEtaPt += DeltaEtaTrack(rjet, aodtrack)*aodtrack->Pt();
2381 deltaPhiSqPt += DeltaPhiSqTrack(rjet, aodtrack)*aodtrack->Pt();
2382 deltaEtaSqPt += DeltaEtaSqTrack(rjet, aodtrack)*aodtrack->Pt();
2383 totalTrackPt += aodtrack->Pt();
17f4943e 2384 fTotTracksInCone++; // Counting tracks
0c9acc4c 2385 if(!IsEqualRel(aodtrack->Pt(), 0.0)) //!IsEqualRel(totalTrackPt, 0.0) //aodtrack->Pt()!=0
2386 aodtrackxi= log(rjet->Pt()/aodtrack->Pt());
2387 if(irecj<maxJetNum)
2388 {
2389 fHistContainerR4[irecj]->Fill(aodtrackxi,rjet->Pt());
2390 if(!IsTrackInsideThisJet(aodtrack, rjet, 0.3)) continue;
2391 fHistContainerR3[irecj]->Fill(aodtrackxi,rjet->Pt());
2392 if(!IsTrackInsideThisJet(aodtrack, rjet, 0.2)) continue;
2393 fHistContainerR2[irecj]->Fill(aodtrackxi,rjet->Pt());
2394 }
2395 } // end loop over tracks
2396 if(!IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) //totalTrackPt!=0.0
2397 {
2398 firstMomDeltPhi = deltaPhiPt/totalTrackPt;
2399 firstMomDeltEta = deltaEtaPt/totalTrackPt;
2400 secondMomDeltPhi = deltaPhiSqPt/totalTrackPt;
2401 secondMomDeltEta = deltaEtaSqPt/totalTrackPt;
2402 secondCentralPhi = secondMomDeltPhi - firstMomDeltPhi*firstMomDeltPhi;
2403 secondCentralEta = secondMomDeltEta - firstMomDeltEta*firstMomDeltEta;
2404 secondCentralR = secondCentralPhi + secondCentralEta;
2405 } // end if totalTrackPt!=0.0
2406 if(IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPt==0.0
2407 secondCentralR = 10.0; //overflow value
2408 } // end of no track references
2409 //Esto es lo anterior, toma al jet como es, y calcula NT90
2410 ntxreco=GetNumberOfChargedTracks(ntx,rjet, tracksAOD, fAOD, jfr); // this call fixes the minimum pT track
2411 //Y aqui calcula cuantos tracks se necesitan arriba del threshold establecido en la linea anterior
2412 //esto debe ser para cada jet. Lo unico que se calcula una sola vez es el cono perpendicular
2413 if(fIsPossibleToSubstBckg&&!IsEqualRel(fCurrentJetMinPtNT90, 7000.)) //and only if the method worked
2414 nTRecAboveThresholdPerp = GetNRecChargedTracksAboveThreshold(fPerpCone,tracksAOD, fAOD,jfr); //here one changes NTX
2415
2416 // correct the jet pT
2417 if(fIsPossibleToSubstBckg) // If there is a perpendicular cone available, substract backg and fill the new jet pT
2418 {
2419 pTbs= rjet->Pt()-fPerpCone->Pt();
2420 etabs= rjet->Eta();
2421 phibs= rjet->Phi();
2422 fBckgSbsJet[0]=pTbs; //pT
2423 fBckgSbsJet[1]=etabs; //eta
2424 fBckgSbsJet[2]=phibs; //phi
2425 // Now re-calculate nt90 for the energy corrected jet
2426 ntxrecoRecalc = GetRecalcNTXRec(ntx,rjet, tracksAOD, fAOD, jfr); //This call saves the new min pT
2427 // Now re-calculate the perpendicular cone NT90 background
2428 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.)) //calculating for the current jet, if the previous method worked
2429 nTRecAboveThresholdPerpRecalc = GetRecalcNRecChTrUpThr(fPerpCone,tracksAOD, fAOD,jfr);
2430 }
2431
2432 // SCM perpendicular cone
2433 if(fIsPossibleToSubstBckg)
2434 {
2435 // To make sure, re-initialize
2436 deltaPhiPtPerp = 0.0;
2437 deltaEtaPtPerp = 0.0;
2438 deltaPhiSqPtPerp = 0.0;
2439 deltaEtaSqPtPerp = 0.0;
2440 totalTrackPtPerp = 0.0;
2441 firstMomDeltPhiPerp = 0.0;
2442 firstMomDeltEtaPerp = 0.0;
2443 secondMomDeltPhiPerp = 0.0;
2444 secondMomDeltEtaPerp = 0.0;
2445 secondCentralPhiPerp = 0.0;
2446 secondCentralEtaPerp = 0.0;
2447 secondCentralRPerp = 0.0;
2448 AliDebug(4,Form("Checking SCM of perpendicular cone in Reco jets"));
2449 for(Int_t aodTperp = 0; aodTperp < tracksAOD; aodTperp++ )
2450 { //fPerpCone
f15c1f69 2451 AliAODTrack *aodtrackperprec = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(aodTperp));
2452 if(!aodtrackperprec) AliFatal("Not a standard AOD");
0c9acc4c 2453 if(!aodtrackperprec) continue;
2454 if(!IsTrackInsideThisJet(aodtrackperprec, fPerpCone, jfr)) continue;
2455 if(!aodtrackperprec->TestFilterBit(fFilterBit)) continue; //track filter selection
0c9acc4c 2456 if(aodtrackperprec->Pt()<fMinpTVal) continue; //DATA: PT CUT
2457 deltaPhiPtPerp += DeltaPhiTrack(fPerpCone, aodtrackperprec)*aodtrackperprec->Pt();
2458 deltaEtaPtPerp += DeltaEtaTrack(fPerpCone, aodtrackperprec)*aodtrackperprec->Pt();
2459 deltaPhiSqPtPerp += DeltaPhiSqTrack(fPerpCone, aodtrackperprec)*aodtrackperprec->Pt();
2460 deltaEtaSqPtPerp += DeltaEtaSqTrack(fPerpCone, aodtrackperprec)*aodtrackperprec->Pt();
2461 totalTrackPtPerp += aodtrackperprec->Pt();
2462 } // end loop over tracks
2463 if(!IsEqualRel(totalTrackPtPerp, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPtPerp!=0.0
2464 {
2465 firstMomDeltPhiPerp = deltaPhiPtPerp/totalTrackPtPerp;
2466 firstMomDeltEtaPerp = deltaEtaPtPerp/totalTrackPtPerp;
2467 secondMomDeltPhiPerp = deltaPhiSqPtPerp/totalTrackPtPerp;
2468 secondMomDeltEtaPerp = deltaEtaSqPtPerp/totalTrackPtPerp;
2469 secondCentralPhiPerp = secondMomDeltPhiPerp - firstMomDeltPhiPerp*firstMomDeltPhiPerp;
2470 secondCentralEtaPerp = secondMomDeltEtaPerp - firstMomDeltEtaPerp*firstMomDeltEtaPerp;
2471 secondCentralRPerp = secondCentralPhiPerp + secondCentralEtaPerp;
2472 } // end if totalTrackPt!=0.0
2473 if(IsEqualRel(totalTrackPtPerp, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPtPerp==0.0
2474 secondCentralRPerp = 10.0; //overflow
2475 }
2476
2477 ///// end of adding the SCM for the perpendicular cone
2478
2479 if(irecj<maxJetNum)
2480 {
2481 recJets[irecj]= *rjet;
2482 nrectracks[irecj] = ntxreco;
2483 ptrecjet[irecj] = rjet->Pt();
2484 scmr[irecj] = secondCentralR;
2485 AliDebug(4,Form("Para el jet reco num: %d se necesitaron %d tracks \n",irecj,nrectracks[irecj]));
2486 }
2487 AliDebug(4,"Before filling the histograms for this jet \n");
2488 fNChTrRD->Fill(ntxreco,rjet->Pt());
2489 fSCMRD->Fill(secondCentralR,rjet->Pt());
2490 fProfNChTrRD->Fill(rjet->Pt(),ntxreco);
2491
2492 fNTXV0MultPt->Fill(ntxreco,v0CorrMult,rjet->Pt());
2493 fNTXCBMultPt->Fill(ntxreco,refNJMult,rjet->Pt());
2494
2495 //refNJMult
2496 // reference multiplicity stuff in pp, also filled in PbPb, but does not matter.
2497 // set to: V0 corrected multiplicity: v0CorrMult
2498 if(v0CorrMult<25)
2499 {
2500 fNChTrRDMult[0]->Fill(ntxreco,rjet->Pt());
2501 fSCMRDMult[0]->Fill(secondCentralR,rjet->Pt());
2502 fTotalJetCharge[0]->Fill(fCurrentJetCharge);
2503 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2504 {
2505 fNChTrRDMultOJ[0]->Fill(ntxreco,rjet->Pt());
2506 fSCMRDMultOJ[0]->Fill(secondCentralR,rjet->Pt());
17f4943e 2507 fJEtaRDMultOJ[0]->Fill(rjet->Eta());
2508 fJetPtRDMultOJ[0]->Fill(rjet->Pt());
0c9acc4c 2509 }
2510 }
2511 if(v0CorrMult>=25&&v0CorrMult<50)
2512 {
2513 fNChTrRDMult[1]->Fill(ntxreco,rjet->Pt());
2514 fSCMRDMult[1]->Fill(secondCentralR,rjet->Pt());
2515 fTotalJetCharge[1]->Fill(fCurrentJetCharge);
2516 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2517 {
2518 fNChTrRDMultOJ[1]->Fill(ntxreco,rjet->Pt());
2519 fSCMRDMultOJ[1]->Fill(secondCentralR,rjet->Pt());
17f4943e 2520 fJEtaRDMultOJ[1]->Fill(rjet->Eta());
2521 fJetPtRDMultOJ[1]->Fill(rjet->Pt());
0c9acc4c 2522 }
2523 }
2524 if(v0CorrMult>=50&&v0CorrMult<90)
2525 {
2526 fNChTrRDMult[2]->Fill(ntxreco,rjet->Pt());
2527 fSCMRDMult[2]->Fill(secondCentralR,rjet->Pt());
2528 fTotalJetCharge[2]->Fill(fCurrentJetCharge);
2529 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2530 {
2531 fNChTrRDMultOJ[2]->Fill(ntxreco,rjet->Pt());
2532 fSCMRDMultOJ[2]->Fill(secondCentralR,rjet->Pt());
17f4943e 2533 fJEtaRDMultOJ[2]->Fill(rjet->Eta());
2534 fJetPtRDMultOJ[2]->Fill(rjet->Pt());
0c9acc4c 2535 }
2536 }
2537 if(v0CorrMult>=90&&v0CorrMult<120)
2538 {
2539 fNChTrRDMult[3]->Fill(ntxreco,rjet->Pt());
2540 fSCMRDMult[3]->Fill(secondCentralR,rjet->Pt());
2541 fTotalJetCharge[3]->Fill(fCurrentJetCharge);
2542 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2543 {
2544 fNChTrRDMultOJ[3]->Fill(ntxreco,rjet->Pt());
2545 fSCMRDMultOJ[3]->Fill(secondCentralR,rjet->Pt());
17f4943e 2546 fJEtaRDMultOJ[3]->Fill(rjet->Eta());
2547 fJetPtRDMultOJ[3]->Fill(rjet->Pt());
0c9acc4c 2548 }
2549 }
2550 if(v0CorrMult>=120&&v0CorrMult<150)
2551 {
2552 fNChTrRDMult[4]->Fill(ntxreco,rjet->Pt());
2553 fSCMRDMult[4]->Fill(secondCentralR,rjet->Pt());
2554 fTotalJetCharge[4]->Fill(fCurrentJetCharge);
2555 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2556 {
2557 fNChTrRDMultOJ[4]->Fill(ntxreco,rjet->Pt());
2558 fSCMRDMultOJ[4]->Fill(secondCentralR,rjet->Pt());
17f4943e 2559 fJEtaRDMultOJ[4]->Fill(rjet->Eta());
2560 fJetPtRDMultOJ[4]->Fill(rjet->Pt());
0c9acc4c 2561 }
2562 }
2563 if(v0CorrMult>=150&&v0CorrMult<200)
2564 {
2565 fNChTrRDMult[5]->Fill(ntxreco,rjet->Pt());
2566 fSCMRDMult[5]->Fill(secondCentralR,rjet->Pt());
2567 fTotalJetCharge[5]->Fill(fCurrentJetCharge);
2568 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2569 {
2570 fNChTrRDMultOJ[5]->Fill(ntxreco,rjet->Pt());
2571 fSCMRDMultOJ[5]->Fill(secondCentralR,rjet->Pt());
17f4943e 2572 fJEtaRDMultOJ[5]->Fill(rjet->Eta());
2573 fJetPtRDMultOJ[5]->Fill(rjet->Pt());
0c9acc4c 2574 }
2575 }
2576 if(v0CorrMult>=200&&v0CorrMult<300)
2577 {
2578 fNChTrRDMult[6]->Fill(ntxreco,rjet->Pt());
2579 fSCMRDMult[6]->Fill(secondCentralR,rjet->Pt());
2580 fTotalJetCharge[6]->Fill(fCurrentJetCharge);
2581 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2582 {
2583 fNChTrRDMultOJ[6]->Fill(ntxreco,rjet->Pt());
2584 fSCMRDMultOJ[6]->Fill(secondCentralR,rjet->Pt());
17f4943e 2585 fJEtaRDMultOJ[6]->Fill(rjet->Eta());
2586 fJetPtRDMultOJ[6]->Fill(rjet->Pt());
0c9acc4c 2587 }
2588 }
2589 if(v0CorrMult>=300)
2590 {
2591 fNChTrRDMult[7]->Fill(ntxreco,rjet->Pt());
2592 fSCMRDMult[7]->Fill(secondCentralR,rjet->Pt());
2593 fTotalJetCharge[7]->Fill(fCurrentJetCharge);
2594 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2595 {
2596 fNChTrRDMultOJ[7]->Fill(ntxreco,rjet->Pt());
2597 fSCMRDMultOJ[7]->Fill(secondCentralR,rjet->Pt());
17f4943e 2598 fJEtaRDMultOJ[7]->Fill(rjet->Eta());
2599 fJetPtRDMultOJ[7]->Fill(rjet->Pt());
0c9acc4c 2600 }
2601 }
2602
2603 // 2nd. Reference: set to: TPC tracks minus jet, minus dijet area
2604 if(refNJMult<5) //&&refNJMult>1
2605 {
2606 fNChTrRDMultSE[0]->Fill(ntxreco,rjet->Pt());
2607 fSCMRDMultSE[0]->Fill(secondCentralR,rjet->Pt());
2608 fTotalJetChargeSE[0]->Fill(fCurrentJetCharge);
2609 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2610 {
2611 fNChTrRDMultSEOJ[0]->Fill(ntxreco,rjet->Pt());
2612 fSCMRDMultSEOJ[0]->Fill(secondCentralR,rjet->Pt());
17f4943e 2613 fJEtaRDMultSEOJ[0]->Fill(rjet->Eta());
2614 fJetPtRDMultSEOJ[0]->Fill(rjet->Pt());
0c9acc4c 2615 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2616 fNChTrRecPerpMultSEOJ[0]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2617 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2618 {
2619 fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,1); //filling mult bin
2620 fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,1); //filling mult bin
2621 }
2622 }
2623 }
2624 if(refNJMult>=5&&refNJMult<10)
2625 {
2626 fNChTrRDMultSE[1]->Fill(ntxreco,rjet->Pt());
2627 fSCMRDMultSE[1]->Fill(secondCentralR,rjet->Pt());
2628 fTotalJetChargeSE[1]->Fill(fCurrentJetCharge);
2629 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2630 {
2631 fNChTrRDMultSEOJ[1]->Fill(ntxreco,rjet->Pt());
2632 fSCMRDMultSEOJ[1]->Fill(secondCentralR,rjet->Pt());
17f4943e 2633 fJEtaRDMultSEOJ[1]->Fill(rjet->Eta());
2634 fJetPtRDMultSEOJ[1]->Fill(rjet->Pt());
0c9acc4c 2635 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2636 fNChTrRecPerpMultSEOJ[1]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2637 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2638 {
2639 fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,2); //filling mult bin
2640 fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,2); //filling mult bin
2641 }
2642 }
2643 }
2644 if(refNJMult>=10&&refNJMult<15)
2645 {
2646 fNChTrRDMultSE[2]->Fill(ntxreco,rjet->Pt());
2647 fSCMRDMultSE[2]->Fill(secondCentralR,rjet->Pt());
2648 fTotalJetChargeSE[2]->Fill(fCurrentJetCharge);
2649 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2650 {
2651 fNChTrRDMultSEOJ[2]->Fill(ntxreco,rjet->Pt());
2652 fSCMRDMultSEOJ[2]->Fill(secondCentralR,rjet->Pt());
17f4943e 2653 fJEtaRDMultSEOJ[2]->Fill(rjet->Eta());
2654 fJetPtRDMultSEOJ[2]->Fill(rjet->Pt());
0c9acc4c 2655 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2656 fNChTrRecPerpMultSEOJ[2]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2657 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2658 {
2659 fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,3); //filling mult bin
2660 fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,3); //filling mult bin
2661 }
2662 }
2663 }
2664 if(refNJMult>=15&&refNJMult<20)
2665 {
2666 fNChTrRDMultSE[3]->Fill(ntxreco,rjet->Pt());
2667 fSCMRDMultSE[3]->Fill(secondCentralR,rjet->Pt());
2668 fTotalJetChargeSE[3]->Fill(fCurrentJetCharge);
2669 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2670 {
2671 fNChTrRDMultSEOJ[3]->Fill(ntxreco,rjet->Pt());
2672 fSCMRDMultSEOJ[3]->Fill(secondCentralR,rjet->Pt());
17f4943e 2673 fJEtaRDMultSEOJ[3]->Fill(rjet->Eta());
2674 fJetPtRDMultSEOJ[3]->Fill(rjet->Pt());
0c9acc4c 2675 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2676 fNChTrRecPerpMultSEOJ[3]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2677 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2678 {
2679 fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,4); //filling mult bin
2680 fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,4); //filling mult bin
2681 }
2682 }
2683 }
2684 if(refNJMult>=20&&refNJMult<30)
2685 {
2686 fNChTrRDMultSE[4]->Fill(ntxreco,rjet->Pt());
2687 fSCMRDMultSE[4]->Fill(secondCentralR,rjet->Pt());
2688 fTotalJetChargeSE[4]->Fill(fCurrentJetCharge);
2689 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2690 {
2691 fNChTrRDMultSEOJ[4]->Fill(ntxreco,rjet->Pt());
2692 fSCMRDMultSEOJ[4]->Fill(secondCentralR,rjet->Pt());
17f4943e 2693 fJEtaRDMultSEOJ[4]->Fill(rjet->Eta());
2694 fJetPtRDMultSEOJ[4]->Fill(rjet->Pt());
0c9acc4c 2695 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2696 fNChTrRecPerpMultSEOJ[4]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2697 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2698 {
2699 fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,5); //filling mult bin
2700 fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,5); //filling mult bin
2701 }
2702 }
2703 }
2704 if(refNJMult>=30&&refNJMult<40)
2705 {
2706 fNChTrRDMultSE[5]->Fill(ntxreco,rjet->Pt());
2707 fSCMRDMultSE[5]->Fill(secondCentralR,rjet->Pt());
2708 fTotalJetChargeSE[5]->Fill(fCurrentJetCharge);
2709 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2710 {
2711 fNChTrRDMultSEOJ[5]->Fill(ntxreco,rjet->Pt());
2712 fSCMRDMultSEOJ[5]->Fill(secondCentralR,rjet->Pt());
17f4943e 2713 fJEtaRDMultSEOJ[5]->Fill(rjet->Eta());
2714 fJetPtRDMultSEOJ[5]->Fill(rjet->Pt());
0c9acc4c 2715 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2716 fNChTrRecPerpMultSEOJ[5]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2717 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2718 {
2719 fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,6); //filling mult bin
2720 fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,6); //filling mult bin
2721 }
2722 }
2723 }
2724 if(refNJMult>=40&&refNJMult<50)
2725 {
2726 fNChTrRDMultSE[6]->Fill(ntxreco,rjet->Pt());
2727 fSCMRDMultSE[6]->Fill(secondCentralR,rjet->Pt());
2728 fTotalJetChargeSE[6]->Fill(fCurrentJetCharge);
2729 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2730 {
2731 fNChTrRDMultSEOJ[6]->Fill(ntxreco,rjet->Pt());
2732 fSCMRDMultSEOJ[6]->Fill(secondCentralR,rjet->Pt());
17f4943e 2733 fJEtaRDMultSEOJ[6]->Fill(rjet->Eta());
2734 fJetPtRDMultSEOJ[6]->Fill(rjet->Pt());
0c9acc4c 2735 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2736 fNChTrRecPerpMultSEOJ[6]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2737 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2738 {
2739 fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,7); //filling mult bin
2740 fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,7); //filling mult bin
2741 }
2742 }
2743 }
2744 if(refNJMult>=50)
2745 {
2746 fNChTrRDMultSE[7]->Fill(ntxreco,rjet->Pt());
2747 fSCMRDMultSE[7]->Fill(secondCentralR,rjet->Pt());
2748 fTotalJetChargeSE[7]->Fill(fCurrentJetCharge);
2749 if(recojets==1) // if only one jet in the whole event, and inside acceptance
2750 {
2751 fNChTrRDMultSEOJ[7]->Fill(ntxreco,rjet->Pt());
2752 fSCMRDMultSEOJ[7]->Fill(secondCentralR,rjet->Pt());
17f4943e 2753 fJEtaRDMultSEOJ[7]->Fill(rjet->Eta());
2754 fJetPtRDMultSEOJ[7]->Fill(rjet->Pt());
0c9acc4c 2755 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2756 fNChTrRecPerpMultSEOJ[7]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2757 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2758 {
2759 fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,8); //filling mult bin
2760 fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,8); //filling mult bin
2761 }
2762 }
2763 }
2764
2765 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2766 {
2767 if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2768 fNChTrRecPerp->Fill(nTRecAboveThresholdPerp,rjet->Pt()); // these are my previous histos
2769 fSCMRecPerp->Fill(secondCentralRPerp,rjet->Pt()); // this are my previous histos
2770 if(!fIsHIevent) //if is a proton proton event
2771 {
2772 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,1); //filling proton bin
2773 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2774 {
2775 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,1); //filling proton bin
2776 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
2777 {
2778 fPtInPerpCon->Fill(fPerpCone->Pt(),1,1);
17f4943e 2779 fTotTracksCone->Fill(fTotTracksInCone,1,1);
0c9acc4c 2780 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 1);
2781 }
2782 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
2783 {
2784 fPtInPerpCon->Fill(fPerpCone->Pt(),2,1);
17f4943e 2785 fTotTracksCone->Fill(fTotTracksInCone,2,1);
0c9acc4c 2786 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 2);
2787 }
2788 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
2789 {
2790 fPtInPerpCon->Fill(fPerpCone->Pt(),3,1);
17f4943e 2791 fTotTracksCone->Fill(fTotTracksInCone,3,1);
0c9acc4c 2792 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 3);
2793 }
2794 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
2795 {
2796 fPtInPerpCon->Fill(fPerpCone->Pt(),4,1);
17f4943e 2797 fTotTracksCone->Fill(fTotTracksInCone,4,1);
0c9acc4c 2798 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 4);
2799 }
2800 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
2801 {
2802 fPtInPerpCon->Fill(fPerpCone->Pt(),5,1);
17f4943e 2803 fTotTracksCone->Fill(fTotTracksInCone,5,1);
0c9acc4c 2804 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 5);
2805 }
2806 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
2807 {
2808 fPtInPerpCon->Fill(fPerpCone->Pt(),6,1);
17f4943e 2809 fTotTracksCone->Fill(fTotTracksInCone,6,1);
0c9acc4c 2810 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 6);
2811 }
2812 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
2813 {
2814 fPtInPerpCon->Fill(fPerpCone->Pt(),7,1);
17f4943e 2815 fTotTracksCone->Fill(fTotTracksInCone,7,1);
0c9acc4c 2816 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 7);
2817 }
2818 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
2819 {
2820 fPtInPerpCon->Fill(fPerpCone->Pt(),8,1);
17f4943e 2821 fTotTracksCone->Fill(fTotTracksInCone,8,1);
0c9acc4c 2822 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 8);
2823 }
2824 }
2825 }
2826 if(fIsHIevent) //if is a PbPb event
2827 {
2828 if(fEventCent>=0&&fEventCent<10.)
2829 {
2830 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,2); //filling first centrality bin
8dcbcbbb 2831 fJetPtCentPbPbRaw->Fill(rjet->Pt(),2);
2832 fJetPtCentPbPbCorr->Fill(pTbs,2);
0c9acc4c 2833 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2834 {
2835 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,2); //filling first centrality bin
8dcbcbbb 2836 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),2);
2837 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),2);
0c9acc4c 2838 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
2839 {
2840 fPtInPerpCon->Fill(fPerpCone->Pt(),1,2);
17f4943e 2841 fTotTracksCone->Fill(fTotTracksInCone,1,2);
0c9acc4c 2842 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 1);
2843 }
2844 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
2845 {
2846 fPtInPerpCon->Fill(fPerpCone->Pt(),2,2);
17f4943e 2847 fTotTracksCone->Fill(fTotTracksInCone,2,2);
0c9acc4c 2848 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 2);
2849 }
2850 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
2851 {
2852 fPtInPerpCon->Fill(fPerpCone->Pt(),3,2);
17f4943e 2853 fTotTracksCone->Fill(fTotTracksInCone,3,2);
0c9acc4c 2854 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 3);
2855 }
2856 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
2857 {
2858 fPtInPerpCon->Fill(fPerpCone->Pt(),4,2);
17f4943e 2859 fTotTracksCone->Fill(fTotTracksInCone,4,2);
0c9acc4c 2860 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 4);
2861 }
2862 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
2863 {
2864 fPtInPerpCon->Fill(fPerpCone->Pt(),5,2);
17f4943e 2865 fTotTracksCone->Fill(fTotTracksInCone,5,2);
0c9acc4c 2866 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 5);
2867 }
2868 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
2869 {
2870 fPtInPerpCon->Fill(fPerpCone->Pt(),6,2);
17f4943e 2871 fTotTracksCone->Fill(fTotTracksInCone,6,2);
0c9acc4c 2872 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 6);
2873 }
2874 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
2875 {
2876 fPtInPerpCon->Fill(fPerpCone->Pt(),7,2);
17f4943e 2877 fTotTracksCone->Fill(fTotTracksInCone,7,2);
0c9acc4c 2878 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 7);
2879 }
2880 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
2881 {
2882 fPtInPerpCon->Fill(fPerpCone->Pt(),8,2);
17f4943e 2883 fTotTracksCone->Fill(fTotTracksInCone,8,2);
0c9acc4c 2884 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 8);
2885 }
2886 }
2887 }
2888 if(fEventCent>=10&&fEventCent<20.)
2889 {
2890 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,3); //filling second centrality bin
8dcbcbbb 2891 fJetPtCentPbPbRaw->Fill(rjet->Pt(),3);
2892 fJetPtCentPbPbCorr->Fill(pTbs,3);
0c9acc4c 2893 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2894 {
2895 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,3); //filling second centrality bin
8dcbcbbb 2896 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),3);
2897 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),3);
0c9acc4c 2898 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
2899 {
2900 fPtInPerpCon->Fill(fPerpCone->Pt(),1,3);
17f4943e 2901 fTotTracksCone->Fill(fTotTracksInCone,1,3);
0c9acc4c 2902 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 1);
2903 }
2904 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
2905 {
2906 fPtInPerpCon->Fill(fPerpCone->Pt(),2,3);
17f4943e 2907 fTotTracksCone->Fill(fTotTracksInCone,2,3);
0c9acc4c 2908 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 2);
2909 }
2910 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
2911 {
2912 fPtInPerpCon->Fill(fPerpCone->Pt(),3,3);
17f4943e 2913 fTotTracksCone->Fill(fTotTracksInCone,3,3);
0c9acc4c 2914 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 3);
2915 }
2916 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
2917 {
2918 fPtInPerpCon->Fill(fPerpCone->Pt(),4,3);
17f4943e 2919 fTotTracksCone->Fill(fTotTracksInCone,4,3);
0c9acc4c 2920 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 4);
2921 }
2922 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
2923 {
2924 fPtInPerpCon->Fill(fPerpCone->Pt(),5,3);
17f4943e 2925 fTotTracksCone->Fill(fTotTracksInCone,5,3);
0c9acc4c 2926 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 5);
2927 }
2928 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
2929 {
2930 fPtInPerpCon->Fill(fPerpCone->Pt(),6,3);
17f4943e 2931 fTotTracksCone->Fill(fTotTracksInCone,6,3);
0c9acc4c 2932 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 6);
2933 }
2934 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
2935 {
2936 fPtInPerpCon->Fill(fPerpCone->Pt(),7,3);
17f4943e 2937 fTotTracksCone->Fill(fTotTracksInCone,7,3);
0c9acc4c 2938 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 7);
2939 }
2940 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
2941 {
2942 fPtInPerpCon->Fill(fPerpCone->Pt(),8,3);
17f4943e 2943 fTotTracksCone->Fill(fTotTracksInCone,8,3);
0c9acc4c 2944 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 8);
2945 }
2946 }
2947 }
2948 if(fEventCent>=20&&fEventCent<30.)
2949 {
2950 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,4); //filling third centrality bin
8dcbcbbb 2951 fJetPtCentPbPbRaw->Fill(rjet->Pt(),4);
2952 fJetPtCentPbPbCorr->Fill(pTbs,4);
0c9acc4c 2953 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2954 {
2955 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,4); //filling third centrality bin
8dcbcbbb 2956 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),4);
2957 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),4);
0c9acc4c 2958 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
2959 {
2960 fPtInPerpCon->Fill(fPerpCone->Pt(),1,4);
17f4943e 2961 fTotTracksCone->Fill(fTotTracksInCone,1,4);
0c9acc4c 2962 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 1);
2963 }
2964 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
2965 {
2966 fPtInPerpCon->Fill(fPerpCone->Pt(),2,4);
17f4943e 2967 fTotTracksCone->Fill(fTotTracksInCone,2,4);
0c9acc4c 2968 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 2);
2969 }
2970 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
2971 {
2972 fPtInPerpCon->Fill(fPerpCone->Pt(),3,4);
17f4943e 2973 fTotTracksCone->Fill(fTotTracksInCone,3,4);
0c9acc4c 2974 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 3);
2975 }
2976 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
2977 {
2978 fPtInPerpCon->Fill(fPerpCone->Pt(),4,4);
17f4943e 2979 fTotTracksCone->Fill(fTotTracksInCone,4,4);
0c9acc4c 2980 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 4);
2981 }
2982 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
2983 {
2984 fPtInPerpCon->Fill(fPerpCone->Pt(),5,4);
17f4943e 2985 fTotTracksCone->Fill(fTotTracksInCone,5,4);
0c9acc4c 2986 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 5);
2987 }
2988 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
2989 {
2990 fPtInPerpCon->Fill(fPerpCone->Pt(),6,4);
17f4943e 2991 fTotTracksCone->Fill(fTotTracksInCone,6,4);
0c9acc4c 2992 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 6);
2993 }
2994 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
2995 {
2996 fPtInPerpCon->Fill(fPerpCone->Pt(),7,4);
17f4943e 2997 fTotTracksCone->Fill(fTotTracksInCone,7,4);
0c9acc4c 2998 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 7);
2999 }
3000 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3001 {
3002 fPtInPerpCon->Fill(fPerpCone->Pt(),8,4);
17f4943e 3003 fTotTracksCone->Fill(fTotTracksInCone,8,4);
0c9acc4c 3004 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 8);
3005 }
3006 }
3007 }
3008 if(fEventCent>=30&&fEventCent<40.)
3009 {
3010 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,5); //filling fourth centrality bin
8dcbcbbb 3011 fJetPtCentPbPbRaw->Fill(rjet->Pt(),5);
3012 fJetPtCentPbPbCorr->Fill(pTbs,5);
0c9acc4c 3013 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3014 {
3015 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,5); //filling fourth centrality bin
8dcbcbbb 3016 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),5);
3017 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),5);
0c9acc4c 3018 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3019 {
3020 fPtInPerpCon->Fill(fPerpCone->Pt(),1,5);
17f4943e 3021 fTotTracksCone->Fill(fTotTracksInCone,1,5);
0c9acc4c 3022 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 1);
3023 }
3024 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3025 {
3026 fPtInPerpCon->Fill(fPerpCone->Pt(),2,5);
17f4943e 3027 fTotTracksCone->Fill(fTotTracksInCone,2,5);
0c9acc4c 3028 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 2);
3029 }
3030 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3031 {
3032 fPtInPerpCon->Fill(fPerpCone->Pt(),3,5);
17f4943e 3033 fTotTracksCone->Fill(fTotTracksInCone,3,5);
0c9acc4c 3034 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 3);
3035 }
3036 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3037 {
3038 fPtInPerpCon->Fill(fPerpCone->Pt(),4,5);
17f4943e 3039 fTotTracksCone->Fill(fTotTracksInCone,4,5);
0c9acc4c 3040 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 4);
3041 }
3042 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3043 {
3044 fPtInPerpCon->Fill(fPerpCone->Pt(),5,5);
17f4943e 3045 fTotTracksCone->Fill(fTotTracksInCone,5,5);
0c9acc4c 3046 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 5);
3047 }
3048 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3049 {
3050 fPtInPerpCon->Fill(fPerpCone->Pt(),6,5);
17f4943e 3051 fTotTracksCone->Fill(fTotTracksInCone,6,5);
0c9acc4c 3052 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 6);
3053 }
3054 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3055 {
3056 fPtInPerpCon->Fill(fPerpCone->Pt(),7,5);
17f4943e 3057 fTotTracksCone->Fill(fTotTracksInCone,7,5);
0c9acc4c 3058 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 7);
3059 }
3060 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3061 {
3062 fPtInPerpCon->Fill(fPerpCone->Pt(),8,5);
17f4943e 3063 fTotTracksCone->Fill(fTotTracksInCone,8,5);
0c9acc4c 3064 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 8);
3065 }
3066 }
3067 }
3068 if(fEventCent>=40&&fEventCent<50.)
3069 {
3070 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,6); //filling fourth centrality bin
8dcbcbbb 3071 fJetPtCentPbPbRaw->Fill(rjet->Pt(),6);
3072 fJetPtCentPbPbCorr->Fill(pTbs,6);
0c9acc4c 3073 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3074 {
3075 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,6); //filling fourth centrality bin
8dcbcbbb 3076 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),6);
3077 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),6);
0c9acc4c 3078 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3079 {
3080 fPtInPerpCon->Fill(fPerpCone->Pt(),1,6);
17f4943e 3081 fTotTracksCone->Fill(fTotTracksInCone,1,6);
0c9acc4c 3082 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 1);
3083 }
3084 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3085 {
3086 fPtInPerpCon->Fill(fPerpCone->Pt(),2,6);
17f4943e 3087 fTotTracksCone->Fill(fTotTracksInCone,2,6);
0c9acc4c 3088 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 2);
3089 }
3090 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3091 {
3092 fPtInPerpCon->Fill(fPerpCone->Pt(),3,6);
17f4943e 3093 fTotTracksCone->Fill(fTotTracksInCone,3,6);
0c9acc4c 3094 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 3);
3095 }
3096 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3097 {
3098 fPtInPerpCon->Fill(fPerpCone->Pt(),4,6);
17f4943e 3099 fTotTracksCone->Fill(fTotTracksInCone,4,6);
0c9acc4c 3100 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 4);
3101 }
3102 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3103 {
3104 fPtInPerpCon->Fill(fPerpCone->Pt(),5,6);
17f4943e 3105 fTotTracksCone->Fill(fTotTracksInCone,5,6);
0c9acc4c 3106 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 5);
3107 }
3108 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3109 {
3110 fPtInPerpCon->Fill(fPerpCone->Pt(),6,6);
17f4943e 3111 fTotTracksCone->Fill(fTotTracksInCone,6,6);
0c9acc4c 3112 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 6);
3113 }
3114 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3115 {
3116 fPtInPerpCon->Fill(fPerpCone->Pt(),7,6);
17f4943e 3117 fTotTracksCone->Fill(fTotTracksInCone,7,6);
0c9acc4c 3118 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 7);
3119 }
3120 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3121 {
3122 fPtInPerpCon->Fill(fPerpCone->Pt(),8,6);
17f4943e 3123 fTotTracksCone->Fill(fTotTracksInCone,8,6);
0c9acc4c 3124 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 8);
3125 }
3126 }
3127 }
3128 if(fEventCent>=50&&fEventCent<60.)
3129 {
3130 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,7); //filling fourth centrality bin
8dcbcbbb 3131 fJetPtCentPbPbRaw->Fill(rjet->Pt(),7);
3132 fJetPtCentPbPbCorr->Fill(pTbs,7);
0c9acc4c 3133 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3134 {
3135 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,7); //filling fourth centrality bin
8dcbcbbb 3136 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),7);
3137 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),7);
0c9acc4c 3138 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3139 {
3140 fPtInPerpCon->Fill(fPerpCone->Pt(),1,7);
17f4943e 3141 fTotTracksCone->Fill(fTotTracksInCone,1,7);
0c9acc4c 3142 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 1);
3143 }
3144 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3145 {
3146 fPtInPerpCon->Fill(fPerpCone->Pt(),2,7);
17f4943e 3147 fTotTracksCone->Fill(fTotTracksInCone,2,7);
0c9acc4c 3148 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 2);
3149 }
3150 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3151 {
3152 fPtInPerpCon->Fill(fPerpCone->Pt(),3,7);
17f4943e 3153 fTotTracksCone->Fill(fTotTracksInCone,3,7);
0c9acc4c 3154 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 3);
3155 }
3156 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3157 {
3158 fPtInPerpCon->Fill(fPerpCone->Pt(),4,7);
17f4943e 3159 fTotTracksCone->Fill(fTotTracksInCone,4,7);
0c9acc4c 3160 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 4);
3161 }
3162 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3163 {
3164 fPtInPerpCon->Fill(fPerpCone->Pt(),5,7);
17f4943e 3165 fTotTracksCone->Fill(fTotTracksInCone,5,7);
0c9acc4c 3166 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 5);
3167 }
3168 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3169 {
3170 fPtInPerpCon->Fill(fPerpCone->Pt(),6,7);
17f4943e 3171 fTotTracksCone->Fill(fTotTracksInCone,6,7);
0c9acc4c 3172 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 6);
3173 }
3174 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3175 {
3176 fPtInPerpCon->Fill(fPerpCone->Pt(),7,7);
17f4943e 3177 fTotTracksCone->Fill(fTotTracksInCone,7,7);
0c9acc4c 3178 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 7);
3179 }
3180 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3181 {
3182 fPtInPerpCon->Fill(fPerpCone->Pt(),8,7);
17f4943e 3183 fTotTracksCone->Fill(fTotTracksInCone,8,7);
0c9acc4c 3184 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 8);
3185 }
3186 }
3187 }
3188 if(fEventCent>=60&&fEventCent<70.)
3189 {
3190 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,8); //filling fourth centrality bin
8dcbcbbb 3191 fJetPtCentPbPbRaw->Fill(rjet->Pt(),8);
3192 fJetPtCentPbPbCorr->Fill(pTbs,8);
0c9acc4c 3193 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3194 {
3195 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,8); //filling fourth centrality bin
8dcbcbbb 3196 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),8);
3197 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),8);
0c9acc4c 3198 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3199 {
3200 fPtInPerpCon->Fill(fPerpCone->Pt(),1,8);
17f4943e 3201 fTotTracksCone->Fill(fTotTracksInCone,1,8);
0c9acc4c 3202 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 1);
3203 }
3204 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3205 {
3206 fPtInPerpCon->Fill(fPerpCone->Pt(),2,8);
17f4943e 3207 fTotTracksCone->Fill(fTotTracksInCone,2,8);
0c9acc4c 3208 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 2);
3209 }
3210 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3211 {
3212 fPtInPerpCon->Fill(fPerpCone->Pt(),3,8);
17f4943e 3213 fTotTracksCone->Fill(fTotTracksInCone,3,8);
0c9acc4c 3214 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 3);
3215 }
3216 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3217 {
3218 fPtInPerpCon->Fill(fPerpCone->Pt(),4,8);
17f4943e 3219 fTotTracksCone->Fill(fTotTracksInCone,4,8);
0c9acc4c 3220 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 4);
3221 }
3222 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3223 {
3224 fPtInPerpCon->Fill(fPerpCone->Pt(),5,8);
17f4943e 3225 fTotTracksCone->Fill(fTotTracksInCone,5,8);
0c9acc4c 3226 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 5);
3227 }
3228 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3229 {
3230 fPtInPerpCon->Fill(fPerpCone->Pt(),6,8);
17f4943e 3231 fTotTracksCone->Fill(fTotTracksInCone,6,8);
0c9acc4c 3232 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 6);
3233 }
3234 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3235 {
3236 fPtInPerpCon->Fill(fPerpCone->Pt(),7,8);
17f4943e 3237 fTotTracksCone->Fill(fTotTracksInCone,7,8);
0c9acc4c 3238 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 7);
3239 }
3240 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3241 {
3242 fPtInPerpCon->Fill(fPerpCone->Pt(),8,8);
17f4943e 3243 fTotTracksCone->Fill(fTotTracksInCone,8,8);
0c9acc4c 3244 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 8);
3245 }
3246 }
3247 }
3248 if(fEventCent>=70&&fEventCent<80.)
3249 {
3250 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,9); //filling fourth centrality bin
8dcbcbbb 3251 fJetPtCentPbPbRaw->Fill(rjet->Pt(),9);
3252 fJetPtCentPbPbCorr->Fill(pTbs,9);
0c9acc4c 3253 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3254 {
3255 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,9); //filling fourth centrality bin
8dcbcbbb 3256 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),9);
3257 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),9);
0c9acc4c 3258 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3259 {
3260 fPtInPerpCon->Fill(fPerpCone->Pt(),1,9);
17f4943e 3261 fTotTracksCone->Fill(fTotTracksInCone,1,9);
0c9acc4c 3262 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 1);
3263 }
3264 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3265 {
3266 fPtInPerpCon->Fill(fPerpCone->Pt(),2,9);
17f4943e 3267 fTotTracksCone->Fill(fTotTracksInCone,2,9);
0c9acc4c 3268 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 2);
3269 }
3270 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3271 {
3272 fPtInPerpCon->Fill(fPerpCone->Pt(),3,9);
17f4943e 3273 fTotTracksCone->Fill(fTotTracksInCone,3,9);
0c9acc4c 3274 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 3);
3275 }
3276 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3277 {
3278 fPtInPerpCon->Fill(fPerpCone->Pt(),4,9);
17f4943e 3279 fTotTracksCone->Fill(fTotTracksInCone,4,9);
0c9acc4c 3280 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 4);
3281 }
3282 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3283 {
3284 fPtInPerpCon->Fill(fPerpCone->Pt(),5,9);
17f4943e 3285 fTotTracksCone->Fill(fTotTracksInCone,5,9);
0c9acc4c 3286 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 5);
3287 }
3288 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3289 {
3290 fPtInPerpCon->Fill(fPerpCone->Pt(),6,9);
17f4943e 3291 fTotTracksCone->Fill(fTotTracksInCone,6,9);
0c9acc4c 3292 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 6);
3293 }
3294 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3295 {
3296 fPtInPerpCon->Fill(fPerpCone->Pt(),7,9);
17f4943e 3297 fTotTracksCone->Fill(fTotTracksInCone,7,9);
0c9acc4c 3298 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 7);
3299 }
3300 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3301 {
3302 fPtInPerpCon->Fill(fPerpCone->Pt(),8,9);
17f4943e 3303 fTotTracksCone->Fill(fTotTracksInCone,8,9);
0c9acc4c 3304 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 8);
3305 }
3306 }
3307 }
3308 if(fEventCent>=80&&fEventCent<100.)
3309 {
3310 fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,10); //filling sixth centrality bin
8dcbcbbb 3311 fJetPtCentPbPbRaw->Fill(rjet->Pt(),10);
3312 fJetPtCentPbPbCorr->Fill(pTbs,10);
0c9acc4c 3313 if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3314 {
3315 fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,10); //filling sixth centrality bin
8dcbcbbb 3316 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),10);
3317 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),10);
0c9acc4c 3318 if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3319 {
3320 fPtInPerpCon->Fill(fPerpCone->Pt(),1,10);
17f4943e 3321 fTotTracksCone->Fill(fTotTracksInCone,1,10);
0c9acc4c 3322 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 1);
3323 }
3324 if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3325 {
3326 fPtInPerpCon->Fill(fPerpCone->Pt(),2,10);
17f4943e 3327 fTotTracksCone->Fill(fTotTracksInCone,2,10);
0c9acc4c 3328 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 2);
3329 }
3330 if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3331 {
3332 fPtInPerpCon->Fill(fPerpCone->Pt(),3,10);
17f4943e 3333 fTotTracksCone->Fill(fTotTracksInCone,3,10);
0c9acc4c 3334 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 3);
3335 }
3336 if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3337 {
3338 fPtInPerpCon->Fill(fPerpCone->Pt(),4,10);
17f4943e 3339 fTotTracksCone->Fill(fTotTracksInCone,4,10);
0c9acc4c 3340 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 4);
3341 }
3342 if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3343 {
3344 fPtInPerpCon->Fill(fPerpCone->Pt(),5,10);
17f4943e 3345 fTotTracksCone->Fill(fTotTracksInCone,5,10);
0c9acc4c 3346 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 5);
3347 }
3348 if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3349 {
3350 fPtInPerpCon->Fill(fPerpCone->Pt(),6,10);
17f4943e 3351 fTotTracksCone->Fill(fTotTracksInCone,6,10);
0c9acc4c 3352 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 6);
3353 }
3354 if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3355 {
3356 fPtInPerpCon->Fill(fPerpCone->Pt(),7,10);
17f4943e 3357 fTotTracksCone->Fill(fTotTracksInCone,7,10);
0c9acc4c 3358 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 7);
3359 }
3360 if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3361 {
3362 fPtInPerpCon->Fill(fPerpCone->Pt(),8,10);
17f4943e 3363 fTotTracksCone->Fill(fTotTracksInCone,8,10);
0c9acc4c 3364 FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 8);
3365 }
3366 }
3367 }
3368 }
3369 }
3370
3371 AliDebug(4,"Before filling the histograms for this jet of min and max pT in NTX \n");
3372 AliDebug(4,Form("Min:%f, Max:%f \n",fMinTrackPtInNTX,fMaxTrackPtInNTX));
8dcbcbbb 3373 fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),1); // for rec pp or inclusive PbPb
3374 fJetPtCentPbPbRaw->Fill(rjet->Pt(),1); // for rec pp or inclusive PbPb
3375 fJetPtCentPbPbCorr->Fill(pTbs,1); // for rec pp or inclusive PbPb
0c9acc4c 3376 fMaxTrackPtInNTXh[1]->Fill(fMaxTrackPtInNTX,rjet->Pt());
3377 if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
3378 {
8dcbcbbb 3379 fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),1); // for rec pp or inclusive PbPb
0c9acc4c 3380 fMaxTrackPtInNTXRecalc->Fill(fMaxTrackPtInNTXR,rjet->Pt());
3381 }
3382 AliDebug(4,"After filling the histograms for this jet of min and max pT in NTX \n");
3383 for(Int_t v=0 ; v<rJetCounter; v++)
3384 {
3385 if(v<7)
3386 fJetsMultPtRD->Fill(jetPtsR[v],rJetCounter);
3387 }
3388 irecj++;
3389 } //reco jets
3390 nRecJets=irecj;
3391 fNAccJetsRD->Fill(rJetCounter,rJetCounter);
3392 // reference multiplicity stuff in pp, also filled in PbPb, but does not matter.
3393 if(v0CorrMult<25)
3394 fNAccJetsRDMult[0]->Fill(rJetCounter);
3395 if(v0CorrMult>=25&&v0CorrMult<50)
3396 fNAccJetsRDMult[1]->Fill(rJetCounter);
3397 if(v0CorrMult>=50&&v0CorrMult<90)
3398 fNAccJetsRDMult[2]->Fill(rJetCounter);
3399 if(v0CorrMult>=90&&v0CorrMult<120)
3400 fNAccJetsRDMult[3]->Fill(rJetCounter);
3401 if(v0CorrMult>=120&&v0CorrMult<150)
3402 fNAccJetsRDMult[4]->Fill(rJetCounter);
3403 if(v0CorrMult>=150&&v0CorrMult<200)
3404 fNAccJetsRDMult[5]->Fill(rJetCounter);
3405 if(v0CorrMult>=200&&v0CorrMult<300)
3406 fNAccJetsRDMult[6]->Fill(rJetCounter);
3407 if(v0CorrMult>=300)
3408 fNAccJetsRDMult[7]->Fill(rJetCounter);
3409
3410 // reference multiplicity from tracks in TPC minus jet related tracks
3411 if(refNJMult<5) // &&refNJMult>1
3412 fNAccJetsRDMultSE[0]->Fill(rJetCounter);
3413 if(refNJMult>=5&&refNJMult<10)
3414 fNAccJetsRDMultSE[1]->Fill(rJetCounter);
3415 if(refNJMult>=10&&refNJMult<15)
3416 fNAccJetsRDMultSE[2]->Fill(rJetCounter);
3417 if(refNJMult>=15&&refNJMult<20)
3418 fNAccJetsRDMultSE[3]->Fill(rJetCounter);
3419 if(refNJMult>=20&&refNJMult<30)
3420 fNAccJetsRDMultSE[4]->Fill(rJetCounter);
3421 if(refNJMult>=30&&refNJMult<40)
3422 fNAccJetsRDMultSE[5]->Fill(rJetCounter);
3423 if(refNJMult>=40&&refNJMult<50)
3424 fNAccJetsRDMultSE[6]->Fill(rJetCounter);
3425 if(refNJMult>=50)
3426 fNAccJetsRDMultSE[7]->Fill(rJetCounter);
3427
3428 AliDebug(4,"Checking if this data contains MC, in order to relate the jets \n");
3429 if(fUseAODMC)
3430 {
3431 AliDebug(4,"Relating MC jets with reconstructed jets");
3432 // Relate the jets
3433 Int_t fCJDebug = 0; //debug level for getclosest jet
3434 nGenJets = TMath::Min(nGenJets,maxJetNum);
3435 nRecJets = TMath::Min(nRecJets,maxJetNum);
3436 Int_t iGenIndex[maxJetNum]; // Index of the generated jet for i-th rec -1 if none
3437 Int_t iRecIndex[maxJetNum]; // Index of the reco jet for i-th gen -1 if none
3438 for(int i = 0;i<maxJetNum;++i)
3439 {
3440 iGenIndex[i] = iRecIndex[i] = -1;
3441 }
3442
3443 AliAnalysisHelperJetTasks::GetClosestJets(genJets,nGenJets,recJets,nRecJets,
3444 iGenIndex,iRecIndex,fCJDebug);
3445 if(fCJDebug > 10)
3446 AliDebug(4,Form("%s:%d",(char*)__FILE__,__LINE__));
3447 if(fCJDebug > 3)
3448 {
3449 for(int i = 0;i<maxJetNum;++i)
3450 {
3451 if(iGenIndex[i]>=0)
3452 {
3453 AliDebug(4,Form("iGenFound: %d -> %d",i,iGenIndex[i]));
3454 // para el i-esimo jet reconstruido corresponde el jet iGenIndex[i]
3455 AliDebug(4,Form("El jet reconstruido numero %d tiene sabor %d",i, genJetsFlavor[iGenIndex[i]]));
3456 }
3457 if(iRecIndex[i]>=0)
3458 {
3459 AliDebug(4,Form("iRecFound: %d -> %d",i,iRecIndex[i]));
3460 // para el i-esimo jet generado corresponde el jet iRecIndex[i]
3461 }
3462 }
3463 }
3464 AliDebug(4,"Helper part finished");
3465
3466 // Llenar los histogramas para los jets reconstruidos
3467
3468 Int_t crf = 0; // current reco jet flavor
3469 Int_t crt = 0; // current reco jet tracks
3470 Double_t crpt = 0; // current jet pt
3471 Double_t cscm = 0.0;// current second central moment
3472
3473 for(Int_t ixr=0; ixr<maxJetNum; ixr++)
3474 {
3475 AliDebug(4,Form("Processing jet number:%i",ixr));
3476 if(iGenIndex[ixr]>=0)
3477 {
3478 crf = genJetsFlavor[iGenIndex[ixr]]; //para el reco jet con indice ixr
3479 crt = nrectracks[ixr]; // se necesitaron este numero de tracks
3480 crpt = ptrecjet[ixr];
3481 cscm = scmr[ixr];
3482
3483 //Fill candidates histos
3484 if(crt>=7) //gluon candidate
3485 fFragCandidates[0]->Add(fHistContainerR4[ixr]);
3486 if(crt<=4) //quark candidate
3487 fFragCandidates[1]->Add(fHistContainerR4[ixr]);
3488
3489 switch(abs(crf))
3490 {
3491 case 1:
3492 fNChTr[6]->Fill(crt,crpt);
3493 fHistPtParton[6]->Fill(crpt);
3494 fSCM[6]->Fill(cscm,crpt);
3495 fFragChargedR4[0]->Add(fHistContainerR4[ixr]);
3496 fFragChargedR3[0]->Add(fHistContainerR3[ixr]);
3497 fFragChargedR2[0]->Add(fHistContainerR2[ixr]);
3498 break;
3499 case 2:
3500 fNChTr[7]->Fill(crt,crpt);
3501 fHistPtParton[7]->Fill(crpt);
3502 fSCM[7]->Fill(cscm,crpt);
3503 fFragChargedR4[1]->Add(fHistContainerR4[ixr]);
3504 fFragChargedR3[1]->Add(fHistContainerR3[ixr]);
3505 fFragChargedR2[1]->Add(fHistContainerR2[ixr]);
3506 break;
3507 case 3:
3508 fNChTr[8]->Fill(crt,crpt);
3509 fHistPtParton[8]->Fill(crpt);
3510 fSCM[8]->Fill(cscm,crpt);
3511 fFragChargedR4[2]->Add(fHistContainerR4[ixr]);
3512 fFragChargedR3[2]->Add(fHistContainerR3[ixr]);
3513 fFragChargedR2[2]->Add(fHistContainerR2[ixr]);
3514 break;
3515 case 4:
3516 fNChTr[9]->Fill(crt,crpt);
3517 fHistPtParton[9]->Fill(crpt);
3518 fSCM[9]->Fill(cscm,crpt);
3519 fFragChargedR4[3]->Add(fHistContainerR4[ixr]);
3520 fFragChargedR3[3]->Add(fHistContainerR3[ixr]);
3521 fFragChargedR2[3]->Add(fHistContainerR2[ixr]);
3522 break;
3523 case 5:
3524 fNChTr[10]->Fill(crt,crpt);
3525 fHistPtParton[10]->Fill(crpt);
3526 fSCM[10]->Fill(cscm,crpt);
3527 fFragChargedR4[4]->Add(fHistContainerR4[ixr]);
3528 fFragChargedR3[4]->Add(fHistContainerR3[ixr]);
3529 fFragChargedR2[4]->Add(fHistContainerR2[ixr]);
3530 break;
3531 case 21:
3532 fNChTr[11]->Fill(crt,crpt);
3533 fHistPtParton[11]->Fill(crpt);
3534 fSCM[11]->Fill(cscm,crpt);
3535 fFragChargedR4[5]->Add(fHistContainerR4[ixr]);
3536 fFragChargedR3[5]->Add(fHistContainerR3[ixr]);
3537 fFragChargedR2[5]->Add(fHistContainerR2[ixr]);
3538 break;
3539 default:
3540 break;
3541 } // end switch
3542 AliDebug(4,Form("Sabor del reco jet con pt:%f y numero:%d es: %d y se necesitaron %d tracks \n",crpt,ixr,crf,crt));
3543 } // end index condition
3544 } // end for cycle correlation gen-reco flavor
3545 } // end if MC info
3546 } // end of only MC info in the AOD, no reco jets
3547 PostData(1, fOutputList);
3548}
3549
3550//________________________________________________________________________
3551void AliAnalysisTaskPartonDisc::Terminate(const Option_t *)
3552{
3553 // Draw result to the screen
3554 // Called once at the end of the query
3555}
3556//________________________________________________________________________
3557Int_t AliAnalysisTaskPartonDisc::GetMCEventType(AliMCEvent *mcEvent)
3558{
3559 //
3560 // Get the event type from the pythia headers
3561 //
3562
3563 Int_t processNumber = 0;
3564 AliGenEventHeader* genHeader = mcEvent->GenEventHeader();
3565 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
3566
3567 if(!pythiaGenHeader)
3568 {
3569 AliDebug(4,Form(" %s:%d No Pythia header!",(char*)__FILE__,__LINE__));
3570 return 0;
3571 }
3572
3573 processNumber = pythiaGenHeader->ProcessType();
3574
3575 return processNumber;
3576}
3577//________________________________________________________________________
3578Int_t AliAnalysisTaskPartonDisc::GetPhojetEventType(AliMCEvent *mcEvent)
3579{
3580 //
3581 // Get the event type from the phojet header
3582 //
3583
3584 Int_t processNumber = 0;
3585 AliGenEventHeader* genHeader = mcEvent->GenEventHeader();
3586 AliGenDPMjetEventHeader* phojetGenHeader = dynamic_cast<AliGenDPMjetEventHeader*>(genHeader);
3587
3588 if(!phojetGenHeader)
3589 {
3590 AliDebug(4,Form(" %s:%d No Phojet header!",(char*)__FILE__,__LINE__));
3591 return 0;
3592 }
3593
3594 processNumber = phojetGenHeader->ProcessType();
3595
3596 return processNumber;
3597}
3598//________________________________________________________________________
3599Bool_t AliAnalysisTaskPartonDisc::IsInsideAcceptance(AliAODJet *jet)
3600{
3601 //
8dcbcbbb 3602 // Check if the jet is inside abs(eta)<=fJetAcceptance
0c9acc4c 3603 //
3604
3605 Double_t jeteta = jet->Eta();
8dcbcbbb 3606 if(TMath::Abs(jeteta)<=fJetAcceptance)
0c9acc4c 3607 return kTRUE;
3608 else
3609 return kFALSE;
3610
3611}
3612//________________________________________________________________________
3613Int_t AliAnalysisTaskPartonDisc::GetJetFlavour(AliAODJet *jet, Int_t ntracks, TClonesArray *mcarray)
3614{
3615 //
3616 // Get the jet flavour, using the definition:
3617 // The flavour will be that of the parton with the highest energy
3618 // within an angular distance <= 0.3
3619 // This method also keeps track of the mother of the parton giving the flavor
3620 //
3621
3622 Int_t flavour = 0;
3623 Int_t pdgCode;
3624 Int_t aPDGcode;
3625 Double_t currentEnergy = 0;
3626 Double_t maxEnergy = 0;
3627 Double_t jeteta = jet->Eta();
3628 Double_t jetphi = jet->Phi();
3629 Double_t tracketa = 0;
3630 Double_t trackphi = 0;
3631 Double_t flavrad = fFlavorRadius; //radius used for flavor
3632 Int_t indexM = 0;
3633 UInt_t status=0; //status code of leading parton
3634 fMpdg=0; // Initialize before each selection
3635 AliAODMCParticle *moftrack=0;
3636 for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
3637 {
3638 AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
3639 if(!mctrack) continue;
3640 pdgCode = mctrack->GetPdgCode();
3641 aPDGcode = abs(pdgCode);
3642 if(aPDGcode==1||aPDGcode==2||aPDGcode==3||aPDGcode==4||aPDGcode==5||aPDGcode==6||aPDGcode==9||aPDGcode==21)
3643 {
3644 tracketa = mctrack->Eta();
3645 trackphi = mctrack->Phi();
3646 if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=flavrad)
3647 {
3648 currentEnergy = mctrack->E();
3649 if(currentEnergy>maxEnergy)
3650 {
3651 maxEnergy = currentEnergy;
3652 flavour = pdgCode;
3653 indexM = mctrack->GetMother();
3654 if(fCheckMCStatus) // default is true
3655 status = mctrack->GetStatus();
3656 // fFlavProc->Fill(flavour,status);
3657 //testing
3658 if(indexM<=0)
3659 fMpdg = 0; // Unknown
3660 else
3661 {
3662 moftrack = (AliAODMCParticle*) mcarray->At(indexM);
3663 fMpdg = moftrack->GetPdgCode();
3664 }
3665 }
3666 }
3667 }
3668 }
3669
3670 // //Restriction to pythia string fragmentation
3671 // if(!fPhojetMC) //if pythia
3672 // {
3673 // if(fMpdg!=0) // if not from the string
3674 // flavour=0;
3675 // }
3676
3677 // PDG code of the mother of the leading parton, leading parton, jet pT
3678 fPDGMothLPart->Fill(fMpdg,flavour,jet->Pt());
3679 fFlavProc->Fill(flavour,status);
3680
3681 return flavour;
3682}
3683//________________________________________________________________________
3684Double_t AliAnalysisTaskPartonDisc::GetDeltaR(Double_t eta1, Double_t phi1,Double_t eta2, Double_t phi2)
3685{
3686 //
3687 // Return R between the two jets or particles
3688 //
3689
3690 Double_t deltaphi = TMath::Abs(phi2-phi1);
3691 if (deltaphi > TMath::Pi())
3692 deltaphi = 2.0 * TMath::Pi() - deltaphi;
3693
3694
3695 Double_t deltaR = sqrt((eta2-eta1)*(eta2-eta1)+deltaphi*deltaphi);
3696 return deltaR;
3697
3698}
3699//________________________________________________________________________
3700Int_t AliAnalysisTaskPartonDisc::GetNumberOfMcChargedTracks(Int_t percentage,AliAODJet *jet, Int_t ntracks, TClonesArray *mcarray, Double_t jr)
3701{
3702 //
3703 // Calculate the number of charged particles necessary to
3704 // add the given percentage of the jet energy (transverse energy)
3705 // for the MC case
3706
3707 Int_t numberOfChargedTracks = 0;
3708 Int_t currentNumber = 0;
3709 Double_t jeteta = jet->Eta();
3710 Double_t jetphi = jet->Phi();
3711 Double_t jetpT = jet->Pt();
3712 Double_t tracketa = 0;
3713 Double_t trackphi = 0;
3714 Int_t arraysize = 1000;
3715 Bool_t rfTrkFlag = kFALSE;
3716 fCurrentJetCharge=0;
3717
3718 AliDebug(4,Form("Eta of the jet:%f ",jeteta));
3719 if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) // jetpT==0
3720 return 0;
3721
3722 // RefTracks
3723 Int_t trkinjet = jet->GetRefTracks()->GetEntriesFast();
3724 if(trkinjet!=0)
3725 rfTrkFlag = kTRUE;
3726 AliDebug(4,Form("Number of tracks in this mc jet by RefTracks:%i \n",trkinjet));
3727
3728 AllocateStaticContainer(arraysize);
3729 InitializeStaticContainer(arraysize);
3730
17f4943e 3731 Double_t randomNum = 0.;
3732
0c9acc4c 3733 if(!rfTrkFlag) // if not track ref, check track by track
3734 {
3735 AliDebug(4,Form("Empty Track Refs (mc)!"));
3736 for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
3737 {
3738 AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
3739 if(!mctrack) continue;
3740 tracketa = mctrack->Eta();
3741 trackphi = mctrack->Phi();
3742 if(mctrack->Pt()<fMinpTVal) continue; // pT cut, not using track refs
3743 if(mctrack->IsPhysicalPrimary())
3744 {
3745 if(mctrack->Charge()!=0&&mctrack->Charge()!=-99)
3746 {
3747 if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
17f4943e 3748 {
3749 randomNum = gRandom->Rndm();
3750 if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection dentro del cono
0c9acc4c 3751 currentNumber++;
3752 fCurrentJetCharge=fCurrentJetCharge+mctrack->Charge(); //add the charge of this track
3753 fgContainer[currentNumber-1] = mctrack->Pt(); // save the current pt in the container
3754 } // end if inside jet
3755 } // end charged
3756 } // end physical primary
3757 } // end for tracks
3758 } // end rfTrkFlag
3759
3760 if(rfTrkFlag) // if track ref, use them
3761 {
3762 AliDebug(4,Form("Using Track Refs (mc)!"));
3763 for(Int_t ixt=0; ixt<trkinjet;ixt++)
3764 {
3765 AliAODMCParticle *vtrack = dynamic_cast<AliAODMCParticle*>(jet->GetRefTracks()->At(ixt));
3766 if(!vtrack) continue;
3767 if(vtrack->Charge()!=0&&vtrack->Charge()!=-99)
3768 {
17f4943e 3769 randomNum = gRandom->Rndm();
3770 if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection dentro del cono
0c9acc4c 3771 currentNumber++;
3772 fCurrentJetCharge=fCurrentJetCharge+vtrack->Charge(); //add the charge of this track
3773 fgContainer[currentNumber-1] = vtrack->Pt(); // save the current pt in the container
3774 }
3775 } // end trk in jet
3776 } // end if trk ref
3777
3778 // sort the contents of the container
3779 SortArray(fgContainer,arraysize);
3780 // loop over the contents and count how many tracks are necessary to recover the percentage of the energy
3781 numberOfChargedTracks = TracksForPercentage(fgContainer, arraysize, percentage, jetpT);
3782 AliDebug(4,Form("Number of tracks was:%i, returning",numberOfChargedTracks));
3783 return numberOfChargedTracks;
3784
3785}
3786//________________________________________________________________________
3787Int_t AliAnalysisTaskPartonDisc::GetNumberOfChargedTracks(Int_t percentage,AliAODJet *jet, Int_t ntracks, AliAODEvent *aode, Double_t jr)
3788{
3789 //
3790 // Calculate the number of charged particles necessary to
3791 // add the given percentage of the jet energy (transverse energy)
3792 // for the AOD track case
3793
3794 Int_t numberOfChargedTracks = 0;
3795 Int_t currentNumber = 0;
3796 Double_t jeteta = jet->Eta();
3797 Double_t jetphi = jet->Phi();
3798 Double_t jetpT = jet->Pt();
3799 Double_t tracketa = 0;
3800 Double_t trackphi = 0;
3801 Int_t arraysize = 1000;
3802 Bool_t rfTrkFlag = kFALSE;
3803 fCurrentJetCharge=0;
3804
3805 if(IsEqualRel(jetpT, 0.0)) // IsEqualRel(jetpT, 0.0) // jetpT==0
3806 return 0;
3807
3808 // RefTracks
3809 Int_t trkinjet = jet->GetRefTracks()->GetEntriesFast();
3810 if(trkinjet!=0&&!fForceNotTR)
3811 rfTrkFlag = kTRUE;
3812 AliDebug(4,Form("Number of tracks in this reco jet by RefTracks:%i \n",trkinjet));
3813
3814 AllocateStaticContainer(arraysize);
3815 InitializeStaticContainer(arraysize);
3816 if(!rfTrkFlag) // if not track ref, check track by track
3817 {
3818 AliDebug(4,Form("Empty Track Refs (reco)!"));
3819 for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
3820 {
f15c1f69 3821 AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(aode->GetTrack(iTracks));
3822 if(!aodtrack) AliFatal("Not a standard AOD");
0c9acc4c 3823 if(!aodtrack) continue;
3824 tracketa = aodtrack->Eta();
3825 trackphi = aodtrack->Phi();
3826 if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
3827 {
3828 if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
0c9acc4c 3829 if(aodtrack->Pt()<fMinpTVal) continue; // pT cut, not using track refs
3830 currentNumber++;
3831 fCurrentJetCharge=fCurrentJetCharge+aodtrack->Charge();
3832 fgContainer[currentNumber-1] = aodtrack->Pt(); // save the current pt in the container
3833
3834 ////////start centrality dependent pT spec ////////
3835 if(!fIsHIevent) //if is a proton proton event
3836 {
3837 if((jet->Pt()>10.)&&(jet->Pt()<20.))
3838 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,1);
3839 if((jet->Pt()>20.)&&(jet->Pt()<30.))
3840 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,1);
3841 if((jet->Pt()>30.)&&(jet->Pt()<40.))
3842 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,1);
3843 if((jet->Pt()>40.)&&(jet->Pt()<50.))
3844 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,1);
3845 if((jet->Pt()>50.)&&(jet->Pt()<60.))
3846 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,1);
3847 if((jet->Pt()>60.)&&(jet->Pt()<70.))
3848 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,1);
3849 if((jet->Pt()>70.)&&(jet->Pt()<80.))
3850 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,1);
3851 if((jet->Pt()>80.)&&(jet->Pt()<90.))
3852 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,1);
3853 } // end of pp event
3854 if(fIsHIevent) //if is a PbPb event
3855 {
3856 if(fEventCent>=0&&fEventCent<10.)
3857 {
3858 if((jet->Pt()>10.)&&(jet->Pt()<20.))
3859 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,2);
3860 if((jet->Pt()>20.)&&(jet->Pt()<30.))
3861 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,2);
3862 if((jet->Pt()>30.)&&(jet->Pt()<40.))
3863 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,2);
3864 if((jet->Pt()>40.)&&(jet->Pt()<50.))
3865 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,2);
3866 if((jet->Pt()>50.)&&(jet->Pt()<60.))
3867 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,2);
3868 if((jet->Pt()>60.)&&(jet->Pt()<70.))
3869 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,2);
3870 if((jet->Pt()>70.)&&(jet->Pt()<80.))
3871 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,2);
3872 if((jet->Pt()>80.)&&(jet->Pt()<90.))
3873 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,2);
3874 } // end of 0-10
3875 if(fEventCent>=10&&fEventCent<20.)
3876 {
3877 if((jet->Pt()>10.)&&(jet->Pt()<20.))
3878 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,3);
3879 if((jet->Pt()>20.)&&(jet->Pt()<30.))
3880 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,3);
3881 if((jet->Pt()>30.)&&(jet->Pt()<40.))
3882 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,3);
3883 if((jet->Pt()>40.)&&(jet->Pt()<50.))
3884 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,3);
3885 if((jet->Pt()>50.)&&(jet->Pt()<60.))
3886 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,3);
3887 if((jet->Pt()>60.)&&(jet->Pt()<70.))
3888 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,3);
3889 if((jet->Pt()>70.)&&(jet->Pt()<80.))
3890 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,3);
3891 if((jet->Pt()>80.)&&(jet->Pt()<90.))
3892 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,3);
3893 } // end of 10-20
3894 if(fEventCent>=20&&fEventCent<30.)
3895 {
3896 if((jet->Pt()>10.)&&(jet->Pt()<20.))
3897 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,4);
3898 if((jet->Pt()>20.)&&(jet->Pt()<30.))
3899 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,4);
3900 if((jet->Pt()>30.)&&(jet->Pt()<40.))
3901 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,4);
3902 if((jet->Pt()>40.)&&(jet->Pt()<50.))
3903 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,4);
3904 if((jet->Pt()>50.)&&(jet->Pt()<60.))
3905 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,4);
3906 if((jet->Pt()>60.)&&(jet->Pt()<70.))
3907 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,4);
3908 if((jet->Pt()>70.)&&(jet->Pt()<80.))
3909 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,4);
3910 if((jet->Pt()>80.)&&(jet->Pt()<90.))
3911 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,4);
3912 } // end of 20-30
3913 if(fEventCent>=30&&fEventCent<40.)
3914 {
3915 if((jet->Pt()>10.)&&(jet->Pt()<20.))
3916 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,5);
3917 if((jet->Pt()>20.)&&(jet->Pt()<30.))
3918 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,5);
3919 if((jet->Pt()>30.)&&(jet->Pt()<40.))
3920 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,5);
3921 if((jet->Pt()>40.)&&(jet->Pt()<50.))
3922 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,5);
3923 if((jet->Pt()>50.)&&(jet->Pt()<60.))
3924 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,5);
3925 if((jet->Pt()>60.)&&(jet->Pt()<70.))
3926 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,5);
3927 if((jet->Pt()>70.)&&(jet->Pt()<80.))
3928 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,5);
3929 if((jet->Pt()>80.)&&(jet->Pt()<90.))
3930 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,5);
3931 } // end of 30-40
3932 if(fEventCent>=40&&fEventCent<50.)
3933 {
3934 if((jet->Pt()>10.)&&(jet->Pt()<20.))
3935 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,6);
3936 if((jet->Pt()>20.)&&(jet->Pt()<30.))
3937 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,6);
3938 if((jet->Pt()>30.)&&(jet->Pt()<40.))
3939 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,6);
3940 if((jet->Pt()>40.)&&(jet->Pt()<50.))
3941 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,6);
3942 if((jet->Pt()>50.)&&(jet->Pt()<60.))
3943 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,6);
3944 if((jet->Pt()>60.)&&(jet->Pt()<70.))
3945 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,6);
3946 if((jet->Pt()>70.)&&(jet->Pt()<80.))
3947 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,6);
3948 if((jet->Pt()>80.)&&(jet->Pt()<90.))
3949 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,6);
3950 } // end of 40-50
3951 if(fEventCent>=50&&fEventCent<60.)
3952 {
3953 if((jet->Pt()>10.)&&(jet->Pt()<20.))
3954 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,7);
3955 if((jet->Pt()>20.)&&(jet->Pt()<30.))
3956 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,7);
3957 if((jet->Pt()>30.)&&(jet->Pt()<40.))
3958 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,7);
3959 if((jet->Pt()>40.)&&(jet->Pt()<50.))
3960 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,7);
3961 if((jet->Pt()>50.)&&(jet->Pt()<60.))
3962 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,7);
3963 if((jet->Pt()>60.)&&(jet->Pt()<70.))
3964 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,7);
3965 if((jet->Pt()>70.)&&(jet->Pt()<80.))
3966 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,7);
3967 if((jet->Pt()>80.)&&(jet->Pt()<90.))
3968 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,7);
3969 } // end of 50-60
3970 if(fEventCent>=60&&fEventCent<70.)
3971 {
3972 if((jet->Pt()>10.)&&(jet->Pt()<20.))
3973 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,8);
3974 if((jet->Pt()>20.)&&(jet->Pt()<30.))
3975 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,8);
3976 if((jet->Pt()>30.)&&(jet->Pt()<40.))
3977 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,8);
3978 if((jet->Pt()>40.)&&(jet->Pt()<50.))
3979 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,8);
3980 if((jet->Pt()>50.)&&(jet->Pt()<60.))
3981 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,8);
3982 if((jet->Pt()>60.)&&(jet->Pt()<70.))
3983 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,8);
3984 if((jet->Pt()>70.)&&(jet->Pt()<80.))
3985 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,8);
3986 if((jet->Pt()>80.)&&(jet->Pt()<90.))
3987 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,8);
3988 } // end of 60-70
3989 if(fEventCent>=70&&fEventCent<80.)
3990 {
3991 if((jet->Pt()>10.)&&(jet->Pt()<20.))
3992 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,9);
3993 if((jet->Pt()>20.)&&(jet->Pt()<30.))
3994 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,9);
3995 if((jet->Pt()>30.)&&(jet->Pt()<40.))
3996 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,9);
3997 if((jet->Pt()>40.)&&(jet->Pt()<50.))
3998 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,9);
3999 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4000 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,9);
4001 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4002 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,9);
4003 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4004 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,9);
4005 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4006 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,9);
4007 } // end of 70-80
4008 if(fEventCent>=80&&fEventCent<100.)
4009 {
4010 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4011 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,10);
4012 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4013 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,10);
4014 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4015 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,10);
4016 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4017 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,10);
4018 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4019 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,10);
4020 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4021 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,10);
4022 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4023 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,10);
4024 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4025 fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,10);
4026 } // end of 80-100
4027 } //end of PbPb event
4028 ////////end centrality dependent pT spec/////
4029 } // end if inside jet
4030 } // end for tracks
4031 } // end of no track ref
4032
4033 if(rfTrkFlag) // if track ref, use them
4034 {
4035 AliDebug(4,Form("Using Track Refs (reco)!"));
4036 for(Int_t ixt=0; ixt<trkinjet;ixt++)
4037 {
4038 AliVParticle *vtrack = dynamic_cast<AliVParticle*>(jet->GetRefTracks()->At(ixt));
4039 if(!vtrack) continue;
4040 // No further checks, all cuts should be in in the track refs
4041 if(vtrack->Charge()!=0&&vtrack->Charge()!=-99)
4042 {
4043 currentNumber++;
4044 fCurrentJetCharge=fCurrentJetCharge+vtrack->Charge();
4045 fgContainer[currentNumber-1] = vtrack->Pt(); // save the current pt in the container
4046
4047 ////////start centrality dependent pT spec ////////
4048 if(!fIsHIevent) //if is a proton proton event
4049 {
4050 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4051 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,1);
4052 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4053 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,1);
4054 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4055 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,1);
4056 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4057 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,1);
4058 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4059 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,1);
4060 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4061 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,1);
4062 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4063 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,1);
4064 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4065 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,1);
4066 } // end of pp event
4067 if(fIsHIevent) //if is a PbPb event
4068 {
4069 if(fEventCent>=0&&fEventCent<10.)
4070 {
4071 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4072 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,2);
4073 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4074 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,2);
4075 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4076 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,2);
4077 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4078 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,2);
4079 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4080 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,2);
4081 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4082 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,2);
4083 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4084 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,2);
4085 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4086 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,2);
4087 } // end of 0-10
4088 if(fEventCent>=10&&fEventCent<20.)
4089 {
4090 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4091 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,3);
4092 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4093 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,3);
4094 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4095 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,3);
4096 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4097 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,3);
4098 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4099 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,3);
4100 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4101 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,3);
4102 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4103 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,3);
4104 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4105 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,3);
4106 } // end of 10-20
4107 if(fEventCent>=20&&fEventCent<30.)
4108 {
4109 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4110 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,4);
4111 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4112 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,4);
4113 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4114 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,4);
4115 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4116 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,4);
4117 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4118 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,4);
4119 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4120 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,4);
4121 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4122 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,4);
4123 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4124 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,4);
4125 } // end of 20-30
4126 if(fEventCent>=30&&fEventCent<40.)
4127 {
4128 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4129 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,5);
4130 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4131 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,5);
4132 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4133 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,5);
4134 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4135 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,5);
4136 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4137 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,5);
4138 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4139 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,5);
4140 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4141 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,5);
4142 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4143 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,5);
4144 } // end of 30-40
4145 if(fEventCent>=40&&fEventCent<50.)
4146 {
4147 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4148 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,6);
4149 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4150 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,6);
4151 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4152 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,6);
4153 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4154 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,6);
4155 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4156 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,6);
4157 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4158 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,6);
4159 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4160 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,6);
4161 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4162 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,6);
4163 } // end of 40-50
4164 if(fEventCent>=50&&fEventCent<60.)
4165 {
4166 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4167 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,7);
4168 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4169 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,7);
4170 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4171 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,7);
4172 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4173 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,7);
4174 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4175 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,7);
4176 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4177 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,7);
4178 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4179 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,7);
4180 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4181 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,7);
4182 } // end of 50-60
4183 if(fEventCent>=60&&fEventCent<70.)
4184 {
4185 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4186 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,8);
4187 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4188 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,8);
4189 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4190 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,8);
4191 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4192 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,8);
4193 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4194 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,8);
4195 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4196 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,8);
4197 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4198 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,8);
4199 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4200 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,8);
4201 } // end of 60-70
4202 if(fEventCent>=70&&fEventCent<80.)
4203 {
4204 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4205 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,9);
4206 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4207 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,9);
4208 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4209 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,9);
4210 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4211 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,9);
4212 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4213 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,9);
4214 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4215 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,9);
4216 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4217 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,9);
4218 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4219 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,9);
4220 } // end of 70-80
4221 if(fEventCent>=80&&fEventCent<100.)
4222 {
4223 if((jet->Pt()>10.)&&(jet->Pt()<20.))
4224 fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,10);
4225 if((jet->Pt()>20.)&&(jet->Pt()<30.))
4226 fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,10);
4227 if((jet->Pt()>30.)&&(jet->Pt()<40.))
4228 fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,10);
4229 if((jet->Pt()>40.)&&(jet->Pt()<50.))
4230 fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,10);
4231 if((jet->Pt()>50.)&&(jet->Pt()<60.))
4232 fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,10);
4233 if((jet->Pt()>60.)&&(jet->Pt()<70.))
4234 fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,10);
4235 if((jet->Pt()>70.)&&(jet->Pt()<80.))
4236 fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,10);
4237 if((jet->Pt()>80.)&&(jet->Pt()<90.))
4238 fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,10);
4239 } // end of 80-100
4240 } //end of PbPb event
4241 ////////end centrality dependent pT spec/////
4242 }
4243 } // end trk in jet
4244 } // end if trk ref
4245
4246
4247 // sort the contents of the container
4248 SortArray(fgContainer,arraysize);
4249 // loop over the contents and count how many tracks are necessary to recover the percetage of the energy
4250 numberOfChargedTracks = TracksForPercentage(fgContainer, arraysize, percentage, jetpT);
4251 return numberOfChargedTracks;
4252}
4253//________________________________________________________________________
4254void AliAnalysisTaskPartonDisc::AllocateStaticContainer(Int_t size)
4255{
4256 //
4257 // Allocate the static container with the given dimensions
4258 //
4259
4260 if(fgContainer)
4261 return;
4262 fgContainer = new Double_t[size];
4263
4264}
4265//________________________________________________________________________
4266void AliAnalysisTaskPartonDisc::InitializeStaticContainer(Int_t size)
4267{
4268 //
4269 // Initialize the static container with the given dimensions
4270 //
4271
4272 memset(fgContainer,0,size*sizeof(Double_t));
4273
4274}
4275//________________________________________________________________________
4276void AliAnalysisTaskPartonDisc::SortArray(Double_t *pointer, Int_t arraySize)
4277{
4278 //
4279 // Sort the contents of the array
4280 // From lower to higher value
4281 //
4282
4283 std::sort(pointer,pointer+arraySize);
4284
4285}
4286//________________________________________________________________________
4287Int_t AliAnalysisTaskPartonDisc::TracksForPercentage(Double_t *array, Int_t arraysize, Int_t percentage, Double_t jetenergy)
4288{
4289 //
4290 // Loop over the contents and count how many tracks are necessary to recover
4291 // the given percentage of the energy.
4292 // If all tracks did not sum the required fraction, it returns 500
4293 //
4294
4295 AliDebug(4,Form("Calculating the number of tracks for a jet with energy:%f \n",jetenergy));
4296 Double_t ptsum = 0;
4297 Double_t threshold = jetenergy*percentage/100;
4298 Int_t tracknummer=0;
4299 fCurrentJetMinPtNT90 = 7000.; //dummy value for debugging
4300 for(Int_t inverse=arraysize; inverse>0; inverse--)
4301 {
4302 ptsum= ptsum + array[inverse-1];
4303 if(inverse==arraysize) //if the highest value
4304 fMaxTrackPtInNTX=array[inverse-1]; //saving the highest pT track value
4305 tracknummer++;
4306 fMinTrackPtInNTX=array[inverse-1]; // this is the current lowest pT track used
4307 if(fIsPossibleToSubstBckg) //Store the value if it was possible to find a perpendicular cone
4308 fCurrentJetMinPtNT90=array[inverse-1];
4309 if(ptsum>=threshold) // the threshold was reached
4310 break;
4311 if((inverse==1)&&(ptsum<threshold)) //if it was not possible to reach the threshold
4312 {
4313 tracknummer = 500; //dummy value for debugging
4314 fCurrentJetMinPtNT90 = 7000.; //dummy value for debugging
4315 }
4316 }
4317
4318 AliDebug(4,"Done calculating the number of tracks, returning to main code \n");
4319 return tracknummer;
4320
4321}
4322//________________________________________________________________________
4323Bool_t AliAnalysisTaskPartonDisc::IsMCTrackInsideThisJet(AliAODMCParticle *MCParticle, AliAODJet *Jet, Double_t jr)
4324{
4325 //
4326 // Return kTrue if the mc track is inside the area covered by the cone of the jet
4327 //
4328
4329 Double_t etapart = MCParticle->Eta();
4330 Double_t phipart = MCParticle->Phi();
4331 Double_t etajet = Jet->Eta();
4332 Double_t phijet = Jet->Phi();
4333 Double_t deltaeta = etajet-etapart;
4334 Double_t deltaphi = TMath::Abs(phijet-phipart);
4335 if (deltaphi > TMath::Pi())
4336 deltaphi = 2.0 * TMath::Pi() - deltaphi;
4337
4338 Double_t deltar = sqrt(deltaeta*deltaeta+deltaphi*deltaphi);
4339 if(deltar<=jr)
4340 return kTRUE;
4341 else
4342 return kFALSE;
4343
4344}
4345//________________________________________________________________________
4346Bool_t AliAnalysisTaskPartonDisc::IsTrackInsideThisJet(AliAODTrack *aodT, AliAODJet *Jet, Double_t jr)
4347{
4348 //
4349 // Return kTrue if the track is inside the area covered by the cone of the jet
4350 //
4351
4352 Double_t etapart = aodT->Eta();
4353 Double_t phipart = aodT->Phi();
4354 Double_t etajet = Jet->Eta();
4355 Double_t phijet = Jet->Phi();
4356 Double_t deltaeta = etajet-etapart;
4357 Double_t deltaphi = TMath::Abs(phijet-phipart);
4358 if (deltaphi > TMath::Pi())
4359 deltaphi = 2.0 * TMath::Pi() - deltaphi;
4360
4361 Double_t deltar = sqrt(deltaeta*deltaeta+deltaphi*deltaphi);
4362 if(deltar<=jr)
4363 return kTRUE;
4364 else
4365 return kFALSE;
4366
4367}
4368//________________________________________________________________________
4369Bool_t AliAnalysisTaskPartonDisc::VertexInJet(AliAODVertex *pvtx, AliAODVertex *vtx, AliAODJet *jet, Double_t jr)
4370{
4371 //
4372 // Return kTRUE if the cone covers the vector
4373 // from the primary vertex to this vertex
4374 //
4375
4376 Double_t pvx = pvtx->GetX(); //primary vertex x
4377 Double_t pvy = pvtx->GetY(); //primary vertex y
4378 Double_t pvz = pvtx->GetZ(); //primary vertex z
4379
4380 Double_t vx = vtx->GetX(); // vertex x
4381 Double_t vy = vtx->GetY(); // vertex y
4382 Double_t vz = vtx->GetZ(); // vertex z
4383
4384 if(IsEqualRel(pvx, vx) && IsEqualRel(pvy, vy) && IsEqualRel(pvz, vz)) //!IsEqualRel(totalTrackPt, 0.0) // pvx==vx && pvy==vy && pvz==vz
4385 return kFALSE;
4386
4387 Double_t thetaval = GetThetaAngle(vx-pvx,vy-pvy,vz-pvz);
4388 Double_t etaval = GetEtaValue(thetaval);
4389 Double_t phival = GetPhiAngle(vx-pvx,vy-pvy);
4390
4391 Double_t etajet = jet->Eta();
4392 Double_t phijet = jet->Phi();
4393
4394 if(GetDeltaR(etajet,phijet,etaval,phival)<=jr)
4395 return kTRUE;
4396
4397 return kFALSE;
4398}
4399//________________________________________________________________________
4400Double_t AliAnalysisTaskPartonDisc::GetEtaValue(Double_t theta) const
4401{
4402 //
4403 // Get the eta value
4404 //
4405
4406 Double_t eta = -TMath::Log(theta/2);
4407 return eta;
4408
4409}
4410//________________________________________________________________________
4411Double_t AliAnalysisTaskPartonDisc::GetThetaAngle(Double_t xval, Double_t yval, Double_t zval)
4412{
4413 //
4414 // Get the theta angle related to these coordinates
4415 //
4416
4417 if(IsEqualRel(zval, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // zval==0
4418 return TMath::PiOver2();
4419
4420 Double_t theta = 0;
4421 Double_t erre = TMath::Sqrt(xval*xval+yval*yval+zval*zval);
4422
4423 if(zval>0)
4424 theta = TMath::ACos(zval/erre);
4425
4426 if(zval<0)
4427 theta = TMath::Pi() - TMath::ACos(TMath::Abs(zval)/erre);
4428
4429 if(IsEqualRel(theta, 0.0)) // theta==0
4430 AliError("ERROR in GetThetaAngle!");
4431
4432 return theta;
4433
4434}
4435//________________________________________________________________________
4436Double_t AliAnalysisTaskPartonDisc::GetPhiAngle(Double_t xval, Double_t yval)
4437{
4438 //
4439 // Get the phi angle related to these coordinates
4440 //
4441
4442 if(IsEqualRel(xval, 0.0)) //IsEqualRel(zval, 0.0) // xval==0
4443 {
4444 if(yval>0)
4445 return TMath::PiOver2();
4446 if(yval<0)
4447 return (3/2*TMath::Pi());
4448 }
4449 Double_t phi = 0;
4450
4451 if(xval>0)
4452 {
4453 if(yval>0)
4454 phi = TMath::ATan(yval/xval);
4455 if(yval<0)
4456 phi = 2*TMath::Pi()- TMath::ATan(TMath::Abs(yval)/xval);
4457 }
4458 if(xval<0)
4459 {
4460 if(yval>0)
4461 phi = TMath::Pi() - TMath::ATan(yval/TMath::Abs(xval));
4462 if(yval<0)
4463 phi = TMath::Pi() + TMath::ATan(TMath::Abs(yval/xval));
4464 }
4465
4466 return phi;
4467}
4468//________________________________________________________________________
4469Double_t AliAnalysisTaskPartonDisc::DeltaPhiMC(AliAODJet *jet, AliAODMCParticle *particle)
4470{
4471 //
4472 // Get delta-phi MC jet-track
4473 //
4474
4475 Double_t deltaphi = jet->Phi()-particle->Phi();
4476 if (deltaphi > TMath::Pi())
4477 deltaphi = 2.0 * TMath::Pi() - deltaphi;
4478 if (deltaphi < -TMath::Pi())
4479 deltaphi = -deltaphi- 2.0 * TMath::Pi();
4480
4481 return deltaphi;
4482
4483}
4484//________________________________________________________________________
4485Double_t AliAnalysisTaskPartonDisc::DeltaEtaMC(AliAODJet *jet, AliAODMCParticle *particle)
4486{
4487 //
4488 // Get delta-eta MC jet-track
4489 //
4490
4491 Double_t deltaetaMC = jet->Eta() - particle->Eta();
4492 return deltaetaMC;
4493}
4494//________________________________________________________________________
4495Double_t AliAnalysisTaskPartonDisc::DeltaPhiSqMC(AliAODJet *jet, AliAODMCParticle *particle)
4496{
4497 //
4498 // Get delta-phi^2 MC jet-track
4499 //
4500
4501 Double_t deltaphi = DeltaPhiMC(jet,particle);
4502 Double_t deltaphiSqMC = deltaphi*deltaphi;
4503 return deltaphiSqMC;
4504}
4505//________________________________________________________________________
4506Double_t AliAnalysisTaskPartonDisc::DeltaEtaSqMC(AliAODJet *jet, AliAODMCParticle *particle)
4507{
4508 //
4509 // Get delta-eta^2 MC jet-track
4510 //
4511
4512 Double_t deltaeta = DeltaEtaMC(jet,particle);
4513 Double_t deltaetaSqMC = deltaeta*deltaeta;
4514 return deltaetaSqMC;
4515}
4516//________________________________________________________________________
4517Double_t AliAnalysisTaskPartonDisc::DeltaPhiTrack(AliAODJet *jet, AliAODTrack *track)
4518{
4519 //
4520 // Get delta-phi Track jet-track
4521 //
4522
4523 // Double_t deltaphiTrack = jet->Phi() - track->Phi();
4524 // return deltaphiTrack;
4525
4526 Double_t deltaphi = jet->Phi() - track->Phi();
4527 if (deltaphi > TMath::Pi())
4528 deltaphi = 2.0 * TMath::Pi() - deltaphi;
4529 if (deltaphi < -TMath::Pi())
4530 deltaphi = -deltaphi- 2.0 * TMath::Pi();
4531
4532 return deltaphi;
4533
4534
4535}
4536//________________________________________________________________________
4537Double_t AliAnalysisTaskPartonDisc::DeltaEtaTrack(AliAODJet *jet, AliAODTrack *track)
4538{
4539 //
4540 // Get delta-eta Track jet-track
4541 //
4542
4543 Double_t deltaetaTrack = jet->Eta() - track->Eta();
4544 return deltaetaTrack;
4545}
4546//________________________________________________________________________
4547Double_t AliAnalysisTaskPartonDisc::DeltaPhiSqTrack(AliAODJet *jet, AliAODTrack *track)
4548{
4549 //
4550 // Get delta-phi^2 Track jet-track
4551 //
4552
4553 Double_t deltaphi = DeltaPhiTrack(jet,track);
4554 Double_t deltaphiSqTrack = deltaphi*deltaphi;
4555 return deltaphiSqTrack;
4556}
4557//________________________________________________________________________
4558Double_t AliAnalysisTaskPartonDisc::DeltaEtaSqTrack(AliAODJet *jet, AliAODTrack *track)
4559{
4560 //
4561 // Get delta-eta^2 Track jet-track
4562 //
4563
4564 Double_t deltaeta = DeltaEtaTrack(jet,track);
4565 Double_t deltaetaSqTrack = deltaeta*deltaeta;
4566 return deltaetaSqTrack;
4567}
4568//_________________________________________________________________________
4569Bool_t AliAnalysisTaskPartonDisc::NumberOfReadEventsAOD(const char* currFile, Int_t &fNEvents)
4570{
4571 //
4572 // get the number of events read out to create this AOD
4573 // from the njets distribution from UA1
4574 // This is to called in Notify and should provide the path to the AOD/ESD file
4575 // code from AliAnalysisTaskJetSpectrum2
4576
4577 TString file(currFile);
4578 fNEvents = 1;
4579
4580 if(file.Contains("root_archive.zip#"))
4581 {
4582 Ssiz_t pos1 = file.Index("root_archive",12,TString::kExact);
4583 Ssiz_t pos = file.Index("#",1,pos1,TString::kExact);
4584 file.Replace(pos+1,20,"");
4585 }
4586 else
4587 {
4588 // not an archive take the basename....
4589 file.ReplaceAll(gSystem->BaseName(file.Data()),"");
4590 }
4591 Printf("%s",file.Data());
4592
4593 TFile *fnev = TFile::Open(Form("%s%s",file.Data(),"PWG4_JetTasksOutput.root"));
4594 if(!fnev)
4595 {
4596 return kFALSE;
4597 } // no PWG4_JetTasksOutput.root
4598 else
4599 {
4600 TList *list;
4601 gDirectory->GetObject("PWG4_jethist_aodmc_ua104/jethist_aodmc_ua104;1",list);
4602 if(!list)
4603 {
4604 fnev->Close();
4605 return kFALSE;
4606 }
1fd2a48e 4607 fNEvents = Int_t(((TH1*)list->FindObject("NJetsH"))->GetEntries());
0c9acc4c 4608 fnev->Close();
4609 }
4610 return kTRUE;
4611}
4612//___________________________________________________________________________
4613void AliAnalysisTaskPartonDisc::HasOverlapedCones(TClonesArray *JetArray)
4614{
4615 //
4616 // Check if there are jet cones that overlap on the current event
4617 // for UA1 and SISCone, based on the cone axis and the radius.
4618 // There can be maximum 7.85 jet in the phi acceptance, with no overlap in
4619 // the phi direction (2pi/0.8).
4620 // Plus there can be up to two jets in contained in the eta acceptance,
4621 // if they are centered in -0.5 and 0.5 respectively, per phi interval
4622 // In total there can be up to 15.7 jets
4623 // Check up to 16 jets, inside the acceptance,
4624 // set the flags for up to those 8 jets.
4625 //
4626
4627 // Now also check if there is a perpendicular area to the leading jet
4628 // that does not contain a jet, if so, set a flag to kTRUE
4629 // Possibility to remove single track jets if there are track references
4630
4631 fJetEvent=kFALSE;
4632 fHasPerpCone=kTRUE;
4633 fEtaPerpCoord=0.0;
4634 fPhiPerpCoord=0.0;
4635 fPtPerpCoord=0.0;
4636
4637 ResetJetFlags(); // reset the flags
4638
4639 Int_t njets = JetArray->GetEntries();
4640 Int_t maxNjets = 16;
4641 Double_t etaCoordinates[16]={0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
4642 Double_t phiCoordinates[16]={0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
4643
4644 for (Int_t idxj = 0; idxj < njets; idxj++)
4645 {
4646 if(idxj>15)
4647 continue; //maximum 16 jets
4648
4649 AliAODJet *currentJet = dynamic_cast<AliAODJet*>(JetArray->At(idxj));
4650 if (!currentJet)
4651 {
4652 AliDebug(2,Form("ERROR: Could not receive jet %d \n", idxj));
4653 continue;
4654 }
4655 // Store the axis coordinates of all sixteen jets
4656 etaCoordinates[idxj]=currentJet->Eta();
4657 phiCoordinates[idxj]=currentJet->Phi();
4658 } //end of first cycle
4659
4660 // Ahora checar que no tengan overlap
4661 Double_t deltaeta = 0.0;
4662 Double_t deltaphi = 0.0;
4663 Double_t deltar = 0.0;
4664 Int_t currentIdxJet = 0;
4665 Int_t trkinjet = 0;
4666
4667 for (Int_t inxoj = 0; inxoj < maxNjets; inxoj++)
4668 {
4669 // only check up to the number of found jets in the event
4670 if(inxoj==njets)
4671 break;
4672
4673 // Optional RefTracks check for single track jets
4674 if(fForceSkipSJ)
4675 {
4676 AliAODJet *currentJet = dynamic_cast<AliAODJet*>(JetArray->At(inxoj));
4677 if (!currentJet)
4678 {
4679 AliDebug(2,Form("ERROR: Could not receive jet %d \n", inxoj));
4680 continue;
4681 }
4682 trkinjet = currentJet->GetRefTracks()->GetEntriesFast();
4683 if(trkinjet==1) // si tiene 1 solo track se marca como malo
4684 {
4685 fJetFlags[inxoj]=kFALSE;
4686 continue;
4687 }
4688 } // end of skip of single track jets condition
4689
4690 // First check if the current jet has its axis inside acceptance
8dcbcbbb 4691 if(!(TMath::Abs(etaCoordinates[inxoj])<=fJetAcceptance)) //
0c9acc4c 4692 {
4693 fJetFlags[inxoj]=kFALSE;
4694 continue;
4695 }
4696 currentIdxJet = inxoj;
4697 //Check this jet with the rest of the jets
4698 for (Int_t idx2 = 0; idx2 < maxNjets; idx2++)
4699 {
4700 if(idx2==njets) // just check the number of found jets
4701 break;
4702
4703 if(currentIdxJet==idx2) // if the same jet
4704 continue;
4705 if(!fJetFlags[idx2]) // if the other jet is already not usable
4706 continue;
8dcbcbbb 4707 if(!(TMath::Abs(etaCoordinates[idx2])<=fJetAcceptance)) // if the jet is outside acceptance
0c9acc4c 4708 continue;
4709 deltaeta = etaCoordinates[currentIdxJet]-etaCoordinates[idx2];
4710 deltaphi = phiCoordinates[currentIdxJet]-phiCoordinates[idx2];
4711 if (deltaphi > TMath::Pi())
4712 deltaphi = 2.0 * TMath::Pi() - deltaphi;
4713 deltar = sqrt(deltaeta*deltaeta+deltaphi*deltaphi);
4714 if(deltar<=2.0*fJetRadius) // if the distance between jet axis is less than 2r with any jet, mark as not usable
4715 {
4716 fJetFlags[currentIdxJet]=kFALSE;
4717 fJetFlags[idx2]=kFALSE; // both jets are not usable
4718 // if(fEnablePrints)
4719 // {
4720 // printf("Rejecting jet #:%i because it had overlap with jet #:%i \n",currentIdxJet, idx2);
4721 // printf("Eta1:%f, Phi1:%f \n", etaCoordinates[currentIdxJet],phiCoordinates[currentIdxJet]);
4722 // printf("Eta2:%f, Phi2:%f \n", etaCoordinates[idx2],phiCoordinates[idx2]);
4723 // printf("Current event number:%i \n",fEvtCount-1);
4724 // }
4725 } // end of actual flagging
4726 } // end of checking the current jet with the rest
4727 } // end of loop over the jets of the branch
4728
4729 // Check if there is at least one accepted jet, so it makes sense to calculate the perpendicular cone
4730 Int_t accJets = 0;
4731 for (Int_t checkjets = 0; checkjets < maxNjets; checkjets++)
4732 {
4733 // only check up to the number of found jets in the event
4734 if(checkjets==njets)
4735 break;
4736 if(fJetFlags[checkjets]) // find the accepted leading jet in acceptance
4737 accJets++;
4738 }
4739 if(accJets>0)
4740 fJetEvent=kTRUE;
4741
4742 // Check for the leading jet on the event
4743 for (Int_t searchlead = 0; searchlead < maxNjets; searchlead++)
4744 {
4745 // only check up to the number of found jets in the event
4746 if(searchlead==njets)
4747 break;
4748 if(fJetFlags[searchlead]) // find the accepted leading jet in acceptance
4749 {
4750 // Phi + pi/2
4751 fPhiPerpCoord = phiCoordinates[searchlead] + 0.5*TMath::Pi();
4752 if(fPhiPerpCoord>2.0*TMath::Pi())
4753 fPhiPerpCoord = fPhiPerpCoord - 2.0*TMath::Pi();
4754 // Same eta
4755 fEtaPerpCoord = etaCoordinates[searchlead];
4756 // Now check if this cone overlaps with any found jet
4757 for (Int_t jets = 0; jets < maxNjets; jets++)
4758 {
4759 // only check up to the number of found jets in the event
4760 if(jets==njets)
4761 break;
4762 // now check that this jet is not the same as the leading
4763 if(jets==searchlead)
4764 continue;
4765
4766 deltaphi = phiCoordinates[jets]-fPhiPerpCoord;
4767 if (deltaphi > TMath::Pi())
4768 deltaphi = 2.0 * TMath::Pi() - deltaphi;
4769 if(deltaphi<=2.0*fJetRadius) // if the distance between cone axis is less than 2r with any jet, mark as not usable
4770 {
4771 fHasPerpCone=kFALSE;
4772 }
4773 // }
4774 } // loop over accepted jets
4775 break; // done doing stuff with the leading
4776 } // if for the first accepted jet (leading)
4777 }
4778}
4779//_______________________________________________________________________
4780void AliAnalysisTaskPartonDisc::ResetJetFlags()
4781{
4782 //
4783 // Reset the flags used for tagging jets from the branches
4784 // Use before calling HasOverlapedCones(jetbranch)
4785 //
4786
4787 for(Int_t a=0; a<16;a++)
4788 {
4789 fJetFlags[a]=kTRUE;
4790 }
4791
4792}
4793//________________________________________________________________________
4794Int_t AliAnalysisTaskPartonDisc::GetNMcChargedTracksAboveThreshold(AliAODJet *jet, Int_t ntracks, TClonesArray *mcarray, Double_t jr)
4795{
4796 // Calculate the number of charged particles above threshold
4797 // inside this jet for the MC case
4798 // the threshold is fCurrentJetMinPtNT90
4799
4800 Int_t numberOfChargedTracks = 0;
4801 Int_t currentNumber = 0;
4802 Double_t jeteta = jet->Eta();
4803 Double_t jetphi = jet->Phi();
4804 Double_t jetpT = jet->Pt();
4805 Double_t tracketa = 0;
4806 Double_t trackphi = 0;
4807
4808 if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(zval, 0.0) //jetpT==0
4809 return 0;
4810
4811 if(IsEqualRel(fCurrentJetMinPtNT90, 7000.)) // fCurrentJetMinPtNT90==7000.
4812 return 1000; //dummy val for debugging
4813
17f4943e 4814 Double_t randomNum = 0.;
4815
0c9acc4c 4816 for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
4817 {
4818 AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
4819 if(!mctrack) continue;
4820 tracketa = mctrack->Eta();
4821 trackphi = mctrack->Phi();
4822 if(mctrack->Pt()<fCurrentJetMinPtNT90) continue;
4823 if(mctrack->IsPhysicalPrimary())
4824 {
4825 if(mctrack->Charge()!=0&&mctrack->Charge()!=-99)
4826 {
4827 if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
17f4943e 4828 {
4829 randomNum = gRandom->Rndm();
4830 if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
0c9acc4c 4831 currentNumber++;
4832 } // end if inside jet
4833 } // end charged
4834 } // end physical primary
4835 } // end for tracks
4836
4837 numberOfChargedTracks = currentNumber;
4838 AliDebug(4,Form("Number of tracks above threshold MC was:%i, returning",numberOfChargedTracks));
4839 return numberOfChargedTracks;
4840
4841}
4842//________________________________________________________________________
4843 Int_t AliAnalysisTaskPartonDisc::GetRecalcNTXMc(Int_t percentage, AliAODJet *originaljet, Int_t ntracks, TClonesArray *mcarray, Double_t jr)
4844{
4845 //
4846 // Calculate the number of charged particles necessary to
4847 // add the given percentage of the jet energy (transverse energy)
4848 // after background substraction, for the MC case
4849
4850 Int_t numberOfChargedTracks = 0;
4851 Int_t currentNumber = 0;
4852 Double_t jetpT = fBckgSbsJet[0]; //pT
4853 Double_t jeteta = fBckgSbsJet[1]; //eta
4854 Double_t jetphi = fBckgSbsJet[2]; //phi
4855 Double_t tracketa = 0;
4856 Double_t trackphi = 0;
4857 Int_t arraysize = 1000;
4858 Bool_t rfTrkFlag = kFALSE;
4859
4860 if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) //jetpT==0
4861 return 0;
4862
4863 // RefTracks
4864 Int_t trkinjet = originaljet->GetRefTracks()->GetEntriesFast();
4865 if(trkinjet!=0)
4866 rfTrkFlag = kTRUE;
4867 AliDebug(4,Form("Number of tracks in this mc jet by RefTracks:%i \n",trkinjet));
4868
4869 AllocateStaticContainer(arraysize);
4870 InitializeStaticContainer(arraysize);
4871
17f4943e 4872 Double_t randomNum = 0.;
4873
0c9acc4c 4874 if(!rfTrkFlag) // if not track ref, check track by track
4875 {
4876 AliDebug(4,Form("Empty Track Refs (mc)!"));
4877 for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
4878 {
4879 AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
4880 if(!mctrack) continue;
4881 tracketa = mctrack->Eta();
4882 trackphi = mctrack->Phi();
4883 if(mctrack->Pt()<fMinpTVal) continue; // pT cut, not using track refs
4884 if(mctrack->IsPhysicalPrimary())
4885 {
4886 if(mctrack->Charge()!=0&&mctrack->Charge()!=-99)
4887 {
4888 if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
17f4943e 4889 {
4890 randomNum = gRandom->Rndm();
4891 if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
0c9acc4c 4892 currentNumber++;
4893 fgContainer[currentNumber-1] = mctrack->Pt(); // save the current pt in the container
4894 } // end if inside jet
4895 } // end charged
4896 } // end physical primary
4897 } // end for tracks
4898 } // end rfTrkFlag
4899
4900 if(rfTrkFlag) // if track ref, use them
4901 {
4902 AliDebug(4,Form("Using Track Refs (mc)!"));
4903 for(Int_t ixt=0; ixt<trkinjet;ixt++)
4904 {
4905 AliAODMCParticle *vtrack = dynamic_cast<AliAODMCParticle*>(originaljet->GetRefTracks()->At(ixt));
4906 if(!vtrack) continue;
4907 if(vtrack->Charge()!=0&&vtrack->Charge()!=-99)
4908 {
17f4943e 4909 randomNum = gRandom->Rndm();
4910 if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
0c9acc4c 4911 currentNumber++;
4912 fgContainer[currentNumber-1] = vtrack->Pt(); // save the current pt in the container
4913 }
4914 } // end trk in jet
4915 } // end if trk ref
4916
4917 // sort the contents of the container
4918 SortArray(fgContainer,arraysize);
4919 // loop over the contents and count how many tracks are necessary to recover the percentage of the energy
4920 numberOfChargedTracks = TracksForPercentageRecalc(fgContainer, arraysize, percentage, jetpT); //este es el que tengo que modificar...
4921 AliDebug(4,Form("Number of tracks was:%i, returning",numberOfChargedTracks));
4922 return numberOfChargedTracks;
4923}
4924//________________________________________________________________________
4925Int_t AliAnalysisTaskPartonDisc::TracksForPercentageRecalc(Double_t *array, Int_t arraysize, Int_t percentage, Double_t jetenergy)
4926{
4927 //
4928 // Loop over the contents and count how many tracks are necessary to recover
4929 // the given percentage of the energy.
4930 // If all tracks did not sum the required fraction, it returns 500
4931 // this saves the minimum pT used, during the nt90 recalculation
4932 // after jet energy correction
4933
4934 AliDebug(4,Form("Re-calculating the number of tracks for a jet with corrected pT:%f \n",jetenergy));
4935 Double_t ptsum = 0;
4936 Double_t threshold = jetenergy*percentage/100;
4937 Int_t tracknummer=0;
4938 fCurrentJetMinPtNT90Recalc=7000.; //dummy value for debugging
4939 for(Int_t inverse=arraysize; inverse>0; inverse--)
4940 {
4941 ptsum= ptsum + array[inverse-1];
4942 if(inverse==arraysize) //if the highest value
4943 fMaxTrackPtInNTXR=array[inverse-1]; //saving the highest pT track value in the recalculation
4944 tracknummer++;
4945 fMinTrackPtInNTXR=array[inverse-1]; // this is the current lowest pT track used in the recalculation
4946 if(fIsPossibleToSubstBckg) //Store the value for the current jet, during recalculation
4947 fCurrentJetMinPtNT90Recalc=array[inverse-1];
4948 if(ptsum>=threshold) // the threshold was reached
4949 break;
4950 if((inverse==1)&&(ptsum<threshold)) //if it was not possible to reach the threshold
4951 {
4952 tracknummer = 500;
4953 fCurrentJetMinPtNT90Recalc=7000.; //dummy values for debugging
4954 }
4955 }
4956
4957 AliDebug(4,"Done re-calculating the number of tracks, returning to main code \n");
4958 return tracknummer;
4959
4960}
4961//________________________________________________________________________
4962Int_t AliAnalysisTaskPartonDisc::GetRecalcNMcChTrUpThr(AliAODJet *jet, Int_t ntracks, TClonesArray *mcarray, Double_t jr)
4963{
4964 // Calculate the number of charged particles above threshold
4965 // inside this jet for the MC case
4966 // the threshold is fCurrentJetMinPtNT90Recalc
4967
4968 Int_t numberOfChargedTracks = 0;
4969 Int_t currentNumber = 0;
4970 Double_t jeteta = jet->Eta();
4971 Double_t jetphi = jet->Phi();
4972 Double_t jetpT = jet->Pt();
4973 Double_t tracketa = 0;
4974 Double_t trackphi = 0;
4975
4976 if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) //jetpT==0
4977 return 0;
4978
17f4943e 4979 Double_t randomNum = 0.;
4980
0c9acc4c 4981 for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
4982 {
4983 AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
4984 if(!mctrack) continue;
4985 tracketa = mctrack->Eta();
4986 trackphi = mctrack->Phi();
4987 if(mctrack->Pt()<fCurrentJetMinPtNT90Recalc) continue;
4988 if(mctrack->IsPhysicalPrimary())
4989 {
4990 if(mctrack->Charge()!=0&&mctrack->Charge()!=-99)
4991 {
4992 if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
17f4943e 4993 {
4994 randomNum = gRandom->Rndm();
4995 if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
0c9acc4c 4996 currentNumber++;
4997 } // end if inside jet
4998 } // end charged
4999 } // end physical primary
5000 } // end for tracks
5001
5002 numberOfChargedTracks = currentNumber;
5003 AliDebug(4,Form("Recalculated number of tracks above threshold MC was:%i, returning",numberOfChargedTracks));
5004 return numberOfChargedTracks;
5005
5006}
5007//________________________________________________________________________
5008Int_t AliAnalysisTaskPartonDisc::GetNRecChargedTracksAboveThreshold(AliAODJet *jet, Int_t ntracks, AliAODEvent *aode, Double_t jr)
5009{
5010 //
5011 // Calculate the number of charged particles
5012 // above the threshold set by the NTX calculation
5013 // for the AOD track case, the threshold is fCurrentJetMinPtNT90
5014 // the fCurrentJetMinPtNT90 was set when calling the NTX method before
5015
5016 Int_t numberOfChargedTracks = 0;
5017 Int_t currentNumber = 0;
5018 Double_t jeteta = jet->Eta();
5019 Double_t jetphi = jet->Phi();
5020 Double_t jetpT = jet->Pt();
5021 Double_t tracketa = 0;
5022 Double_t trackphi = 0;
5023
5024 if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) // jetpT==0
5025 return 0;
5026
5027 for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
5028 {
f15c1f69 5029 AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(aode->GetTrack(iTracks));
5030 if(!aodtrack) AliFatal("Not a standard AOD");
0c9acc4c 5031 if(!aodtrack) continue;
5032 tracketa = aodtrack->Eta();
5033 trackphi = aodtrack->Phi();
5034 if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
5035 {
5036 if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
0c9acc4c 5037 if(aodtrack->Pt()<fCurrentJetMinPtNT90) continue;
5038 currentNumber++;
5039 } // end if inside jet
5040 } // end for tracks
5041
5042 numberOfChargedTracks = currentNumber;
5043 return numberOfChargedTracks;
5044}
5045//________________________________________________________________________
5046Int_t AliAnalysisTaskPartonDisc::GetRecalcNTXRec(Int_t percentage,AliAODJet *originaljet, Int_t ntracks, AliAODEvent *aode, Double_t jr)
5047{
5048 //
5049 // Calculate the number of charged particles necessary to
5050 // add the given percentage of the jet energy (transverse energy)
5051 // after pT recalculation, for the AOD track case
5052
5053 Int_t numberOfChargedTracks = 0;
5054 Int_t currentNumber = 0;
5055 Double_t jetpT = fBckgSbsJet[0]; //pT
5056 Double_t jeteta = fBckgSbsJet[1]; //eta
5057 Double_t jetphi = fBckgSbsJet[2]; //phi
5058 Double_t tracketa = 0;
5059 Double_t trackphi = 0;
5060 Int_t arraysize = 1000;
5061 Bool_t rfTrkFlag = kFALSE;
5062
5063 if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) //jetpT==0
5064 return 0;
5065
5066 // RefTracks
5067 Int_t trkinjet = originaljet->GetRefTracks()->GetEntriesFast();
5068 if(trkinjet!=0&&!fForceNotTR)
5069 rfTrkFlag = kTRUE;
5070 AliDebug(4,Form("Number of tracks in this reco jet by RefTracks:%i \n",trkinjet));
5071
5072 AllocateStaticContainer(arraysize);
5073 InitializeStaticContainer(arraysize);
5074 if(!rfTrkFlag) // if not track ref, check track by track
5075 {
5076 AliDebug(4,Form("Empty Track Refs (reco)!"));
5077 for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
5078 {
f15c1f69 5079 AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(aode->GetTrack(iTracks));
5080 if(!aodtrack) AliFatal("Not a standard AOD");
0c9acc4c 5081 if(!aodtrack) continue;
5082 tracketa = aodtrack->Eta();
5083 trackphi = aodtrack->Phi();
5084 if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
5085 {
5086 if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
0c9acc4c 5087 if(aodtrack->Pt()<fMinpTVal) continue; // pT cut, not using track refs
5088 currentNumber++;
5089 fgContainer[currentNumber-1] = aodtrack->Pt(); // save the current pt in the container
5090 } // end if inside jet
5091 } // end for tracks
5092 } // end of no track ref
5093
5094 if(rfTrkFlag) // if track ref, use them
5095 {
5096 AliDebug(4,Form("Using Track Refs (reco)!"));
5097 for(Int_t ixt=0; ixt<trkinjet;ixt++)
5098 {
5099 AliVParticle *vtrack = dynamic_cast<AliVParticle*>(originaljet->GetRefTracks()->At(ixt));
5100 if(!vtrack) continue;
5101 // No further checks, all cuts should be in in the track refs
5102 if(vtrack->Charge()!=0&&vtrack->Charge()!=-99)
5103 {
5104 currentNumber++;
5105 fgContainer[currentNumber-1] = vtrack->Pt(); // save the current pt in the container
5106 }
5107 } // end trk in jet
5108 } // end if trk ref
5109
5110
5111 // sort the contents of the container
5112 SortArray(fgContainer,arraysize);
5113 // loop over the contents and count how many tracks are necessary to recover the percetage of the energy
5114 numberOfChargedTracks = TracksForPercentageRecalc(fgContainer, arraysize, percentage, jetpT);
5115 return numberOfChargedTracks;
5116}
5117//________________________________________________________________________
5118Int_t AliAnalysisTaskPartonDisc::GetRecalcNRecChTrUpThr(AliAODJet *jet, Int_t ntracks, AliAODEvent *aode, Double_t jr)
5119{
5120 //
5121 // Calculate the number of charged particles
5122 // above the threshold set by the NTX calculation
5123 // for the AOD track case, the threshold is fCurrentJetMinPtNT90Recalc
5124 // the fCurrentJetMinPtNT90Recalc was set when calling the NTX method before
5125
5126 Int_t numberOfChargedTracks = 0;
5127 Int_t currentNumber = 0;
5128 Double_t jeteta = jet->Eta();
5129 Double_t jetphi = jet->Phi();
5130 Double_t jetpT = jet->Pt();
5131 Double_t tracketa = 0;
5132 Double_t trackphi = 0;
5133
5134 if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) // jetpT==0
5135 return 0;
5136
5137 for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
5138 {
f15c1f69 5139 AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(aode->GetTrack(iTracks));
5140 if(!aodtrack) AliFatal("Not a standard AOD");
0c9acc4c 5141 if(!aodtrack) continue;
5142 tracketa = aodtrack->Eta();
5143 trackphi = aodtrack->Phi();
5144 if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
5145 {
5146 if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
0c9acc4c 5147 if(aodtrack->Pt()<fCurrentJetMinPtNT90Recalc) continue;
5148 currentNumber++;
5149 } // end if inside jet
5150 } // end for tracks
5151
5152 numberOfChargedTracks = currentNumber;
5153 return numberOfChargedTracks;
5154}
5155//________________________________________________________________________
5156Bool_t AliAnalysisTaskPartonDisc::IsTrackInsideExcludedArea(Double_t tracketa, Double_t trackphi, TClonesArray *recojetsA)
5157{
5158 //
5159 // Check if these track coordinates are in an excluded area
5160 //
5161
5162 //Primero: checar si esta dentro de cualquier jet, no importa si esta dentro de la
5163 //aceptancia o no(en base al eje), aun podria haber tracks del jet dentro del
5164 //evento.
5165 Int_t numbRecJ = recojetsA->GetEntries();
5166 Double_t etaCurrJet = 0.0;
5167 Double_t phiCurrJet = 0.0;
5168 Double_t deltaeta = 0.0;
5169 Double_t deltaphi = 0.0;
5170 Double_t deltar = 0.0;
8dcbcbbb 5171 Double_t extendedRadius = fJetRadius+fIncExcR;
0c9acc4c 5172 Double_t extendedRadiusDiJet = 0.0;
5173 Double_t phiCurrJetExArL = 0.0; // preliminary left boundary of exluded phi of current jet
5174 Double_t phiCurrJetExArR = 0.0; // preliminary right boundary of exluded phi of current jet
5175 Double_t leftBoundary = 0.0;
5176 Double_t rightBoundary = 0.0;
5177
5178 if(fNotExtDiJEx)
5179 extendedRadiusDiJet = fJetRadius; // old behaviour
5180 if(!fNotExtDiJEx)
5181 extendedRadiusDiJet = fJetRadius+fIncExcR; // new behaviour
5182
5183 for (Int_t indxrec = 0; indxrec < numbRecJ; indxrec++)
5184 {
5185 AliDebug(4,Form("Number of current jet:%i \n",indxrec));
5186 AliAODJet *rjet = dynamic_cast<AliAODJet*>(recojetsA->At(indxrec));
5187 if (!rjet)
5188 {
5189 AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxrec));
5190 continue;
5191 }
5192 etaCurrJet = rjet->Eta();
5193 phiCurrJet = rjet->Phi();
5194 deltaeta = etaCurrJet-tracketa;
5195 deltaphi = phiCurrJet-trackphi;
5196 if (deltaphi > TMath::Pi())
5197 deltaphi = 2.0 * TMath::Pi() - deltaphi;
5198 deltar = sqrt(deltaeta*deltaeta+deltaphi*deltaphi);
5199 if(deltar<=extendedRadius) // if the track is inside the jet, reject (extended radius)
5200 {
5201 // printf("Excluding track for being in the extended jet area. Eta:%f, Phi:%f, deltar=%f \n",tracketa,trackphi,deltar);
5202 return kTRUE;
5203 }
5204 // Now check if it is in the expected dijet area for the two hardest jets
5205 if(indxrec==0||indxrec==1) //two hardest jets in the event
5206 {
5207 //left boundary
5208 phiCurrJetExArL= phiCurrJet + TMath::Pi() - extendedRadiusDiJet;
5209 if(phiCurrJetExArL>TMath::TwoPi())
5210 phiCurrJetExArL=phiCurrJetExArL-TMath::TwoPi();
5211 //right boundary
5212 phiCurrJetExArR= phiCurrJet + TMath::Pi() + extendedRadiusDiJet;
5213 if(phiCurrJetExArR>TMath::TwoPi())
5214 phiCurrJetExArR=phiCurrJetExArR-TMath::TwoPi();
5215 // //Assign left and right boundary
5216 leftBoundary=phiCurrJetExArL;
5217 rightBoundary=phiCurrJetExArR;
5218 // now check if inside the excluded area
5219 if(trackphi>=leftBoundary&&trackphi<=rightBoundary)
5220 {
5221 // printf("Excluding track for being in di-jet excluded area!!! \n");
5222 // printf("phi of track:%f, left bound:%f, right bound:%f \n",trackphi,leftBoundary,rightBoundary);
5223 return kTRUE;
5224 }
5225 }
5226 }
5227 // Si sobrevive todos los tests, regresar kFALSE
5228 return kFALSE;
5229}
5230//________________________________________________________________________
5231Double_t AliAnalysisTaskPartonDisc::GetV0ExcludedMultiplicity(TClonesArray *recojets)
5232{
5233 //
5234 // Calculate the V0 MIP multiplicity that should be excluded due
5235 // to possible jet activity
5236 //
5237
5238 //Check if there is V0 info
5239 if(!fVZero)
5240 {
5241 AliDebug(2,"ERROR: There is not VZERO info in the AOD");
5242 // printf("No hay objeto fVZero \n");
5243 return 0.0;
5244 }
5245
5246 Int_t numbRecJ = recojets->GetEntries();
5247 Double_t phiCurrJet = 0.0;
5248 //Check if there are jets
5249 if(numbRecJ==0)
5250 {
5251 AliDebug(2,"ERROR: There are not jets in the event");
5252 return 0.0;
5253 }
5254
5255 //Flags for V0A sectors
5256 Bool_t removeS0cells = kFALSE;
5257 Bool_t removeS1cells = kFALSE;
5258 Bool_t removeS2cells = kFALSE;
5259 Bool_t removeS3cells = kFALSE;
5260 Bool_t removeS4cells = kFALSE;
5261 Bool_t removeS5cells = kFALSE;
5262 Bool_t removeS6cells = kFALSE;
5263 Bool_t removeS7cells = kFALSE;
5264 //Flags for V0C sectors
5265 Bool_t removeS0cellsV0C = kFALSE;
5266 Bool_t removeS1cellsV0C = kFALSE;
5267 Bool_t removeS2cellsV0C = kFALSE;
5268 Bool_t removeS3cellsV0C = kFALSE;
5269 Bool_t removeS4cellsV0C = kFALSE;
5270 Bool_t removeS5cellsV0C = kFALSE;
5271 Bool_t removeS6cellsV0C = kFALSE;
5272 Bool_t removeS7cellsV0C = kFALSE;
5273 //Excedent multiplicity in V0A, V0C and total
5274 Double_t excedentV0A = 0.0;
5275 Double_t excedentV0C = 0.0;
5276 Double_t excedentV0Total = 0.0;
5277 Double_t phiValLow = 0.0;
5278 Double_t phiValUp = 0.0;
5279 Double_t extendedR = fJetRadius + fIncExcR;
5280
5281 for (Int_t indxrec = 0; indxrec < numbRecJ; indxrec++)
5282 {
5283 // Now check the two hardest jets
5284 if(indxrec==0||indxrec==1) //two hardest jets in the event
5285 {
5286 AliAODJet *rjet = dynamic_cast<AliAODJet*>(recojets->At(indxrec));
5287 if (!rjet)
5288 {
5289 AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxrec));
5290 continue;
5291 }
5292 phiCurrJet = rjet->Phi();
5293
5294 //Get the excluded phi boundaries
5295 Double_t b1 = phiCurrJet + TMath::Pi() - extendedR;
5296 Double_t b2 = phiCurrJet + TMath::Pi() + extendedR;
5297 if(b1>TMath::TwoPi())
5298 b1 = b1 - TMath::TwoPi();
5299 if(b2>TMath::TwoPi())
5300 b2 = b2 - TMath::TwoPi();
5301
5302 phiValLow = b1;
5303 phiValUp = b2;
5304
5305 if(phiValLow>TMath::TwoPi()||phiValUp>TMath::TwoPi()||phiValLow<0.||phiValUp<0.)
5306 return 500.0;
5307
5308 // First V0A (EN EVE LA NUMERACION EMPIEZA EN 1...)
5309 // Cells in sector S0 ( 0 to pi/4): 32,40,48,56
5310 // Cells in sector S1 ( pi/4 to pi/2): 33,41,49,57
5311 // Cells in sector S2 ( pi/2 to 3pi/4): 34,42,50,58
5312 // Cells in sector S3 (3pi/4 to pi ): 35,43,51,59
5313 // Cells in sector S4 ( pi to 5pi/4): 36,44,52,60
5314 // Cells in sector S5 (5pi/4 to 3pi/2): 37,45,53,61
5315 // Cells in sector S6 (3pi/2 to 7pi/4): 38,46,54,62
5316 // Cells in sector S7 (7pi/4 to 2pi ): 39,47,55,63
5317
5318 //Check if falls in sector S0
5319 if(phiValLow>=(0.)&&phiValLow<=(1./4.*TMath::Pi()))
5320 removeS0cells = kTRUE;
5321 if(phiValUp>=(0.)&&phiValUp<=(1./4.*TMath::Pi()))
5322 removeS0cells = kTRUE;
5323 //Check if falls in sector S1
5324 if(phiValLow>=(1./4.*TMath::Pi())&&phiValLow<=(1./2.*TMath::Pi()))
5325 removeS1cells = kTRUE;
5326 if(phiValUp>=(1./4.*TMath::Pi())&&phiValUp<=(1./2.*TMath::Pi()))
5327 removeS1cells = kTRUE;
5328 //Check if falls in sector S2
5329 if(phiValLow>=(1./2.*TMath::Pi())&&phiValLow<=(3./4.*TMath::Pi()))
5330 removeS2cells = kTRUE;
5331 if(phiValUp>=(1./2.*TMath::Pi())&&phiValUp<=(3./4.*TMath::Pi()))
5332 removeS2cells = kTRUE;
5333 //Check if falls in sector S3
5334 if(phiValLow>=(3./4.*TMath::Pi())&&phiValLow<=(TMath::Pi()))
5335 removeS3cells = kTRUE;
5336 if(phiValUp>=(3./4.*TMath::Pi())&&phiValUp<=(TMath::Pi()))
5337 removeS3cells = kTRUE;
5338 //Check if falls in sector S4
5339 if(phiValLow>=(TMath::Pi())&&phiValLow<=(5./4.*TMath::Pi()))
5340 removeS4cells = kTRUE;
5341 if(phiValUp>=(TMath::Pi())&&phiValUp<=(5./4.*TMath::Pi()))
5342 removeS4cells = kTRUE;
5343 //Check if falls in sector S5
5344 if(phiValLow>=(5./4.*TMath::Pi())&&phiValLow<=(3./2.*TMath::Pi()))
5345 removeS5cells = kTRUE;
5346 if(phiValUp>=(5./4.*TMath::Pi())&&phiValUp<=(3./2.*TMath::Pi()))
5347 removeS5cells = kTRUE;
5348 //Check if falls in sector S6
5349 if(phiValLow>=(3./2.*TMath::Pi())&&phiValLow<=(7./4.*TMath::Pi()))
5350 removeS6cells = kTRUE;
5351 if(phiValUp>=(3./2.*TMath::Pi())&&phiValUp<=(7./4.*TMath::Pi()))
5352 removeS6cells = kTRUE;
5353 //Check if falls in sector S7
5354 if(phiValLow>=(7./4.*TMath::Pi())&&phiValLow<=(TMath::TwoPi()))
5355 removeS7cells = kTRUE;
5356 if(phiValUp>=(7./4.*TMath::Pi())&&phiValUp<=(TMath::TwoPi()))
5357 removeS7cells = kTRUE;
5358
5359 /////////////////////////////////////////////////////////////////////////////////
5360
5361 // Now V0C (EN EVE LA NUMERACION EMPIEZA EN 1...)
5362 // Cells in sector S0 ( pi/2 to 3pi/4): 0,8,16,24
5363 // Cells in sector S1 (3pi/4 to pi ): 1,9,17,25
5364 // Cells in sector S2 ( pi to 5pi/4): 2,10,18,26
5365 // Cells in sector S3 (5pi/4 to 3pi/2): 3,11,19,27
5366 // Cells in sector S4 (3pi/2 to 7pi/4): 4,12,20,28
5367 // Cells in sector S5 (7pi/4 to 2pi ): 5,13,21,29
5368 // Cells in sector S6 ( 0 to pi/4): 6,14,22,30
5369 // Cells in sector S7 ( pi/4 to pi/2): 7,15,23,31
5370
5371 //Check if falls in sector S0
5372 if(phiValLow>=(1./2.*TMath::Pi())&&phiValLow<=(3./4.*TMath::Pi()))
5373 removeS0cellsV0C = kTRUE;
5374 if(phiValUp>=(1./2.*TMath::Pi())&&phiValUp<=(3./4.*TMath::Pi()))
5375 removeS0cellsV0C = kTRUE;
5376 //Check if falls in sector S1
5377 if(phiValLow>=(3./4.*TMath::Pi())&&phiValLow<=(TMath::Pi()))
5378 removeS1cellsV0C = kTRUE;
5379 if(phiValUp>=(3./4.*TMath::Pi())&&phiValUp<=(TMath::Pi()))
5380 removeS1cellsV0C = kTRUE;
5381 //Check if falls in sector S2
5382 if(phiValLow>=(TMath::Pi())&&phiValLow<=(5./4.*TMath::Pi()))
5383 removeS2cellsV0C = kTRUE;
5384 if(phiValUp>=(TMath::Pi())&&phiValUp<=(5./4.*TMath::Pi()))
5385 removeS2cellsV0C = kTRUE;
5386 //Check if falls in sector S3
5387 if(phiValLow>=(5./4.*TMath::Pi())&&phiValLow<=(3./2.*TMath::Pi()))
5388 removeS3cellsV0C = kTRUE;
5389 if(phiValUp>=(5./4.*TMath::Pi())&&phiValUp<=(3./2.*TMath::Pi()))
5390 removeS3cellsV0C = kTRUE;
5391 //Check if falls in sector S4
5392 if(phiValLow>=(3./2.*TMath::Pi())&&phiValLow<=(7./4.*TMath::Pi()))
5393 removeS4cellsV0C = kTRUE;
5394 if(phiValUp>=(3./2.*TMath::Pi())&&phiValUp<=(7./4.*TMath::Pi()))
5395 removeS4cellsV0C = kTRUE;
5396 //Check if falls in sector S5
5397 if(phiValLow>=(7./4.*TMath::Pi())&&phiValLow<=(TMath::TwoPi()))
5398 removeS5cellsV0C = kTRUE;
5399 if(phiValUp>=(7./4.*TMath::Pi())&&phiValUp<=(TMath::TwoPi()))
5400 removeS5cellsV0C = kTRUE;
5401 //Check if falls in sector S6
5402 if(phiValLow>=(0.)&&phiValLow<=(1./4.*TMath::Pi()))
5403 removeS6cellsV0C = kTRUE;
5404 if(phiValUp>=(0.)&&phiValUp<=(1./4.*TMath::Pi()))
5405 removeS6cellsV0C = kTRUE;
5406 //Check if falls in sector S7
5407 if(phiValLow>=(1./4.*TMath::Pi())&&phiValLow<=(1./2.*TMath::Pi()))
5408 removeS7cellsV0C = kTRUE;
5409 if(phiValUp>=(1./4.*TMath::Pi())&&phiValUp<=(1./2.*TMath::Pi()))
5410 removeS7cellsV0C = kTRUE;
5411
5412 // printf("phi del jet:%f, philow:%f, phiup:%f \n",phiCurrJet,phiValLow,phiValUp);
5413 } // end if leading jets (2)
5414 } // end jet loop
5415
5416 // printf("_________V0A____________\n");
5417 // printf("Status sector S0:%i \n",removeS0cells);
5418 // printf("Status sector S1:%i \n",removeS1cells);
5419 // printf("Status sector S2:%i \n",removeS2cells);
5420 // printf("Status sector S3:%i \n",removeS3cells);
5421 // printf("Status sector S4:%i \n",removeS4cells);
5422 // printf("Status sector S5:%i \n",removeS5cells);
5423 // printf("Status sector S6:%i \n",removeS6cells);
5424 // printf("Status sector S7:%i \n",removeS7cells);
5425 // printf("_______________________\n");
5426
5427 if(removeS0cells)
5428 excedentV0A = excedentV0A + fVZero->GetMultiplicity(32)+fVZero->GetMultiplicity(40)+fVZero->GetMultiplicity(48)+fVZero->GetMultiplicity(56);
5429 if(removeS1cells)
5430 excedentV0A = excedentV0A + fVZero->GetMultiplicity(33)+fVZero->GetMultiplicity(41)+fVZero->GetMultiplicity(49)+fVZero->GetMultiplicity(57);
5431 if(removeS2cells)
5432 excedentV0A = excedentV0A + fVZero->GetMultiplicity(34)+fVZero->GetMultiplicity(42)+fVZero->GetMultiplicity(50)+fVZero->GetMultiplicity(58);
5433 if(removeS3cells)
5434 excedentV0A = excedentV0A + fVZero->GetMultiplicity(35)+fVZero->GetMultiplicity(43)+fVZero->GetMultiplicity(51)+fVZero->GetMultiplicity(59);
5435 if(removeS4cells)
5436 excedentV0A = excedentV0A + fVZero->GetMultiplicity(36)+fVZero->GetMultiplicity(44)+fVZero->GetMultiplicity(52)+fVZero->GetMultiplicity(60);
5437 if(removeS5cells)
5438 excedentV0A = excedentV0A + fVZero->GetMultiplicity(37)+fVZero->GetMultiplicity(45)+fVZero->GetMultiplicity(53)+fVZero->GetMultiplicity(61);
5439 if(removeS6cells)
5440 excedentV0A = excedentV0A + fVZero->GetMultiplicity(38)+fVZero->GetMultiplicity(46)+fVZero->GetMultiplicity(54)+fVZero->GetMultiplicity(62);
5441 if(removeS7cells)
5442 excedentV0A = excedentV0A + fVZero->GetMultiplicity(39)+fVZero->GetMultiplicity(47)+fVZero->GetMultiplicity(55)+fVZero->GetMultiplicity(63);
5443
5444 // printf("________V0C____________\n");
5445 // printf("Status sector S0:%i \n",removeS0cellsV0C);
5446 // printf("Status sector S1:%i \n",removeS1cellsV0C);
5447 // printf("Status sector S2:%i \n",removeS2cellsV0C);
5448 // printf("Status sector S3:%i \n",removeS3cellsV0C);
5449 // printf("Status sector S4:%i \n",removeS4cellsV0C);
5450 // printf("Status sector S5:%i \n",removeS5cellsV0C);
5451 // printf("Status sector S6:%i \n",removeS6cellsV0C);
5452 // printf("Status sector S7:%i \n",removeS7cellsV0C);
5453 // printf("_______________________\n");
5454
5455 if(removeS0cellsV0C)
5456 excedentV0C = excedentV0C + fVZero->GetMultiplicity(0)+fVZero->GetMultiplicity(8)+fVZero->GetMultiplicity(16)+fVZero->GetMultiplicity(24);
5457 if(removeS1cellsV0C)
5458 excedentV0C = excedentV0C + fVZero->GetMultiplicity(1)+fVZero->GetMultiplicity(9)+fVZero->GetMultiplicity(17)+fVZero->GetMultiplicity(25);
5459 if(removeS2cellsV0C)
5460 excedentV0C = excedentV0C + fVZero->GetMultiplicity(2)+fVZero->GetMultiplicity(10)+fVZero->GetMultiplicity(18)+fVZero->GetMultiplicity(26);
5461 if(removeS3cellsV0C)
5462 excedentV0C = excedentV0C + fVZero->GetMultiplicity(3)+fVZero->GetMultiplicity(11)+fVZero->GetMultiplicity(19)+fVZero->GetMultiplicity(27);
5463 if(removeS4cellsV0C)
5464 excedentV0C = excedentV0C + fVZero->GetMultiplicity(4)+fVZero->GetMultiplicity(12)+fVZero->GetMultiplicity(20)+fVZero->GetMultiplicity(28);
5465 if(removeS5cellsV0C)
5466 excedentV0C = excedentV0C + fVZero->GetMultiplicity(5)+fVZero->GetMultiplicity(13)+fVZero->GetMultiplicity(21)+fVZero->GetMultiplicity(29);
5467 if(removeS6cellsV0C)
5468 excedentV0C = excedentV0C + fVZero->GetMultiplicity(6)+fVZero->GetMultiplicity(14)+fVZero->GetMultiplicity(22)+fVZero->GetMultiplicity(30);
5469 if(removeS7cellsV0C)
5470 excedentV0C = excedentV0C + fVZero->GetMultiplicity(7)+fVZero->GetMultiplicity(15)+fVZero->GetMultiplicity(23)+fVZero->GetMultiplicity(31);
5471
5472 excedentV0Total = excedentV0A+excedentV0C;
5473
5474 // printf("La multiplicidad total en V0 es:%f, la multiplicidad excedente en V0A es:%f, y en V0C es:%f, la multiplicidad corregida es:%f \n",fVZero->GetMTotV0A()+fVZero->GetMTotV0C(),excedentV0A,excedentV0C,fVZero->GetMTotV0A()+fVZero->GetMTotV0C()-excedentV0Total);
5475
5476 return excedentV0Total;
5477}
5478//________________________________________________________________________
5479Int_t AliAnalysisTaskPartonDisc::GetV0LikeExcludedMultMC(TClonesArray *mcjets, TClonesArray *mcparticles)
5480{
5481 //
5482 // Calculate the V0 like multiplicity that should be excluded due
5483 // to possible jet activity in MC events
5484 //
5485
5486 Int_t nMcJets = mcjets->GetEntries();
5487 Int_t tracksMC = mcparticles->GetEntriesFast();
5488 Double_t phiCurrJet = 0.0;
5489 //Check if there are jets
5490 if(nMcJets==0)
5491 {
5492 AliDebug(2,"ERROR: There are no MC jets in the event");
5493 return 0;
5494 }
5495 Int_t excludedMultV0Like = 0;
5496 Double_t trackphi=0.0;
5497 Double_t extendedR = fJetRadius + fIncExcR;
5498 for (Int_t indxMC = 0; indxMC < nMcJets; indxMC++)
5499 {
5500 // Now check the two hardest jets
5501 if(indxMC==0||indxMC==1) //two hardest jets in the event
5502 {
5503 AliAODJet *mcJet = dynamic_cast<AliAODJet*>(mcjets->At(indxMC));
5504 if (!mcJet)
5505 {
5506 AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxMC));
5507 continue;
5508 }
5509 phiCurrJet = mcJet->Phi();
5510 //Get the excluded phi boundaries
5511 Double_t b1 = phiCurrJet + TMath::Pi() - extendedR;
5512 Double_t b2 = phiCurrJet + TMath::Pi() + extendedR;
5513 if(b1>TMath::TwoPi())
5514 b1 = b1 - TMath::TwoPi();
5515 if(b2>TMath::TwoPi())
5516 b2 = b2 - TMath::TwoPi();
5517 // now check the charged tracks in the V0 acceptance
5518 for(Int_t aodMCTrack = 0; aodMCTrack < tracksMC; aodMCTrack++ )
5519 {
5520 AliAODMCParticle *mctrackf = (AliAODMCParticle*) mcparticles->At(aodMCTrack);
5521 if(!mctrackf) continue;
5522 if(!mctrackf->IsPhysicalPrimary()) continue;
5523 if(mctrackf->Charge()==0||mctrackf->Charge()==-99) continue;
5524 if(mctrackf->Pt()<fMinpTValMC) continue; // cut off en MC
5525 trackphi = mctrackf->Phi();
5526 if(trackphi>=b1&&trackphi<=b2)
5527 {
5528 //V0A
5529 if(((mctrackf->Eta())>(2.8))&&((mctrackf->Eta())<(5.1)))
5530 excludedMultV0Like++;
5531 //V0C
5532 if(((mctrackf->Eta())>(-3.7))&&((mctrackf->Eta())<(-1.7)))
5533 excludedMultV0Like++;
5534 }
5535 }
5536 } // end of 2 hardest jets
5537 } // end jet loop
5538 return excludedMultV0Like;
5539}
5540//________________________________________________________________________
5541void AliAnalysisTaskPartonDisc::FillPerpConeHisto(TH3F *currenthisto, Int_t ntracks, AliAODEvent *aode, Int_t CentralityBin, Int_t pTBin)
5542{
5543
5544 // Fills the histrogram of the pT distribution in the perpendicular cone
5545
5546 Double_t aodtracketaC = 0.;
5547
5548 for(Int_t aodT = 0; aodT < ntracks; aodT++ )
5549 {
f15c1f69 5550 AliAODTrack *aodtrackC = dynamic_cast<AliAODTrack*>(aode->GetTrack(aodT));
5551 if(!aodtrackC) AliFatal("Not a standard AOD");
0c9acc4c 5552 if(!aodtrackC) continue;
5553 aodtracketaC = TMath::Abs(aodtrackC->Eta());
5554 if(aodtracketaC>0.9) continue;
5555 if(!aodtrackC->TestFilterBit(fFilterBit)) continue; //track filter selection
0c9acc4c 5556 if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
5557 {
5558 if(HasPerpendicularCone()) // If there is a perpendicular cone available
5559 {
5560 if(aodtrackC->Pt()>fMinpTVal)
5561 {
5562 if(GetDeltaR(fEtaPerpCoord,fPhiPerpCoord,aodtrackC->Eta(),aodtrackC->Phi())<fJetRadius)
5563 {
5564 currenthisto->Fill(aodtrackC->Pt(),pTBin,CentralityBin);
5565 }
5566 }
5567 }
5568 } // end if jet event
5569 }
5570}
5571//________________________________________________________________________
5572Bool_t AliAnalysisTaskPartonDisc::IsEqualRel(Double_t vA, Double_t vB)
5573{
5574 // Comparison of Double_t values
5575
5576 Double_t epsVal = 0.000001;
5577 return TMath::Abs(vA-vB) <= epsVal*TMath::Abs(vA);
5578
5579}