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