| ac6a3f1e |
1 | #include "AliAnalysisTaskFullpAJets.h" |
| 2 | |
| 3 | #include <Riostream.h> |
| 4 | #include <ctime> |
| 5 | #include <TString.h> |
| 6 | #include <TChain.h> |
| 7 | #include <TTree.h> |
| 8 | #include <TH1D.h> |
| 9 | #include <TH2D.h> |
| 10 | #include <TH3D.h> |
| 11 | #include <TCanvas.h> |
| 12 | #include <TList.h> |
| 13 | #include <TLorentzVector.h> |
| 14 | #include <TProfile.h> |
| 15 | #include <TProfile2D.h> |
| 16 | #include <TProfile3D.h> |
| 17 | #include <TRandom.h> |
| 18 | #include <TRandom3.h> |
| c6202663 |
19 | #include <TClonesArray.h> |
| 20 | #include <TObjArray.h> |
| ac6a3f1e |
21 | |
| 22 | #include "AliAnalysisTaskSE.h" |
| 23 | #include "AliAnalysisManager.h" |
| 24 | #include "AliStack.h" |
| 25 | #include "AliESDtrackCuts.h" |
| 26 | #include "AliESDEvent.h" |
| 27 | #include "AliESDInputHandler.h" |
| 28 | #include "AliAODEvent.h" |
| 29 | #include "AliMCEvent.h" |
| c6202663 |
30 | #include "AliVTrack.h" |
| 31 | #include "AliVCluster.h" |
| ac6a3f1e |
32 | #include "AliEmcalJet.h" |
| 33 | #include "AliEMCALGeometry.h" |
| c6202663 |
34 | #include "Rtypes.h" |
| ac6a3f1e |
35 | |
| 36 | ClassImp(AliAnalysisTaskFullpAJets) |
| 37 | |
| 38 | //________________________________________________________________________ |
| 39 | AliAnalysisTaskFullpAJets::AliAnalysisTaskFullpAJets() : |
| 40 | AliAnalysisTaskSE(), |
| 41 | |
| 42 | fOutput(0), |
| ac6a3f1e |
43 | fhTrackPt(0), |
| 44 | fhTrackEta(0), |
| 45 | fhTrackPhi(0), |
| 46 | fhClusterPt(0), |
| 47 | fhClusterEta(0), |
| 48 | fhClusterPhi(0), |
| c54b626a |
49 | fhCentrality(0), |
| ac6a3f1e |
50 | fhEMCalCellCounts(0), |
| 7acc3e04 |
51 | fhDeltaRhoN(0), |
| 52 | fhDeltaRhoCMS(0), |
| 78246241 |
53 | |
| ac6a3f1e |
54 | fhTrackEtaPhi(0), |
| 55 | fhClusterEtaPhi(0), |
| 56 | fhJetPtArea(0), |
| ac6a3f1e |
57 | fhJetConstituentPt(0), |
| c6202663 |
58 | fhRhoScale(0), |
| 59 | |
| 60 | fpEMCalEventMult(0), |
| 61 | fpTPCEventMult(0), |
| ac6a3f1e |
62 | fpRhoScale(0), |
| 78246241 |
63 | |
| d812e269 |
64 | fpJetEtaProfile(0), |
| 65 | fpJetAbsEtaProfile(0), |
| 66 | fpChargedJetRProfile(0), |
| 67 | fpJetRProfile(0), |
| 68 | |
| ac6a3f1e |
69 | fpTrackPtProfile(0), |
| c54b626a |
70 | fpClusterPtProfile(0), |
| 71 | |
| d812e269 |
72 | fpChargedJetEDProfile(0), |
| 73 | fpJetEDProfile(0), |
| 74 | |
| c6202663 |
75 | fTPCRawJets(0), |
| 76 | fEMCalRawJets(0), |
| 77 | fRhoFull0(0), |
| 78 | fRhoFull1(0), |
| 79 | fRhoFull2(0), |
| 80 | fRhoFullN(0), |
| 81 | fRhoFullDijet(0), |
| 82 | fRhoFullkT(0), |
| 83 | fRhoFullCMS(0), |
| 84 | fRhoCharged0(0), |
| 85 | fRhoCharged1(0), |
| 86 | fRhoCharged2(0), |
| 87 | fRhoChargedN(0), |
| 88 | fRhoChargedScale(0), |
| 89 | fRhoChargedkT(0), |
| 90 | fRhoChargedkTScale(0), |
| 91 | fRhoChargedCMS(0), |
| 92 | fRhoChargedCMSScale(0), |
| 93 | |
| 94 | fTPCJet(0), |
| 95 | fTPCFullJet(0), |
| 96 | fTPCOnlyJet(0), |
| 97 | fTPCkTFullJet(0), |
| 98 | fEMCalJet(0), |
| 99 | fEMCalFullJet(0), |
| 100 | fEMCalPartJet(0), |
| 101 | fEMCalkTFullJet(0), |
| 102 | |
| c54b626a |
103 | fIsInitialized(0), |
| c6202663 |
104 | fRJET(4), |
| c54b626a |
105 | fnEvents(0), |
| 106 | fnEventsCharged(0), |
| 107 | fnDiJetEvents(0), |
| c6202663 |
108 | fEMCalPhiMin(1.39626), |
| 109 | fEMCalPhiMax(3.26377), |
| 110 | fEMCalPhiTotal(1.86750), |
| 111 | fEMCalEtaMin(-0.7), |
| 112 | fEMCalEtaMax(0.7), |
| 113 | fEMCalEtaTotal(1.4), |
| 114 | fEMCalArea(2.61450), |
| c54b626a |
115 | fTPCPhiMin(0), |
| c6202663 |
116 | fTPCPhiMax(6.28319), |
| 117 | fTPCPhiTotal(6.28319), |
| 118 | fTPCEtaMin(-0.9), |
| 119 | fTPCEtaMax(0.9), |
| 120 | fTPCEtaTotal(1.8), |
| 121 | fTPCArea(11.30973), |
| 122 | fJetR(0.4), |
| 123 | fJetRForRho(0.5), |
| 124 | fJetAreaCutFrac(0.6), |
| 125 | fJetAreaThreshold(0.30159), |
| 126 | fnEMCalCells(12288), |
| 127 | fScaleFactor(1.50), |
| 7acc3e04 |
128 | fNColl(7), |
| c6202663 |
129 | fTrackMinPt(0.15), |
| 130 | fClusterMinPt(0.3), |
| 3aae667c |
131 | fCentralityTag("V0A"), |
| c6202663 |
132 | fCentralityBins(10), |
| c54b626a |
133 | fCentralityLow(0), |
| c6202663 |
134 | fCentralityUp(100), |
| c54b626a |
135 | fEventCentrality(0), |
| c6202663 |
136 | fRhoFull(0), |
| c54b626a |
137 | fRhoCharged(0), |
| c6202663 |
138 | fEtaProfileBins(14), |
| 139 | fEtaProfileLow(-0.7), |
| 140 | fEtaProfileUp(0.7), |
| 141 | fEDProfileRBins(50), |
| c54b626a |
142 | fEDProfileRLow(0), |
| c6202663 |
143 | fEDProfileRUp(0.5), |
| 144 | fEDProfilePtBins(100), |
| c54b626a |
145 | fEDProfilePtLow(0), |
| c6202663 |
146 | fEDProfilePtUp(100), |
| 147 | fEDProfileEtaBins(4), |
| 148 | fEDProfileEtaLow(-0.2), |
| 149 | fEDProfileEtaUp(0.2), |
| c54b626a |
150 | fnTracks(0), |
| 151 | fnClusters(0), |
| 152 | fnAKTFullJets(0), |
| 153 | fnAKTChargedJets(0), |
| 154 | fnKTFullJets(0), |
| 78246241 |
155 | fnKTChargedJets(0), |
| c54b626a |
156 | fnBckgClusters(0), |
| c6202663 |
157 | fTPCJetThreshold(5), |
| 158 | fEMCalJetThreshold(5), |
| 159 | fVertexWindow(10), |
| 160 | fVertexMaxR(1), |
| d812e269 |
161 | fTrackName(0), |
| 162 | fClusName(0), |
| 163 | fkTChargedName(0), |
| 164 | fAkTChargedName(0), |
| 165 | fkTFullName(0), |
| 166 | fAkTFullName(0), |
| c6202663 |
167 | fOrgTracks(0), |
| 168 | fOrgClusters(0), |
| c54b626a |
169 | fmyAKTFullJets(0), |
| 170 | fmyAKTChargedJets(0), |
| 171 | fmyKTFullJets(0), |
| 78246241 |
172 | fmyKTChargedJets(0), |
| c6202663 |
173 | fmyTracks(0), |
| 174 | fmyClusters(0), |
| 175 | fEMCalRCBckgFluc(0), |
| 176 | fTPCRCBckgFluc(0), |
| 177 | fEMCalRCBckgFlucSignal(0), |
| 7acc3e04 |
178 | fTPCRCBckgFlucSignal(0), |
| 179 | fEMCalRCBckgFlucNColl(0), |
| 180 | fTPCRCBckgFlucNColl(0) |
| ac6a3f1e |
181 | { |
| 182 | // Dummy constructor ALWAYS needed for I/O. |
| 183 | fpJetEtaProfile = new TProfile *[14]; |
| 184 | fpJetAbsEtaProfile = new TProfile *[14]; |
| 185 | fpChargedJetRProfile = new TProfile *[8]; |
| 186 | fpJetRProfile= new TProfile *[4]; |
| 187 | fpChargedJetEDProfile= new TProfile3D *[10]; |
| 188 | fpJetEDProfile= new TProfile3D *[10]; |
| c54b626a |
189 | fvertex[0]=0.0,fvertex[1]=0.0,fvertex[2]=0.0; |
| ac6a3f1e |
190 | } |
| 191 | |
| 192 | //________________________________________________________________________ |
| 193 | AliAnalysisTaskFullpAJets::AliAnalysisTaskFullpAJets(const char *name) : |
| 194 | AliAnalysisTaskSE(name), |
| 195 | |
| 196 | fOutput(0), |
| ac6a3f1e |
197 | fhTrackPt(0), |
| 198 | fhTrackEta(0), |
| 199 | fhTrackPhi(0), |
| 200 | fhClusterPt(0), |
| 201 | fhClusterEta(0), |
| 202 | fhClusterPhi(0), |
| c54b626a |
203 | fhCentrality(0), |
| ac6a3f1e |
204 | fhEMCalCellCounts(0), |
| 7acc3e04 |
205 | fhDeltaRhoN(0), |
| 206 | fhDeltaRhoCMS(0), |
| 78246241 |
207 | |
| ac6a3f1e |
208 | fhTrackEtaPhi(0), |
| 209 | fhClusterEtaPhi(0), |
| 210 | fhJetPtArea(0), |
| ac6a3f1e |
211 | fhJetConstituentPt(0), |
| c6202663 |
212 | fhRhoScale(0), |
| 213 | |
| 214 | fpEMCalEventMult(0), |
| 215 | fpTPCEventMult(0), |
| ac6a3f1e |
216 | fpRhoScale(0), |
| 78246241 |
217 | |
| d812e269 |
218 | fpJetEtaProfile(0), |
| 219 | fpJetAbsEtaProfile(0), |
| 220 | fpChargedJetRProfile(0), |
| 221 | fpJetRProfile(0), |
| 222 | |
| ac6a3f1e |
223 | fpTrackPtProfile(0), |
| c54b626a |
224 | fpClusterPtProfile(0), |
| 225 | |
| d812e269 |
226 | fpChargedJetEDProfile(0), |
| 227 | fpJetEDProfile(0), |
| 228 | |
| c6202663 |
229 | fTPCRawJets(0), |
| 230 | fEMCalRawJets(0), |
| 231 | fRhoFull0(0), |
| 232 | fRhoFull1(0), |
| 233 | fRhoFull2(0), |
| 234 | fRhoFullN(0), |
| 235 | fRhoFullDijet(0), |
| 236 | fRhoFullkT(0), |
| 237 | fRhoFullCMS(0), |
| 238 | fRhoCharged0(0), |
| 239 | fRhoCharged1(0), |
| 240 | fRhoCharged2(0), |
| 241 | fRhoChargedN(0), |
| 242 | fRhoChargedScale(0), |
| 243 | fRhoChargedkT(0), |
| 244 | fRhoChargedkTScale(0), |
| 245 | fRhoChargedCMS(0), |
| 246 | fRhoChargedCMSScale(0), |
| 247 | |
| 248 | fTPCJet(0), |
| 249 | fTPCFullJet(0), |
| 250 | fTPCOnlyJet(0), |
| 251 | fTPCkTFullJet(0), |
| 252 | fEMCalJet(0), |
| 253 | fEMCalFullJet(0), |
| 254 | fEMCalPartJet(0), |
| 255 | fEMCalkTFullJet(0), |
| 256 | |
| c54b626a |
257 | fIsInitialized(0), |
| c6202663 |
258 | fRJET(4), |
| c54b626a |
259 | fnEvents(0), |
| 260 | fnEventsCharged(0), |
| 261 | fnDiJetEvents(0), |
| c6202663 |
262 | fEMCalPhiMin(1.39626), |
| 263 | fEMCalPhiMax(3.26377), |
| 264 | fEMCalPhiTotal(1.86750), |
| 265 | fEMCalEtaMin(-0.7), |
| 266 | fEMCalEtaMax(0.7), |
| 267 | fEMCalEtaTotal(1.4), |
| 268 | fEMCalArea(2.61450), |
| c54b626a |
269 | fTPCPhiMin(0), |
| c6202663 |
270 | fTPCPhiMax(6.28319), |
| 271 | fTPCPhiTotal(6.28319), |
| 272 | fTPCEtaMin(-0.9), |
| 273 | fTPCEtaMax(0.9), |
| 274 | fTPCEtaTotal(1.8), |
| 275 | fTPCArea(11.30973), |
| 276 | fJetR(0.4), |
| 277 | fJetRForRho(0.5), |
| 278 | fJetAreaCutFrac(0.6), |
| 279 | fJetAreaThreshold(0.30159), |
| 280 | fnEMCalCells(12288), |
| 281 | fScaleFactor(1.50), |
| 7acc3e04 |
282 | fNColl(7), |
| c6202663 |
283 | fTrackMinPt(0.15), |
| 284 | fClusterMinPt(0.3), |
| 3aae667c |
285 | fCentralityTag("V0A"), |
| c6202663 |
286 | fCentralityBins(10), |
| c54b626a |
287 | fCentralityLow(0), |
| c6202663 |
288 | fCentralityUp(100), |
| c54b626a |
289 | fEventCentrality(0), |
| c6202663 |
290 | fRhoFull(0), |
| c54b626a |
291 | fRhoCharged(0), |
| c6202663 |
292 | fEtaProfileBins(14), |
| 293 | fEtaProfileLow(-0.7), |
| 294 | fEtaProfileUp(0.7), |
| 295 | fEDProfileRBins(50), |
| c54b626a |
296 | fEDProfileRLow(0), |
| c6202663 |
297 | fEDProfileRUp(0.5), |
| 298 | fEDProfilePtBins(100), |
| c54b626a |
299 | fEDProfilePtLow(0), |
| c6202663 |
300 | fEDProfilePtUp(100), |
| 301 | fEDProfileEtaBins(4), |
| 302 | fEDProfileEtaLow(-0.2), |
| 303 | fEDProfileEtaUp(0.2), |
| c54b626a |
304 | fnTracks(0), |
| 305 | fnClusters(0), |
| 306 | fnAKTFullJets(0), |
| 307 | fnAKTChargedJets(0), |
| 308 | fnKTFullJets(0), |
| 78246241 |
309 | fnKTChargedJets(0), |
| c54b626a |
310 | fnBckgClusters(0), |
| c6202663 |
311 | fTPCJetThreshold(5), |
| 312 | fEMCalJetThreshold(5), |
| 313 | fVertexWindow(10), |
| 314 | fVertexMaxR(1), |
| d812e269 |
315 | fTrackName(0), |
| 316 | fClusName(0), |
| 317 | fkTChargedName(0), |
| 318 | fAkTChargedName(0), |
| 319 | fkTFullName(0), |
| 320 | fAkTFullName(0), |
| c6202663 |
321 | fOrgTracks(0), |
| 322 | fOrgClusters(0), |
| c54b626a |
323 | fmyAKTFullJets(0), |
| 324 | fmyAKTChargedJets(0), |
| 325 | fmyKTFullJets(0), |
| 78246241 |
326 | fmyKTChargedJets(0), |
| c6202663 |
327 | fmyTracks(0), |
| 328 | fmyClusters(0), |
| 329 | fEMCalRCBckgFluc(0), |
| 330 | fTPCRCBckgFluc(0), |
| 331 | fEMCalRCBckgFlucSignal(0), |
| 7acc3e04 |
332 | fTPCRCBckgFlucSignal(0), |
| 333 | fEMCalRCBckgFlucNColl(0), |
| 334 | fTPCRCBckgFlucNColl(0) |
| ac6a3f1e |
335 | { |
| 336 | // Constructor |
| 337 | // Define input and output slots here (never in the dummy constructor) |
| 338 | // Input slot #0 works with a TChain - it is connected to the default input container |
| 339 | // Output slot #1 writes into a TH1 container |
| 340 | fpJetEtaProfile = new TProfile *[14]; |
| 341 | fpJetAbsEtaProfile = new TProfile *[14]; |
| 342 | fpChargedJetRProfile = new TProfile *[8]; |
| 343 | fpJetRProfile = new TProfile *[4]; |
| 344 | fpChargedJetEDProfile= new TProfile3D *[10]; |
| 345 | fpJetEDProfile= new TProfile3D *[10]; |
| c54b626a |
346 | fvertex[0]=0.0,fvertex[1]=0.0,fvertex[2]=0.0; |
| ac6a3f1e |
347 | |
| c54b626a |
348 | DefineOutput(1,TList::Class()); // for output list |
| ac6a3f1e |
349 | } |
| 350 | |
| 351 | //________________________________________________________________________ |
| 352 | AliAnalysisTaskFullpAJets::~AliAnalysisTaskFullpAJets() |
| 353 | { |
| 354 | // Destructor. Clean-up the output list, but not the histograms that are put inside |
| 355 | // (the list is owner and will clean-up these histograms). Protect in PROOF case. |
| 356 | if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) |
| 357 | { |
| 358 | delete fOutput; |
| 359 | } |
| ac6a3f1e |
360 | } |
| 361 | |
| 362 | //________________________________________________________________________ |
| 363 | void AliAnalysisTaskFullpAJets::UserCreateOutputObjects() |
| 364 | { |
| 365 | // Create histograms |
| 366 | // Called once (on the worker node) |
| 367 | fIsInitialized=kFALSE; |
| 368 | fOutput = new TList(); |
| 369 | fOutput->SetOwner(); // IMPORTANT! |
| 370 | |
| ac6a3f1e |
371 | // Initialize Global Variables |
| 372 | fnEvents=0; |
| 373 | fnEventsCharged=0; |
| 374 | fnDiJetEvents=0; |
| ac6a3f1e |
375 | |
| c54b626a |
376 | // fRJET=4 -> fJetR=0.4 && fRJET=25 -> fJetR=0.25, but for writing files, should be 4 and 25 respectively |
| 377 | if (fRJET>10) |
| 378 | { |
| 379 | fJetR=(Double_t)fRJET/100.0; |
| 380 | } |
| 381 | else |
| 382 | { |
| 383 | fJetR=(Double_t)fRJET/10.0; |
| 384 | } |
| c6202663 |
385 | fJetRForRho=0.5; |
| 386 | |
| ac6a3f1e |
387 | fEMCalPhiMin=(80/(double)360)*2*TMath::Pi(); |
| 388 | fEMCalPhiMax=(187/(double)360)*2*TMath::Pi(); |
| 389 | fEMCalPhiTotal= fEMCalPhiMax-fEMCalPhiMin; |
| 390 | fEMCalEtaMin=-0.7; |
| 391 | fEMCalEtaMax=0.7; |
| 392 | fEMCalEtaTotal=fEMCalEtaMax-fEMCalEtaMin; |
| 393 | fEMCalArea=fEMCalPhiTotal*fEMCalEtaTotal; |
| 394 | |
| 395 | fTPCPhiMin=(0/(double)360)*2*TMath::Pi(); |
| 396 | fTPCPhiMax=(360/(double)360)*2*TMath::Pi(); |
| 397 | fTPCPhiTotal= fTPCPhiMax-fTPCPhiMin; |
| 398 | fTPCEtaMin=-0.9; |
| 399 | fTPCEtaMax=0.9; |
| 400 | fTPCEtaTotal=fTPCEtaMax-fTPCEtaMin; |
| 401 | fTPCArea=fTPCPhiTotal*fTPCEtaTotal; |
| 402 | |
| 403 | fCentralityBins=10; |
| 404 | fCentralityLow=0.0; |
| 405 | fCentralityUp=100.0; |
| c54b626a |
406 | Int_t CentralityBinMult=10; |
| 407 | |
| c6202663 |
408 | fJetAreaCutFrac =0.6; // Fudge factor for selecting on jets with threshold Area or higher |
| ac6a3f1e |
409 | fJetAreaThreshold=fJetAreaCutFrac*TMath::Pi()*fJetR*fJetR; |
| c6202663 |
410 | fTPCJetThreshold=5.0; // Threshold required for an Anti-kT Charged jet to be considered a "true" jet in TPC |
| 411 | fEMCalJetThreshold=5.0; // Threshold required for an Anti-kT Charged+Neutral jet to be considered a "true" jet in EMCal |
| ac6a3f1e |
412 | fVertexWindow=10.0; |
| 413 | fVertexMaxR=1.0; |
| 414 | |
| c6202663 |
415 | fnBckgClusters=1; |
| 416 | fEMCalRCBckgFluc = new Double_t[fnBckgClusters]; |
| 417 | fTPCRCBckgFluc = new Double_t[fnBckgClusters]; |
| 418 | fEMCalRCBckgFlucSignal = new Double_t[fnBckgClusters]; |
| 419 | fTPCRCBckgFlucSignal = new Double_t[fnBckgClusters]; |
| 7acc3e04 |
420 | fEMCalRCBckgFlucNColl = new Double_t[fnBckgClusters]; |
| 421 | fTPCRCBckgFlucNColl = new Double_t[fnBckgClusters]; |
| ac6a3f1e |
422 | for (Int_t i=0;i<fnBckgClusters;i++) |
| 423 | { |
| c6202663 |
424 | fEMCalRCBckgFluc[i]=0.0; |
| 425 | fTPCRCBckgFluc[i]=0.0; |
| 426 | fEMCalRCBckgFlucSignal[i]=0.0; |
| 427 | fTPCRCBckgFlucSignal[i]=0.0; |
| 7acc3e04 |
428 | fEMCalRCBckgFlucNColl[i]=0.0; |
| 429 | fTPCRCBckgFlucNColl[i]=0.0; |
| ac6a3f1e |
430 | } |
| 431 | |
| ac6a3f1e |
432 | fnEMCalCells=12288; // sMods 1-10 have 24x48 cells, sMods 11&12 have 8x48 cells... |
| 433 | |
| c54b626a |
434 | // Histograms |
| 435 | Int_t JetPtBins = 200; |
| 436 | Double_t JetPtLow = 0.0; |
| 437 | Double_t JetPtUp = 200.0; |
| 438 | |
| ac6a3f1e |
439 | Int_t TCBins=100; |
| 440 | |
| c54b626a |
441 | // QA Plots |
| 442 | fhTrackPt = new TH1D("fhTrackPt","p_{T} distribution of tracks in event",10*JetPtBins,JetPtLow,JetPtUp); |
| ac6a3f1e |
443 | fhTrackPt->GetXaxis()->SetTitle("p_{T} (GeV/c)"); |
| 444 | fhTrackPt->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}"); |
| 445 | fhTrackPt->Sumw2(); |
| 446 | |
| 447 | fhTrackPhi = new TH1D("fhTrackPhi","#phi distribution of tracks in event",TCBins,fTPCPhiMin,fTPCPhiMax); |
| 448 | fhTrackPhi->GetXaxis()->SetTitle("#phi"); |
| 449 | fhTrackPhi->GetYaxis()->SetTitle("1/N_{Events} dN/d#phi"); |
| 450 | fhTrackPhi->Sumw2(); |
| 451 | |
| 452 | fhTrackEta = new TH1D("fhTrackEta","#eta distribution of tracks in event",TCBins,fTPCEtaMin,fTPCEtaMax); |
| 453 | fhTrackEta->GetXaxis()->SetTitle("#eta"); |
| 454 | fhTrackEta->GetYaxis()->SetTitle("1/N_{Events} dN/d#eta"); |
| 455 | fhTrackEta->Sumw2(); |
| 456 | |
| 457 | fhTrackEtaPhi = new TH2D("fhTrackEtaPhi","#eta-#phi distribution of tracks in event",TCBins,fTPCEtaMin,fTPCEtaMax,TCBins,fTPCPhiMin,fTPCPhiMax); |
| 458 | fhTrackEtaPhi->GetXaxis()->SetTitle("#eta"); |
| 459 | fhTrackEtaPhi->GetYaxis()->SetTitle("#phi"); |
| 460 | fhTrackEtaPhi->GetZaxis()->SetTitle("1/N_{Events} dN/d#etad#phi"); |
| 461 | fhTrackEtaPhi->Sumw2(); |
| 462 | |
| c54b626a |
463 | fhClusterPt = new TH1D("fhClusterPt","p_{T} distribution of clusters in event",10*JetPtBins,JetPtLow,JetPtUp); |
| ac6a3f1e |
464 | fhClusterPt->GetXaxis()->SetTitle("p_{T} (GeV/c)"); |
| 465 | fhClusterPt->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}"); |
| 466 | fhClusterPt->Sumw2(); |
| 467 | |
| 468 | fhClusterPhi = new TH1D("fhClusterPhi","#phi distribution of clusters in event",TCBins,fTPCPhiMin,fTPCPhiMax); |
| 469 | fhClusterPhi->GetXaxis()->SetTitle("#phi"); |
| 470 | fhClusterPhi->GetYaxis()->SetTitle("1/N_{Events} dN/d#phi"); |
| 471 | fhClusterPhi->Sumw2(); |
| 472 | |
| 473 | fhClusterEta = new TH1D("fhClusterEta","#eta distribution of clusters in event",TCBins,fTPCEtaMin,fTPCEtaMax); |
| 474 | fhClusterEta->GetXaxis()->SetTitle("#eta"); |
| 475 | fhClusterEta->GetYaxis()->SetTitle("1/N_{Events} dN/d#eta"); |
| 476 | fhClusterEta->Sumw2(); |
| 477 | |
| 478 | fhClusterEtaPhi = new TH2D("fhClusterEtaPhi","#eta-#phi distribution of clusters in event",TCBins,fEMCalEtaMin,fEMCalEtaMax,TCBins,fEMCalPhiMin,fEMCalPhiMax); |
| 479 | fhClusterEtaPhi->GetXaxis()->SetTitle("#eta"); |
| 480 | fhClusterEtaPhi->GetYaxis()->SetTitle("#phi"); |
| 481 | fhClusterEtaPhi->GetZaxis()->SetTitle("1/N_{Events} dN/d#etad#phi"); |
| 482 | fhClusterEtaPhi->Sumw2(); |
| 483 | |
| c54b626a |
484 | fhCentrality = new TH1D("fhCentrality","Event Centrality Distribution",fCentralityBins*CentralityBinMult,fCentralityLow,fCentralityUp); |
| c6202663 |
485 | fhCentrality->GetXaxis()->SetTitle(fCentralityTag); |
| c54b626a |
486 | fhCentrality->GetYaxis()->SetTitle("1/N_{Events}"); |
| 487 | fhCentrality->Sumw2(); |
| 488 | |
| c54b626a |
489 | fhJetConstituentPt= new TH2D("fhJetConstituentPt","Jet constituents p_{T} distribution",JetPtBins, JetPtLow, JetPtUp,10*JetPtBins, JetPtLow, JetPtUp); |
| 490 | fhJetConstituentPt->GetXaxis()->SetTitle("Jet p_{T} (GeV/c)"); |
| 491 | fhJetConstituentPt->GetYaxis()->SetTitle("Constituent p_{T} (GeV/c)"); |
| 492 | fhJetConstituentPt->Sumw2(); |
| 493 | |
| 494 | fhEMCalCellCounts = new TH1D("fhEMCalCellCounts","Distribtuion of cluster counts across the EMCal",fnEMCalCells,1,fnEMCalCells); |
| 495 | fhEMCalCellCounts->GetXaxis()->SetTitle("Absoulute Cell Id"); |
| 496 | fhEMCalCellCounts->GetYaxis()->SetTitle("Counts per Event"); |
| 497 | fhEMCalCellCounts->Sumw2(); |
| 498 | |
| 7acc3e04 |
499 | // Rho QA Plots |
| 500 | Int_t RhoBins = 1000; |
| 501 | Double_t RhoPtMin = -50.0; |
| 502 | Double_t RhoPtMax = 50.0; |
| 503 | |
| 504 | fhDeltaRhoN = new TH1D("fhDeltaRhoN","0-100% #delta#rho_{N} = #rho_{N}^{TPC+EMCal} - #rho_{N}^{TPC+Scale}",RhoBins,RhoPtMin,RhoPtMax); |
| 505 | fhDeltaRhoN->GetXaxis()->SetTitle("#delta#rho (GeV)"); |
| 506 | fhDeltaRhoN->GetYaxis()->SetTitle("Counts"); |
| 507 | fhDeltaRhoN->Sumw2(); |
| 508 | |
| 509 | fhDeltaRhoCMS = new TH1D("fhDeltaRhoCMS","0-100% #delta#rho_{CMS} = #rho_{CMS}^{TPC+EMCal} - #rho_{CMS}^{TPC+Scale}",RhoBins,RhoPtMin,RhoPtMax); |
| 510 | fhDeltaRhoCMS->GetXaxis()->SetTitle("#delta#rho (GeV)"); |
| 511 | fhDeltaRhoCMS->GetYaxis()->SetTitle("Counts"); |
| 512 | fhDeltaRhoCMS->Sumw2(); |
| 513 | |
| c54b626a |
514 | // Jet Area vs pT Distribution |
| 515 | Int_t JetPtAreaBins=200; |
| 516 | Double_t JetPtAreaLow=0.0; |
| 517 | Double_t JetPtAreaUp=2.0; |
| 518 | |
| c6202663 |
519 | Int_t SFBins =100; |
| 520 | Double_t SFLow=0.0; |
| 521 | Double_t SFUp=10.0; |
| 522 | |
| 78246241 |
523 | fhJetPtArea = new TH2D("fhJetPtArea","Jet Area Distribution",JetPtBins, JetPtLow,JetPtUp,JetPtAreaBins,JetPtAreaLow,JetPtAreaUp); |
| ac6a3f1e |
524 | fhJetPtArea->GetXaxis()->SetTitle("p_{T} (GeV/c)"); |
| c54b626a |
525 | fhJetPtArea->GetYaxis()->SetTitle("A_{jet}"); |
| 78246241 |
526 | fhJetPtArea->GetZaxis()->SetTitle("1/N_{Events} dN/dA_{jet}dp_{T}"); |
| ac6a3f1e |
527 | fhJetPtArea->Sumw2(); |
| 528 | |
| c6202663 |
529 | fhRhoScale = new TH2D("fhRhoScale","Scaling Factor",SFBins,SFLow,SFUp,CentralityBinMult*fCentralityBins,fCentralityLow,fCentralityUp); |
| 530 | fhRhoScale->GetXaxis()->SetTitle("Scale Factor"); |
| 531 | fhRhoScale->GetYaxis()->SetTitle("Centrality"); |
| 532 | fhRhoScale->GetZaxis()->SetTitle("Counts"); |
| 533 | fhRhoScale->Sumw2(); |
| ac6a3f1e |
534 | |
| c54b626a |
535 | // Profiles |
| c6202663 |
536 | fpEMCalEventMult = new TProfile("fpEMCalEventMult","EMCal Event Multiplcity vs Centrality",CentralityBinMult*fCentralityBins,fCentralityLow,fCentralityUp); |
| 537 | fpEMCalEventMult->GetXaxis()->SetTitle(fCentralityTag); |
| 538 | fpEMCalEventMult->GetYaxis()->SetTitle("Multiplicity"); |
| ac6a3f1e |
539 | |
| c6202663 |
540 | fpTPCEventMult = new TProfile("fpTPCEventMult","TPC Event Multiplcity vs Centrality",CentralityBinMult*fCentralityBins,fCentralityLow,fCentralityUp); |
| 541 | fpTPCEventMult->GetXaxis()->SetTitle(fCentralityTag); |
| 542 | fpTPCEventMult->GetYaxis()->SetTitle("Multiplicity"); |
| 78246241 |
543 | |
| c54b626a |
544 | fpRhoScale = new TProfile("fpRhoScale","Scaling Factor Profile vs Centrality",CentralityBinMult*fCentralityBins,fCentralityLow,fCentralityUp); |
| c6202663 |
545 | fpRhoScale->GetXaxis()->SetTitle(fCentralityTag); |
| ac6a3f1e |
546 | fpRhoScale->GetYaxis()->SetTitle("Scale Factor"); |
| 78246241 |
547 | |
| c6202663 |
548 | // QA::2D Energy Density Profiles for Tracks and Clusters |
| c54b626a |
549 | fpTrackPtProfile = new TProfile2D("fpTrackPtProfile","2D Profile of track pT density throughout the TPC",TCBins,fTPCEtaMin,fTPCEtaMax,TCBins,fTPCPhiMin,fTPCPhiMax); |
| 550 | fpTrackPtProfile->GetXaxis()->SetTitle("#eta"); |
| 551 | fpTrackPtProfile->GetYaxis()->SetTitle("#phi"); |
| 552 | fpTrackPtProfile->GetZaxis()->SetTitle("p_{T} density (GeV/Area)"); |
| 553 | |
| 554 | fpClusterPtProfile = new TProfile2D("fpClusterPtProfile","2D Profile of cluster pT density throughout the EMCal",TCBins,fEMCalEtaMin,fEMCalEtaMax,TCBins,fEMCalPhiMin,fEMCalPhiMax); |
| 555 | fpClusterPtProfile->GetXaxis()->SetTitle("#eta"); |
| 556 | fpClusterPtProfile->GetYaxis()->SetTitle("#phi"); |
| 557 | fpClusterPtProfile->GetZaxis()->SetTitle("p_{T} density (GeV/Area)"); |
| ac6a3f1e |
558 | |
| 559 | TString temp_name=""; |
| 560 | TString title_name=""; |
| 561 | |
| 562 | fEtaProfileBins=14; |
| 563 | fEtaProfileLow=-0.7; |
| 564 | fEtaProfileUp=0.7; |
| 565 | |
| 566 | for (Int_t i=0;i<14;i++) |
| 567 | { |
| 568 | temp_name=Form("fpJetEtaProfile%d",i); |
| 569 | title_name=Form("Jet Energy Density #eta Profile for ALL p_{T}, 0-20 Centrality, and eta=%g to %g",(i-7)/10.,(i-6)/10.); |
| 570 | |
| 571 | fpJetEtaProfile[i]= new TProfile(temp_name,title_name,fEtaProfileBins,fEtaProfileLow,fEtaProfileUp); |
| 572 | fpJetEtaProfile[i]->GetXaxis()->SetTitle("#eta"); |
| 573 | fpJetEtaProfile[i]->GetYaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 574 | fOutput->Add(fpJetEtaProfile[i]); |
| 575 | temp_name=""; |
| 576 | title_name=""; |
| 577 | |
| 578 | temp_name=Form("fpJetAbsEtaProfile%d",i); |
| 579 | title_name=Form("Jet Energy Density #Delta #eta Profile for ALL p_{T}, 0-20 Centrality, and eta=%g to %g",(i-7)/10.,(i-6)/10.); |
| 580 | |
| 581 | fpJetAbsEtaProfile[i]= new TProfile(temp_name,title_name,fEtaProfileBins,0,2*fEtaProfileUp); |
| 582 | fpJetAbsEtaProfile[i]->GetXaxis()->SetTitle("#Delta#eta"); |
| 583 | fpJetAbsEtaProfile[i]->GetYaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 584 | fOutput->Add(fpJetAbsEtaProfile[i]); |
| 585 | temp_name=""; |
| 586 | title_name=""; |
| 587 | } |
| 588 | |
| 589 | fEDProfileRBins=50; |
| 590 | fEDProfileRLow=0.0; |
| 591 | fEDProfileRUp=0.5; |
| 592 | fEDProfilePtBins=100; |
| 593 | fEDProfilePtLow=0.0; |
| 594 | fEDProfilePtUp=100.0; |
| 595 | fEDProfileEtaBins=4; |
| 596 | fEDProfileEtaLow=-0.2; |
| 597 | fEDProfileEtaUp=0.2; |
| 598 | |
| 599 | for (Int_t i=0;i<8;i++) |
| 600 | { |
| 601 | temp_name=Form("fpChargedJetRProfile%d",i); |
| 602 | title_name=Form("Charged Jet Energy Density Radius Profile for ALL p_{T}, 0-20 Centrality, and eta=%g to %g",(i-4)/10.,(i-3)/10.); |
| 603 | |
| 604 | fpChargedJetRProfile[i]= new TProfile(temp_name,title_name,fEDProfileRBins,fEDProfileRLow,fEDProfileRUp); |
| 605 | fpChargedJetRProfile[i]->GetXaxis()->SetTitle("Radius"); |
| 606 | fpChargedJetRProfile[i]->GetYaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 607 | fOutput->Add(fpChargedJetRProfile[i]); |
| 608 | temp_name=""; |
| 609 | title_name=""; |
| 610 | } |
| 611 | |
| 612 | for (Int_t i=0;i<4;i++) |
| 613 | { |
| 614 | temp_name=Form("fpJetRProfile%d",i); |
| 615 | title_name=Form("Jet Energy Density Radius Profile for ALL p_{T}, 0-20 Centrality, and eta=%g to %g",(i-2)/10.,(i-1)/10.); |
| 616 | |
| 617 | fpJetRProfile[i]= new TProfile(temp_name,title_name,fEDProfileRBins,fEDProfileRLow,fEDProfileRUp); |
| 618 | fpJetRProfile[i]->GetXaxis()->SetTitle("Radius"); |
| 619 | fpJetRProfile[i]->GetYaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 620 | fOutput->Add(fpJetRProfile[i]); |
| 621 | temp_name=""; |
| 622 | title_name=""; |
| 623 | } |
| 624 | |
| 625 | for (Int_t i=0;i<10;i++) |
| 626 | { |
| 627 | temp_name=Form("fpChargedJetEDProfile%d0",i); |
| 628 | title_name=Form("Charged Jet Energy Density Profile for %d0-%d0 Centrality",i,i+1); |
| 629 | |
| 630 | fpChargedJetEDProfile[i]= new TProfile3D(temp_name,title_name,fEDProfilePtBins,fEDProfilePtLow,fEDProfilePtUp,fEDProfileEtaBins+4,fEDProfileEtaLow-0.2,fEDProfileEtaUp+0.2,fEDProfileRBins,fEDProfileRLow,fEDProfileRUp); |
| 631 | fpChargedJetEDProfile[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)"); |
| 632 | fpChargedJetEDProfile[i]->GetYaxis()->SetTitle("Pseudorapidity"); |
| 633 | fpChargedJetEDProfile[i]->GetZaxis()->SetTitle("Radius"); |
| 634 | fOutput->Add(fpChargedJetEDProfile[i]); |
| 635 | temp_name=""; |
| 636 | title_name=""; |
| 637 | |
| 638 | temp_name=Form("fpJetEDProfile%d0",i); |
| 639 | title_name=Form("Jet Energy Density Profile for %d0-%d0 Centrality",i,i+1); |
| 640 | |
| 641 | fpJetEDProfile[i]= new TProfile3D(temp_name,title_name,fEDProfilePtBins,fEDProfilePtLow,fEDProfilePtUp,fEDProfileEtaBins,fEDProfileEtaLow,fEDProfileEtaUp,fEDProfileRBins,fEDProfileRLow,fEDProfileRUp); |
| 642 | fpJetEDProfile[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)"); |
| 643 | fpJetEDProfile[i]->GetYaxis()->SetTitle("Pseudorapidity"); |
| 644 | fpJetEDProfile[i]->GetZaxis()->SetTitle("Radius"); |
| 645 | fOutput->Add(fpJetEDProfile[i]); |
| 646 | temp_name=""; |
| 647 | title_name=""; |
| 648 | } |
| 649 | |
| c6202663 |
650 | fTPCRawJets = new AlipAJetHistos("TPCRawJets",fCentralityTag); |
| 651 | fEMCalRawJets = new AlipAJetHistos("EMCalRawJets",fCentralityTag); |
| 652 | |
| 653 | fRhoFull0 = new AlipAJetHistos("RhoFull0",fCentralityTag); |
| 654 | fRhoFull1 = new AlipAJetHistos("RhoFull1",fCentralityTag); |
| 655 | fRhoFull2 = new AlipAJetHistos("RhoFull2",fCentralityTag); |
| 656 | fRhoFullN = new AlipAJetHistos("RhoFullN",fCentralityTag); |
| 657 | fRhoFullDijet = new AlipAJetHistos("RhoFullDijet",fCentralityTag); |
| 658 | fRhoFullkT = new AlipAJetHistos("RhoFullkT",fCentralityTag); |
| 659 | fRhoFullCMS = new AlipAJetHistos("RhoFullCMS",fCentralityTag); |
| 660 | |
| 661 | fRhoCharged0 = new AlipAJetHistos("RhoCharged0",fCentralityTag); |
| 662 | fRhoCharged1 = new AlipAJetHistos("RhoCharged1",fCentralityTag); |
| 663 | fRhoCharged2 = new AlipAJetHistos("RhoCharged2",fCentralityTag); |
| 664 | fRhoChargedN = new AlipAJetHistos("RhoChargedN",fCentralityTag); |
| 665 | fRhoChargedkT = new AlipAJetHistos("RhoChargedkT",fCentralityTag); |
| 666 | fRhoChargedScale = new AlipAJetHistos("RhoChargedScale",fCentralityTag); |
| 667 | fRhoChargedkTScale = new AlipAJetHistos("RhoChargedkTScale",fCentralityTag); |
| 668 | fRhoChargedCMS = new AlipAJetHistos("RhoChargedCMS",fCentralityTag); |
| 669 | fRhoChargedCMSScale = new AlipAJetHistos("RhoChargedCMSScale",fCentralityTag); |
| 670 | |
| ac6a3f1e |
671 | fOutput->Add(fhTrackPt); |
| 672 | fOutput->Add(fhTrackEta); |
| 673 | fOutput->Add(fhTrackPhi); |
| 674 | fOutput->Add(fhTrackEtaPhi); |
| 675 | fOutput->Add(fhClusterPt); |
| 676 | fOutput->Add(fhClusterEta); |
| 677 | fOutput->Add(fhClusterPhi); |
| 678 | fOutput->Add(fhClusterEtaPhi); |
| c54b626a |
679 | fOutput->Add(fhCentrality); |
| c6202663 |
680 | fOutput->Add(fhEMCalCellCounts); |
| 7acc3e04 |
681 | fOutput->Add(fhDeltaRhoN); |
| 682 | fOutput->Add(fhDeltaRhoCMS); |
| ac6a3f1e |
683 | fOutput->Add(fhJetPtArea); |
| ac6a3f1e |
684 | fOutput->Add(fhJetConstituentPt); |
| c6202663 |
685 | fOutput->Add(fhRhoScale); |
| 78246241 |
686 | |
| c6202663 |
687 | fOutput->Add(fpTPCEventMult); |
| 688 | fOutput->Add(fpEMCalEventMult); |
| 689 | fOutput->Add(fpRhoScale); |
| 690 | |
| ac6a3f1e |
691 | fOutput->Add(fpTrackPtProfile); |
| 692 | fOutput->Add(fpClusterPtProfile); |
| 78246241 |
693 | |
| c6202663 |
694 | fOutput->Add(fTPCRawJets->GetOutputHistos()); |
| 695 | fOutput->Add(fEMCalRawJets->GetOutputHistos()); |
| 696 | |
| 697 | fOutput->Add(fRhoFull0->GetOutputHistos()); |
| 698 | fOutput->Add(fRhoFull1->GetOutputHistos()); |
| 699 | fOutput->Add(fRhoFull2->GetOutputHistos()); |
| 700 | fOutput->Add(fRhoFullN->GetOutputHistos()); |
| 701 | fOutput->Add(fRhoFullDijet->GetOutputHistos()); |
| 702 | fOutput->Add(fRhoFullkT->GetOutputHistos()); |
| 703 | fOutput->Add(fRhoFullCMS->GetOutputHistos()); |
| 704 | fOutput->Add(fRhoCharged0->GetOutputHistos()); |
| 705 | fOutput->Add(fRhoCharged1->GetOutputHistos()); |
| 706 | fOutput->Add(fRhoCharged2->GetOutputHistos()); |
| 707 | fOutput->Add(fRhoChargedN->GetOutputHistos()); |
| 708 | fOutput->Add(fRhoChargedkT->GetOutputHistos()); |
| 709 | fOutput->Add(fRhoChargedScale->GetOutputHistos()); |
| 710 | fOutput->Add(fRhoChargedkTScale->GetOutputHistos()); |
| 711 | fOutput->Add(fRhoChargedCMS->GetOutputHistos()); |
| 712 | fOutput->Add(fRhoChargedCMSScale->GetOutputHistos()); |
| 713 | |
| ac6a3f1e |
714 | // Post data for ALL output slots >0 here, |
| 715 | // To get at least an empty histogram |
| 716 | // 1 is the outputnumber of a certain weg of task 1 |
| 717 | PostData(1, fOutput); |
| 718 | } |
| 719 | |
| 720 | void AliAnalysisTaskFullpAJets::UserExecOnce() |
| 721 | { |
| d812e269 |
722 | // Get the event tracks |
| 723 | fOrgTracks = dynamic_cast <TClonesArray*>(InputEvent()->FindListObject(fTrackName)); |
| ac6a3f1e |
724 | |
| d812e269 |
725 | // Get the event caloclusters |
| 726 | fOrgClusters = dynamic_cast <TClonesArray*>(InputEvent()->FindListObject(fClusName)); |
| ac6a3f1e |
727 | |
| 728 | // Get charged jets |
| d812e269 |
729 | fmyKTChargedJets = dynamic_cast <TClonesArray*>(InputEvent()->FindListObject(fkTChargedName)); |
| 730 | fmyAKTChargedJets = dynamic_cast <TClonesArray*>(InputEvent()->FindListObject(fAkTChargedName)); |
| 78246241 |
731 | |
| ac6a3f1e |
732 | // Get the full jets |
| d812e269 |
733 | fmyKTFullJets = dynamic_cast <TClonesArray*>(InputEvent()->FindListObject(fkTFullName)); |
| 734 | fmyAKTFullJets = dynamic_cast <TClonesArray*>(InputEvent()->FindListObject(fAkTFullName)); |
| 735 | |
| ac6a3f1e |
736 | fIsInitialized=kTRUE; |
| 737 | } |
| 738 | //________________________________________________________________________ |
| 739 | void AliAnalysisTaskFullpAJets::UserExec(Option_t *) |
| 740 | { |
| 741 | if (fIsInitialized==kFALSE) |
| 742 | { |
| 743 | UserExecOnce(); |
| 744 | } |
| 745 | |
| 746 | // Get pointer to reconstructed event |
| 747 | AliVEvent *event = InputEvent(); |
| 748 | if (!event) |
| 749 | { |
| 750 | AliError("Pointer == 0, this can not happen!"); |
| 751 | return; |
| 752 | } |
| 753 | |
| 754 | AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event); |
| 755 | AliAODEvent* aod = dynamic_cast<AliAODEvent*>(event); |
| 756 | |
| 757 | if (esd) |
| 758 | { |
| c6202663 |
759 | fEventCentrality=esd->GetCentrality()->GetCentralityPercentile(fCentralityTag); |
| ac6a3f1e |
760 | |
| 761 | if (esd->GetPrimaryVertex()->GetNContributors()<1 || (TMath::Abs(esd->GetPrimaryVertex()->GetZ())>fVertexWindow)) |
| 762 | { |
| 763 | return; |
| 764 | } |
| 765 | if (TMath::Sqrt(TMath::Power(esd->GetPrimaryVertex()->GetX(),2)+TMath::Power(esd->GetPrimaryVertex()->GetY(),2))>fVertexMaxR) |
| 766 | { |
| 767 | return; |
| 768 | } |
| 769 | |
| 770 | esd->GetPrimaryVertex()->GetXYZ(fvertex); |
| 771 | } |
| 772 | else if (aod) |
| 773 | { |
| c6202663 |
774 | fEventCentrality=aod->GetCentrality()->GetCentralityPercentile(fCentralityTag); |
| ac6a3f1e |
775 | |
| 776 | if (aod->GetPrimaryVertex()->GetNContributors()<1 || (TMath::Abs(aod->GetPrimaryVertex()->GetZ())>fVertexWindow)) |
| 777 | { |
| 778 | return; |
| 779 | } |
| 780 | if (TMath::Sqrt(TMath::Power(aod->GetPrimaryVertex()->GetX(),2)+TMath::Power(aod->GetPrimaryVertex()->GetY(),2))>fVertexMaxR) |
| 781 | { |
| 782 | return; |
| 783 | } |
| 784 | |
| 785 | aod->GetPrimaryVertex()->GetXYZ(fvertex); |
| 786 | } |
| 787 | else |
| 788 | { |
| 789 | AliError("Cannot get AOD/ESD event. Rejecting Event"); |
| 790 | return; |
| 791 | } |
| 792 | |
| 793 | // Make sure Centrality isn't exactly 100% (to avoid bin filling errors in profile plots. Make it 99.99 |
| 794 | if (fEventCentrality>99.99) |
| 795 | { |
| 796 | fEventCentrality=99.99; |
| 797 | } |
| c54b626a |
798 | fhCentrality->Fill(fEventCentrality); |
| ac6a3f1e |
799 | |
| c6202663 |
800 | TrackCuts(); |
| ac6a3f1e |
801 | // Reject any event that doesn't have any tracks, i.e. TPC is off |
| 802 | if (fnTracks<1) |
| 803 | { |
| 804 | AliWarning("No PicoTracks, Rejecting Event"); |
| 805 | return; |
| 806 | } |
| d812e269 |
807 | |
| c6202663 |
808 | ClusterCuts(); |
| ac6a3f1e |
809 | if (fnClusters<1) |
| 810 | { |
| 811 | AliInfo("No Corrected CaloClusters, using only charged jets"); |
| 812 | |
| 813 | TrackHisto(); |
| 814 | InitChargedJets(); |
| c6202663 |
815 | GenerateTPCRandomConesPt(); |
| 816 | |
| 817 | // Rho's |
| 818 | EstimateChargedRho0(); |
| 819 | EstimateChargedRho1(); |
| 820 | EstimateChargedRho2(); |
| 821 | EstimateChargedRhoN(); |
| 822 | EstimateChargedRhokT(); |
| 823 | EstimateChargedRhoCMS(); |
| 824 | |
| ac6a3f1e |
825 | JetPtChargedProfile(); |
| c6202663 |
826 | DeleteJetData(kFALSE); |
| ac6a3f1e |
827 | |
| 828 | fnEventsCharged++; |
| c6202663 |
829 | |
| 830 | PostData(1, fOutput); |
| ac6a3f1e |
831 | return; |
| 832 | } |
| d812e269 |
833 | |
| ac6a3f1e |
834 | TrackHisto(); |
| 835 | ClusterHisto(); |
| 836 | |
| 837 | // Prep the jets |
| 838 | InitChargedJets(); |
| 839 | InitFullJets(); |
| c6202663 |
840 | JetPtArea(); |
| 841 | GenerateTPCRandomConesPt(); |
| 842 | GenerateEMCalRandomConesPt(); |
| 843 | |
| 844 | // Rho's |
| 845 | EstimateChargedRho0(); |
| 846 | EstimateChargedRho1(); |
| 847 | EstimateChargedRho2(); |
| 848 | EstimateChargedRhoN(); |
| 849 | EstimateChargedRhokT(); |
| 850 | EstimateChargedRhoCMS(); |
| 851 | |
| 852 | EstimateFullRho0(); |
| 853 | EstimateFullRho1(); |
| 854 | EstimateFullRho2(); |
| 855 | EstimateFullRhoN(); |
| 856 | EstimateFullRhokT(); |
| 857 | EstimateFullRhoCMS(); |
| 858 | |
| 859 | EstimateChargedRhoScale(); |
| 860 | EstimateChargedRhokTScale(); |
| 861 | EstimateChargedRhoCMSScale(); |
| 862 | |
| 863 | // Dijet |
| ac6a3f1e |
864 | if (IsDiJetEvent()==kTRUE) |
| 865 | { |
| c6202663 |
866 | EstimateFullRhoDijet(); |
| ac6a3f1e |
867 | } |
| 868 | |
| ac6a3f1e |
869 | // Compute Jet Energy Density Profile |
| 870 | JetPtChargedProfile(); |
| 871 | JetPtFullProfile(); |
| 872 | JetPtEtaProfile(); |
| 873 | |
| 7acc3e04 |
874 | // Compute differences between TPC+EMCal Rho to TPC&Scaled Rho |
| 875 | if (fRhoChargedScale->GetRho()>0 && fRhoFullN->GetRho()>0) |
| 876 | { |
| 877 | fhDeltaRhoN->Fill(fRhoFullN->GetRho()-fRhoChargedScale->GetRho()); |
| 878 | } |
| 879 | if (fRhoChargedCMSScale->GetRho()>0 && fRhoFullCMS->GetRho()>0) |
| 880 | { |
| 881 | fhDeltaRhoCMS->Fill(fRhoFullCMS->GetRho()-fRhoChargedCMSScale->GetRho()); |
| 882 | } |
| 883 | |
| ac6a3f1e |
884 | // Delete Dynamic Arrays |
| c6202663 |
885 | DeleteJetData(kTRUE); |
| ac6a3f1e |
886 | fnEvents++; |
| 887 | |
| 888 | PostData(1, fOutput); |
| 889 | } |
| 890 | |
| 891 | //________________________________________________________________________ |
| 892 | void AliAnalysisTaskFullpAJets::Terminate(Option_t *) //specify what you want to have done |
| 893 | { |
| 894 | // Called once at the end of the query. Done nothing here. |
| ac6a3f1e |
895 | } |
| 896 | |
| 897 | ///////////////////////////////////////////////////////////////////////////////////////// |
| 898 | ///////////////// User Defined Sub_Routines /////////////////////////////////////// |
| 899 | ///////////////////////////////////////////////////////////////////////////////////////// |
| 900 | |
| c6202663 |
901 | void AliAnalysisTaskFullpAJets::TrackCuts() |
| 902 | { |
| 903 | // Fill a TObjArray with the tracks from a TClonesArray which grabs the picotracks. |
| 904 | Int_t i; |
| 905 | |
| 906 | fmyTracks = new TObjArray(); |
| 907 | for (i=0;i<fOrgTracks->GetEntries();i++) |
| 908 | { |
| 909 | AliVTrack* vtrack = (AliVTrack*) fOrgTracks->At(i); |
| 910 | if (vtrack->Pt()>=fTrackMinPt) |
| 911 | { |
| 912 | fmyTracks->Add(vtrack); |
| 913 | } |
| 914 | } |
| 915 | fnTracks = fmyTracks->GetEntries(); |
| 916 | } |
| 917 | |
| 918 | void AliAnalysisTaskFullpAJets::ClusterCuts() |
| 919 | { |
| 920 | // Fill a TObjArray with the clusters from a TClonesArray which grabs the caloclusterscorr. |
| 921 | Int_t i; |
| 922 | |
| 923 | fmyClusters = new TObjArray(); |
| 924 | if(fOrgClusters) { |
| 925 | for (i=0;i<fOrgClusters->GetEntries();i++) |
| 926 | { |
| 927 | AliVCluster* vcluster = (AliVCluster*) fOrgClusters->At(i); |
| 928 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 929 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 930 | |
| 931 | if (cluster_vec->Pt()>=fClusterMinPt) |
| 932 | { |
| 933 | fmyClusters->Add(vcluster); |
| 934 | } |
| 935 | delete cluster_vec; |
| 936 | |
| 937 | } |
| 938 | } |
| 939 | fnClusters = fmyClusters->GetEntries(); |
| 940 | } |
| 941 | |
| ac6a3f1e |
942 | void AliAnalysisTaskFullpAJets::TrackHisto() |
| 943 | { |
| 944 | // Fill track histograms: Phi,Eta,Pt |
| 945 | Int_t i,j; |
| 946 | Int_t TCBins=100; |
| 947 | TH2D *hdummypT= new TH2D("hdummypT","",TCBins,fTPCEtaMin,fTPCEtaMax,TCBins,fTPCPhiMin,fTPCPhiMax); //! |
| 948 | |
| 949 | for (i=0;i<fnTracks;i++) |
| 950 | { |
| 951 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 952 | fhTrackPt->Fill(vtrack->Pt()); |
| 953 | fhTrackEta->Fill(vtrack->Eta()); |
| 954 | fhTrackPhi->Fill(vtrack->Phi()); |
| 955 | fhTrackEtaPhi->Fill(vtrack->Eta(),vtrack->Phi()); |
| 956 | hdummypT->Fill(vtrack->Eta(),vtrack->Phi(),vtrack->Pt()); |
| 957 | } |
| 958 | for (i=1;i<=TCBins;i++) |
| 959 | { |
| 960 | for (j=1;j<=TCBins;j++) |
| 961 | { |
| 962 | fpTrackPtProfile->Fill(hdummypT->GetXaxis()->GetBinCenter(i),hdummypT->GetYaxis()->GetBinCenter(j),fTPCArea*TMath::Power(TCBins,-2)*hdummypT->GetBinContent(i,j)); |
| 963 | } |
| 964 | } |
| 965 | delete hdummypT; |
| 966 | } |
| 967 | |
| 968 | void AliAnalysisTaskFullpAJets::ClusterHisto() |
| 969 | { |
| 970 | // Fill cluster histograms: Phi,Eta,Pt |
| 971 | Int_t i,j; |
| 972 | Int_t TCBins=100; |
| 973 | TH2D *hdummypT= new TH2D("hdummypT","",TCBins,fEMCalEtaMin,fEMCalEtaMax,TCBins,fEMCalPhiMin,fEMCalPhiMax); //! |
| 974 | AliEMCALGeometry *myAliEMCGeo = AliEMCALGeometry::GetInstance(); |
| 975 | Int_t myCellID=-2; |
| 976 | |
| 977 | for (i=0;i<fnClusters;i++) |
| 978 | { |
| 979 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 980 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 981 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 982 | |
| 983 | fhClusterPt->Fill(cluster_vec->Pt()); |
| 984 | fhClusterEta->Fill(cluster_vec->Eta()); |
| 985 | fhClusterPhi->Fill(cluster_vec->Phi()); |
| 986 | fhClusterEtaPhi->Fill(cluster_vec->Eta(),cluster_vec->Phi()); |
| 987 | hdummypT->Fill(cluster_vec->Eta(),cluster_vec->Phi(),cluster_vec->Pt()); |
| 988 | myAliEMCGeo->GetAbsCellIdFromEtaPhi(cluster_vec->Eta(),cluster_vec->Phi(),myCellID); |
| 989 | fhEMCalCellCounts->Fill(myCellID); |
| ac6a3f1e |
990 | delete cluster_vec; |
| 991 | } |
| 992 | for (i=1;i<=TCBins;i++) |
| 993 | { |
| 994 | for (j=1;j<=TCBins;j++) |
| 995 | { |
| 996 | fpClusterPtProfile->Fill(hdummypT->GetXaxis()->GetBinCenter(i),hdummypT->GetYaxis()->GetBinCenter(j),fEMCalArea*TMath::Power(TCBins,-2)*hdummypT->GetBinContent(i,j)); |
| 997 | } |
| 998 | } |
| ac6a3f1e |
999 | delete hdummypT; |
| 1000 | } |
| 1001 | |
| c6202663 |
1002 | void AliAnalysisTaskFullpAJets::InitChargedJets() |
| 1003 | { |
| 1004 | // Preliminary Jet Placement and Selection Cuts |
| 1005 | Int_t i; |
| 1006 | |
| 1007 | fnAKTChargedJets = fmyAKTChargedJets->GetEntries(); |
| 1008 | fnKTChargedJets = fmyKTChargedJets->GetEntries(); |
| 1009 | |
| 1010 | fTPCJet = new AlipAJetData("fTPCJet",kFALSE,fnAKTChargedJets); |
| 1011 | fTPCFullJet = new AlipAJetData("fTPCFullJet",kFALSE,fnAKTChargedJets); |
| 1012 | fTPCOnlyJet = new AlipAJetData("fTPCOnlyJet",kFALSE,fnAKTChargedJets); |
| 1013 | |
| 1014 | fTPCJet->SetSignalCut(fTPCJetThreshold); |
| 1015 | fTPCJet->SetAreaCutFraction(fJetAreaCutFrac); |
| 1016 | fTPCJet->SetJetR(fJetR); |
| 1017 | fTPCFullJet->SetSignalCut(fTPCJetThreshold); |
| 1018 | fTPCFullJet->SetAreaCutFraction(fJetAreaCutFrac); |
| 1019 | fTPCFullJet->SetJetR(fJetR); |
| 1020 | fTPCOnlyJet->SetSignalCut(fTPCJetThreshold); |
| 1021 | fTPCOnlyJet->SetAreaCutFraction(fJetAreaCutFrac); |
| 1022 | fTPCOnlyJet->SetJetR(fJetR); |
| 1023 | |
| 1024 | // Initialize Jet Data |
| 1025 | for (i=0;i<fnAKTChargedJets;i++) |
| 1026 | { |
| 1027 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTChargedJets->At(i); |
| 1028 | |
| 1029 | fTPCJet->SetIsJetInArray(IsInTPC(fJetR,myJet->Phi(),myJet->Eta(),kFALSE),i); |
| 1030 | fTPCFullJet->SetIsJetInArray(IsInTPC(fJetR,myJet->Phi(),myJet->Eta(),kTRUE),i); |
| 1031 | fTPCOnlyJet->SetIsJetInArray(IsInTPCFull(fJetR,myJet->Phi(),myJet->Eta()),i); |
| 1032 | } |
| 1033 | fTPCJet->InitializeJetData(fmyAKTChargedJets,fnAKTChargedJets); |
| 1034 | fTPCFullJet->InitializeJetData(fmyAKTChargedJets,fnAKTChargedJets); |
| 1035 | fTPCOnlyJet->InitializeJetData(fmyAKTChargedJets,fnAKTChargedJets); |
| 1036 | |
| 1037 | // kT Jets |
| 1038 | fTPCkTFullJet = new AlipAJetData("fTPCkTFullJet",kFALSE,fnKTChargedJets); |
| 1039 | fTPCkTFullJet->SetSignalCut(fTPCJetThreshold); |
| 1040 | fTPCkTFullJet->SetAreaCutFraction(0.25*fJetAreaCutFrac); |
| 1041 | fTPCkTFullJet->SetJetR(fJetR); |
| 1042 | |
| 1043 | for (i=0;i<fnKTChargedJets;i++) |
| 1044 | { |
| 1045 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTChargedJets->At(i); |
| 1046 | fTPCkTFullJet->SetIsJetInArray(IsInTPC(fJetR,myJet->Phi(),myJet->Eta(),kTRUE),i); |
| 1047 | } |
| 1048 | fTPCkTFullJet->InitializeJetData(fmyKTChargedJets,fnKTChargedJets); |
| 1049 | |
| 1050 | // Raw Charged Jet Spectra |
| 1051 | fTPCRawJets->FillBSJS(fEventCentrality,0.0,fTPCJetThreshold,fmyAKTChargedJets,fTPCFullJet->GetJets(),fTPCFullJet->GetTotalJets()); |
| 1052 | } |
| 1053 | |
| 1054 | void AliAnalysisTaskFullpAJets::InitFullJets() |
| 1055 | { |
| 1056 | // Preliminary Jet Placement and Selection Cuts |
| 1057 | Int_t i; |
| 1058 | |
| 1059 | fnAKTFullJets = fmyAKTFullJets->GetEntries(); |
| 1060 | fnKTFullJets = fmyKTFullJets->GetEntries(); |
| 1061 | |
| 1062 | fEMCalJet = new AlipAJetData("fEMCalJet",kTRUE,fnAKTFullJets); |
| 1063 | fEMCalFullJet = new AlipAJetData("fEMCalFullJet",kTRUE,fnAKTFullJets); |
| 1064 | fEMCalPartJet = new AlipAJetData("fEMCalPartJet",kTRUE,fnAKTFullJets); |
| 1065 | |
| 1066 | fEMCalJet->SetSignalCut(fEMCalJetThreshold); |
| 1067 | fEMCalJet->SetAreaCutFraction(fJetAreaCutFrac); |
| 1068 | fEMCalJet->SetJetR(fJetR); |
| 1069 | fEMCalFullJet->SetSignalCut(fEMCalJetThreshold); |
| 1070 | fEMCalFullJet->SetAreaCutFraction(fJetAreaCutFrac); |
| 1071 | fEMCalFullJet->SetJetR(fJetR); |
| 1072 | fEMCalPartJet->SetSignalCut(fEMCalJetThreshold); |
| 1073 | fEMCalPartJet->SetAreaCutFraction(fJetAreaCutFrac); |
| 1074 | fEMCalPartJet->SetJetR(fJetR); |
| 1075 | |
| 1076 | // Initialize Jet Data |
| 1077 | for (i=0;i<fnAKTFullJets;i++) |
| 1078 | { |
| 1079 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTFullJets->At(i); |
| 1080 | |
| 1081 | fEMCalJet->SetIsJetInArray(IsInEMCal(myJet->Phi(),myJet->Eta()),i); |
| 1082 | fEMCalFullJet->SetIsJetInArray(IsInEMCalFull(fJetR,myJet->Phi(),myJet->Eta()),i); |
| 1083 | fEMCalPartJet->SetIsJetInArray(IsInEMCalPart(fJetR,myJet->Phi(),myJet->Eta()),i); |
| 1084 | } |
| 1085 | fEMCalJet->InitializeJetData(fmyAKTFullJets,fnAKTFullJets); |
| 1086 | fEMCalFullJet->InitializeJetData(fmyAKTFullJets,fnAKTFullJets); |
| 1087 | fEMCalPartJet->InitializeJetData(fmyAKTFullJets,fnAKTFullJets); |
| 1088 | |
| 1089 | // kT Jets |
| 1090 | fEMCalkTFullJet = new AlipAJetData("fEMCalkTFullJet",kTRUE,fnKTFullJets); |
| 1091 | fEMCalkTFullJet->SetSignalCut(fEMCalJetThreshold); |
| 1092 | fEMCalkTFullJet->SetAreaCutFraction(0.25*fJetAreaCutFrac); |
| 1093 | fEMCalkTFullJet->SetJetR(fJetR); |
| 1094 | |
| 1095 | for (i=0;i<fnKTFullJets;i++) |
| 1096 | { |
| 1097 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTFullJets->At(i); |
| 1098 | fEMCalkTFullJet->SetIsJetInArray(IsInEMCalFull(fJetR,myJet->Phi(),myJet->Eta()),i); |
| 1099 | } |
| 1100 | fEMCalkTFullJet->InitializeJetData(fmyKTFullJets,fnKTFullJets); |
| 1101 | |
| 1102 | // Raw Full Jet Spectra |
| 1103 | fEMCalRawJets->FillBSJS(fEventCentrality,0.0,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 1104 | } |
| 1105 | |
| 1106 | void AliAnalysisTaskFullpAJets::JetPtArea() |
| 1107 | { |
| 1108 | Int_t i; |
| 1109 | |
| 1110 | for (i=0;i<fEMCalFullJet->GetTotalJets();i++) |
| 1111 | { |
| 1112 | AliEmcalJet *myJet = (AliEmcalJet*) fmyAKTFullJets->At(fEMCalFullJet->GetJetIndex(i)); |
| 1113 | fhJetPtArea->Fill(myJet->Pt(),myJet->Area()); |
| 1114 | } |
| 1115 | } |
| 1116 | |
| 1117 | void AliAnalysisTaskFullpAJets::GenerateTPCRandomConesPt() |
| ac6a3f1e |
1118 | { |
| 1119 | Int_t i,j; |
| 1120 | Double_t E_tracks_total=0.; |
| ac6a3f1e |
1121 | TRandom3 u(time(NULL)); |
| 1122 | |
| c6202663 |
1123 | Double_t Eta_Center=0.5*(fTPCEtaMin+fTPCEtaMax); |
| 1124 | Double_t Phi_Center=0.5*(fTPCPhiMin+fTPCPhiMax); |
| ac6a3f1e |
1125 | Int_t event_mult=0; |
| 1126 | Int_t clus_mult=0; |
| 1127 | |
| c6202663 |
1128 | for (i=0;i<fnBckgClusters;i++) |
| 1129 | { |
| 1130 | fTPCRCBckgFluc[i]=0.0; |
| 1131 | fTPCRCBckgFlucSignal[i]=0.0; |
| 7acc3e04 |
1132 | fTPCRCBckgFlucNColl[i]=0.0; |
| c6202663 |
1133 | } |
| 1134 | |
| ac6a3f1e |
1135 | TLorentzVector *dummy= new TLorentzVector; |
| c6202663 |
1136 | TLorentzVector *temp_jet= new TLorentzVector; |
| ac6a3f1e |
1137 | |
| c6202663 |
1138 | // First, consider the RC with no spatial restrictions |
| ac6a3f1e |
1139 | for (j=0;j<fnBckgClusters;j++) |
| 1140 | { |
| ac6a3f1e |
1141 | E_tracks_total=0.; |
| ac6a3f1e |
1142 | |
| c6202663 |
1143 | dummy->SetPtEtaPhiE(1,u.Uniform(Eta_Center-fJetR,Eta_Center+fJetR),u.Uniform(Phi_Center-fJetR,Phi_Center+fJetR),0); |
| ac6a3f1e |
1144 | // Loop over all tracks |
| 1145 | for (i=0;i<fnTracks;i++) |
| 1146 | { |
| 1147 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| c6202663 |
1148 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| ac6a3f1e |
1149 | { |
| ac6a3f1e |
1150 | TLorentzVector *track_vec = new TLorentzVector; |
| 1151 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 1152 | if (dummy->DeltaR(*track_vec)<fJetR) |
| 1153 | { |
| ac6a3f1e |
1154 | E_tracks_total+=vtrack->Pt(); |
| 1155 | } |
| 1156 | delete track_vec; |
| 1157 | } |
| 1158 | } |
| c6202663 |
1159 | fTPCRCBckgFlucSignal[j]=E_tracks_total; |
| 1160 | } |
| 1161 | |
| 1162 | // Now, consider the RC where the vertex of RC is at least 2R away from the leading signal |
| 1163 | E_tracks_total=0.0; |
| 1164 | if (fTPCJet->GetLeadingPt()<0.0) |
| 1165 | { |
| 1166 | temp_jet->SetPtEtaPhiE(1,u.Uniform(Eta_Center-fJetR,Eta_Center+fJetR),u.Uniform(Phi_Center-fJetR,Phi_Center+fJetR),0); |
| 1167 | } |
| 1168 | else |
| 1169 | { |
| 1170 | AliEmcalJet *myJet = (AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetLeadingIndex()); |
| 1171 | myJet->GetMom(*temp_jet); |
| 1172 | } |
| 1173 | |
| 1174 | for (j=0;j<fnBckgClusters;j++) |
| 1175 | { |
| 1176 | event_mult=0; |
| 1177 | clus_mult=0; |
| 1178 | E_tracks_total=0.; |
| ac6a3f1e |
1179 | |
| c6202663 |
1180 | dummy->SetPtEtaPhiE(1,u.Uniform(Eta_Center-fJetR,Eta_Center+fJetR),u.Uniform(Phi_Center-fJetR,Phi_Center+fJetR),0); |
| 1181 | while (temp_jet->DeltaR(*dummy)<fJetR) |
| ac6a3f1e |
1182 | { |
| c6202663 |
1183 | dummy->SetPtEtaPhiE(1,u.Uniform(Eta_Center-fJetR,Eta_Center+fJetR),u.Uniform(Phi_Center-fJetR,Phi_Center+fJetR),0); |
| ac6a3f1e |
1184 | } |
| c6202663 |
1185 | // Loop over all tracks |
| 1186 | for (i=0;i<fnTracks;i++) |
| ac6a3f1e |
1187 | { |
| c6202663 |
1188 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 1189 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| 1190 | { |
| 1191 | event_mult++; |
| 1192 | TLorentzVector *track_vec = new TLorentzVector; |
| 1193 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 1194 | if (dummy->DeltaR(*track_vec)<fJetR) |
| 1195 | { |
| 1196 | clus_mult++; |
| 1197 | E_tracks_total+=vtrack->Pt(); |
| 1198 | } |
| 1199 | delete track_vec; |
| 1200 | } |
| ac6a3f1e |
1201 | } |
| c6202663 |
1202 | fTPCRCBckgFluc[j]=E_tracks_total; |
| ac6a3f1e |
1203 | } |
| c6202663 |
1204 | fpTPCEventMult->Fill(fEventCentrality,event_mult); |
| 1205 | fTPCRawJets->FillDeltaPt(fEventCentrality,0.0,fJetR,fTPCRCBckgFluc,1); |
| ac6a3f1e |
1206 | |
| 7acc3e04 |
1207 | // For the case of partial exclusion, merely allow a superposition of full and no exclusion with probability p=1/Ncoll |
| 1208 | Double_t exclusion_prob; |
| 1209 | for (j=0;j<fnBckgClusters;j++) |
| 1210 | { |
| 1211 | exclusion_prob = u.Uniform(0,1); |
| 1212 | if (exclusion_prob<(1/fNColl)) |
| 1213 | { |
| 1214 | fTPCRCBckgFlucNColl[j]=fTPCRCBckgFlucSignal[j]; |
| 1215 | } |
| 1216 | else |
| 1217 | { |
| 1218 | fTPCRCBckgFlucNColl[j]=fTPCRCBckgFluc[j]; |
| 1219 | } |
| 1220 | } |
| 1221 | |
| ac6a3f1e |
1222 | delete dummy; |
| c6202663 |
1223 | delete temp_jet; |
| ac6a3f1e |
1224 | } |
| 1225 | |
| c6202663 |
1226 | void AliAnalysisTaskFullpAJets::GenerateEMCalRandomConesPt() |
| ac6a3f1e |
1227 | { |
| 78246241 |
1228 | Int_t i,j; |
| c6202663 |
1229 | Double_t E_tracks_total=0.; |
| 1230 | Double_t E_caloclusters_total=0.; |
| 1231 | TRandom3 u(time(NULL)); |
| ac6a3f1e |
1232 | |
| c6202663 |
1233 | Double_t Eta_Center=0.5*(fEMCalEtaMin+fEMCalEtaMax); |
| 1234 | Double_t Phi_Center=0.5*(fEMCalPhiMin+fEMCalPhiMax); |
| 1235 | Int_t event_mult=0; |
| 1236 | Int_t clus_mult=0; |
| ac6a3f1e |
1237 | |
| c6202663 |
1238 | for (i=0;i<fnBckgClusters;i++) |
| ac6a3f1e |
1239 | { |
| c6202663 |
1240 | fEMCalRCBckgFluc[i]=0.0; |
| 1241 | fEMCalRCBckgFlucSignal[i]=0.0; |
| 7acc3e04 |
1242 | fEMCalRCBckgFlucNColl[i]=0.0; |
| ac6a3f1e |
1243 | } |
| 78246241 |
1244 | |
| c6202663 |
1245 | TLorentzVector *dummy= new TLorentzVector; |
| 1246 | TLorentzVector *temp_jet= new TLorentzVector; |
| 1247 | |
| 1248 | // First, consider the RC with no spatial restrictions |
| 1249 | for (j=0;j<fnBckgClusters;j++) |
| 78246241 |
1250 | { |
| c6202663 |
1251 | E_tracks_total=0.; |
| 1252 | E_caloclusters_total=0.; |
| 1253 | |
| 1254 | dummy->SetPtEtaPhiE(1,u.Uniform(Eta_Center-fJetR,Eta_Center+fJetR),u.Uniform(Phi_Center-fJetR,Phi_Center+fJetR),0); |
| 1255 | // Loop over all tracks |
| 1256 | for (i=0;i<fnTracks;i++) |
| 78246241 |
1257 | { |
| c6202663 |
1258 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 1259 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 78246241 |
1260 | { |
| c6202663 |
1261 | TLorentzVector *track_vec = new TLorentzVector; |
| 1262 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 1263 | if (dummy->DeltaR(*track_vec)<fJetR) |
| 78246241 |
1264 | { |
| c6202663 |
1265 | E_tracks_total+=vtrack->Pt(); |
| 78246241 |
1266 | } |
| c6202663 |
1267 | delete track_vec; |
| 78246241 |
1268 | } |
| 1269 | } |
| 78246241 |
1270 | |
| c6202663 |
1271 | // Loop over all caloclusters |
| 1272 | for (i=0;i<fnClusters;i++) |
| 78246241 |
1273 | { |
| c6202663 |
1274 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 1275 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 1276 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 1277 | if (dummy->DeltaR(*cluster_vec)<fJetR) |
| 1278 | { |
| 1279 | clus_mult++; |
| 1280 | E_caloclusters_total+=vcluster->E(); |
| 1281 | } |
| 1282 | delete cluster_vec; |
| 78246241 |
1283 | } |
| c6202663 |
1284 | fEMCalRCBckgFlucSignal[j]=E_tracks_total+E_caloclusters_total; |
| 78246241 |
1285 | } |
| c6202663 |
1286 | |
| 1287 | // Now, consider the RC where the vertex of RC is at least 2R away from the leading signal |
| 1288 | E_tracks_total=0.; |
| 1289 | E_caloclusters_total=0.; |
| 1290 | if (fEMCalPartJet->GetLeadingPt()<0.0) |
| 78246241 |
1291 | { |
| c6202663 |
1292 | temp_jet->SetPtEtaPhiE(1,u.Uniform(Eta_Center-fJetR,Eta_Center+fJetR),u.Uniform(Phi_Center-fJetR,Phi_Center+fJetR),0); |
| 78246241 |
1293 | } |
| c6202663 |
1294 | else |
| 78246241 |
1295 | { |
| c6202663 |
1296 | AliEmcalJet *myJet = (AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetLeadingIndex()); |
| 1297 | myJet->GetMom(*temp_jet); |
| 78246241 |
1298 | } |
| 1299 | |
| c6202663 |
1300 | for (j=0;j<fnBckgClusters;j++) |
| 78246241 |
1301 | { |
| c6202663 |
1302 | event_mult=0; |
| 1303 | clus_mult=0; |
| 1304 | E_tracks_total=0.; |
| 1305 | E_caloclusters_total=0.; |
| 1306 | |
| 1307 | dummy->SetPtEtaPhiE(1,u.Uniform(Eta_Center-fJetR,Eta_Center+fJetR),u.Uniform(Phi_Center-fJetR,Phi_Center+fJetR),0); |
| 1308 | while (temp_jet->DeltaR(*dummy)<fJetR) |
| 1309 | { |
| 1310 | dummy->SetPtEtaPhiE(1,u.Uniform(Eta_Center-fJetR,Eta_Center+fJetR),u.Uniform(Phi_Center-fJetR,Phi_Center+fJetR),0); |
| 1311 | } |
| 1312 | // Loop over all tracks |
| 1313 | for (i=0;i<fnTracks;i++) |
| 1314 | { |
| 1315 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 1316 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 1317 | { |
| 1318 | event_mult++; |
| 1319 | TLorentzVector *track_vec = new TLorentzVector; |
| 1320 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 1321 | if (dummy->DeltaR(*track_vec)<fJetR) |
| 1322 | { |
| 1323 | clus_mult++; |
| 1324 | E_tracks_total+=vtrack->Pt(); |
| 1325 | } |
| 1326 | delete track_vec; |
| 1327 | } |
| 1328 | } |
| 1329 | |
| 1330 | // Loop over all caloclusters |
| 1331 | for (i=0;i<fnClusters;i++) |
| 1332 | { |
| 1333 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 1334 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 1335 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 1336 | event_mult++; |
| 1337 | if (dummy->DeltaR(*cluster_vec)<fJetR) |
| 1338 | { |
| 1339 | clus_mult++; |
| 1340 | E_caloclusters_total+=vcluster->E(); |
| 1341 | } |
| 1342 | delete cluster_vec; |
| 1343 | } |
| 1344 | fEMCalRCBckgFluc[j]=E_tracks_total+E_caloclusters_total; |
| 78246241 |
1345 | } |
| c6202663 |
1346 | fpEMCalEventMult->Fill(fEventCentrality,event_mult); |
| 1347 | fEMCalRawJets->FillDeltaPt(fEventCentrality,0.0,fJetR,fEMCalRCBckgFluc,1); |
| 1348 | |
| 7acc3e04 |
1349 | // For the case of partial exclusion, merely allow a superposition of full and no exclusion with probability p=1/Ncoll |
| 1350 | Double_t exclusion_prob; |
| 1351 | for (j=0;j<fnBckgClusters;j++) |
| 1352 | { |
| 1353 | exclusion_prob = u.Uniform(0,1); |
| 1354 | if (exclusion_prob<(1/fNColl)) |
| 1355 | { |
| 1356 | fEMCalRCBckgFlucNColl[j]=fEMCalRCBckgFlucSignal[j]; |
| 1357 | } |
| 1358 | else |
| 1359 | { |
| 1360 | fEMCalRCBckgFlucNColl[j]=fEMCalRCBckgFluc[j]; |
| 1361 | } |
| 1362 | } |
| 1363 | |
| c6202663 |
1364 | delete dummy; |
| 1365 | delete temp_jet; |
| ac6a3f1e |
1366 | } |
| 1367 | |
| c6202663 |
1368 | // Charged Rho's |
| 1369 | void AliAnalysisTaskFullpAJets::EstimateChargedRho0() |
| ac6a3f1e |
1370 | { |
| ac6a3f1e |
1371 | Int_t i; |
| c6202663 |
1372 | Double_t E_tracks_total=0.0; |
| 1373 | Double_t TPC_rho=0.; |
| ac6a3f1e |
1374 | |
| c6202663 |
1375 | // Loop over all tracks |
| 1376 | for (i=0;i<fnTracks;i++) |
| 1377 | { |
| 1378 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 1379 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| 1380 | { |
| 1381 | E_tracks_total+=vtrack->Pt(); |
| 1382 | } |
| 1383 | } |
| ac6a3f1e |
1384 | |
| c6202663 |
1385 | // Calculate the mean Background density |
| 1386 | TPC_rho=E_tracks_total/fTPCArea; |
| 1387 | fRhoCharged=TPC_rho; |
| ac6a3f1e |
1388 | |
| c6202663 |
1389 | // Fill Histograms |
| 1390 | fRhoCharged0->FillRho(fEventCentrality,TPC_rho); |
| 1391 | fRhoCharged0->FillBSJS(fEventCentrality,TPC_rho,fTPCJetThreshold,fmyAKTChargedJets,fTPCJet->GetJets(),fTPCJet->GetTotalJets()); |
| 1392 | fRhoCharged0->FillDeltaPt(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFluc,1); |
| 1393 | fRhoCharged0->FillDeltaPtSignal(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFlucSignal,1); |
| 7acc3e04 |
1394 | fRhoCharged0->FillDeltaPtNColl(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFlucNColl,1); |
| c6202663 |
1395 | fRhoCharged0->FillBackgroundFluctuations(fEventCentrality,TPC_rho,fJetR); |
| 1396 | fRhoCharged0->FillLeadingJetPtRho(fTPCJet->GetLeadingPt(),TPC_rho); |
| ac6a3f1e |
1397 | |
| c6202663 |
1398 | } |
| ac6a3f1e |
1399 | |
| c6202663 |
1400 | void AliAnalysisTaskFullpAJets::EstimateChargedRho1() |
| 1401 | { |
| 1402 | Int_t i; |
| 1403 | Double_t E_tracks_total=0.0; |
| 1404 | Double_t TPC_rho=0.; |
| 1405 | |
| 1406 | if (fTPCJet->GetLeadingPt()>=fTPCJetThreshold) |
| ac6a3f1e |
1407 | { |
| c6202663 |
1408 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetLeadingIndex()); |
| 1409 | TLorentzVector *temp_jet= new TLorentzVector; |
| 1410 | myJet->GetMom(*temp_jet); |
| ac6a3f1e |
1411 | |
| c6202663 |
1412 | // Loop over all tracks |
| 1413 | for (i=0;i<fnTracks;i++) |
| 1414 | { |
| 1415 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 1416 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| 1417 | { |
| 1418 | TLorentzVector *track_vec = new TLorentzVector; |
| 1419 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 1420 | if (temp_jet->DeltaR(*track_vec)>fJetRForRho) |
| 1421 | { |
| 1422 | E_tracks_total+=vtrack->Pt(); |
| 1423 | } |
| 1424 | delete track_vec; |
| 1425 | } |
| 1426 | } |
| 1427 | delete temp_jet; |
| ac6a3f1e |
1428 | |
| c6202663 |
1429 | // Calculate the mean Background density |
| 1430 | TPC_rho=E_tracks_total/(fTPCArea-AreaWithinTPC(fJetR,myJet->Eta())); |
| 1431 | } |
| 1432 | else // i.e. No signal jets -> same as total background density |
| 1433 | { |
| 1434 | // Loop over all tracks |
| 1435 | for (i=0;i<fnTracks;i++) |
| ac6a3f1e |
1436 | { |
| c6202663 |
1437 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 1438 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| ac6a3f1e |
1439 | { |
| c6202663 |
1440 | E_tracks_total+=vtrack->Pt(); |
| ac6a3f1e |
1441 | } |
| c6202663 |
1442 | } |
| 1443 | // Calculate the mean Background density |
| 1444 | TPC_rho=E_tracks_total/fTPCArea; |
| 1445 | } |
| 1446 | |
| 1447 | // Fill histograms |
| 1448 | fRhoCharged1->FillRho(fEventCentrality,TPC_rho); |
| 1449 | fRhoCharged1->FillBSJS(fEventCentrality,TPC_rho,fTPCJetThreshold,fmyAKTChargedJets,fTPCFullJet->GetJets(),fTPCFullJet->GetTotalJets()); |
| 1450 | fRhoCharged1->FillDeltaPt(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFluc,1); |
| 1451 | fRhoCharged1->FillDeltaPtSignal(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFlucSignal,1); |
| 7acc3e04 |
1452 | fRhoCharged1->FillDeltaPtNColl(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFlucNColl,1); |
| c6202663 |
1453 | fRhoCharged1->FillBackgroundFluctuations(fEventCentrality,TPC_rho,fJetR); |
| 1454 | fRhoCharged1->FillLeadingJetPtRho(fTPCFullJet->GetLeadingPt(),TPC_rho); |
| 1455 | } |
| 1456 | |
| 1457 | void AliAnalysisTaskFullpAJets::EstimateChargedRho2() |
| 1458 | { |
| 1459 | Int_t i; |
| 1460 | Double_t E_tracks_total=0.0; |
| 1461 | Double_t TPC_rho=0.; |
| 1462 | |
| 1463 | if ((fTPCJet->GetLeadingPt()>=fTPCJetThreshold) && (fTPCJet->GetSubLeadingPt()>=fTPCJetThreshold)) |
| 1464 | { |
| 1465 | AliEmcalJet *myhJet =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetLeadingIndex()); |
| 1466 | TLorentzVector *temp_jet1= new TLorentzVector; |
| 1467 | myhJet->GetMom(*temp_jet1); |
| 1468 | |
| 1469 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetSubLeadingIndex()); |
| 1470 | TLorentzVector *temp_jet2= new TLorentzVector; |
| 1471 | myJet->GetMom(*temp_jet2); |
| 1472 | |
| 1473 | // Loop over all tracks |
| 1474 | for (i=0;i<fnTracks;i++) |
| 1475 | { |
| 1476 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 1477 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| ac6a3f1e |
1478 | { |
| c6202663 |
1479 | TLorentzVector *track_vec = new TLorentzVector; |
| 1480 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 1481 | if ((temp_jet1->DeltaR(*track_vec)>fJetRForRho) && (temp_jet2->DeltaR(*track_vec)>fJetRForRho)) |
| c54b626a |
1482 | { |
| c6202663 |
1483 | E_tracks_total+=vtrack->Pt(); |
| c54b626a |
1484 | } |
| c6202663 |
1485 | delete track_vec; |
| 1486 | } |
| 1487 | } |
| 1488 | delete temp_jet1; |
| 1489 | delete temp_jet2; |
| 1490 | |
| 1491 | // Calculate the mean Background density |
| 1492 | TPC_rho=E_tracks_total/(fTPCArea-AreaWithinTPC(fJetR,myhJet->Eta())-AreaWithinTPC(fJetR,myJet->Eta())); |
| 1493 | } |
| 1494 | else if (fTPCJet->GetLeadingPt()>=fTPCJetThreshold) |
| 1495 | { |
| 1496 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetLeadingIndex()); |
| 1497 | TLorentzVector *temp_jet= new TLorentzVector; |
| 1498 | myJet->GetMom(*temp_jet); |
| 1499 | |
| 1500 | // Loop over all tracks |
| 1501 | for (i=0;i<fnTracks;i++) |
| 1502 | { |
| 1503 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 1504 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| 1505 | { |
| 1506 | TLorentzVector *track_vec = new TLorentzVector; |
| 1507 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 1508 | if (temp_jet->DeltaR(*track_vec)>fJetRForRho) |
| ac6a3f1e |
1509 | { |
| c6202663 |
1510 | E_tracks_total+=vtrack->Pt(); |
| ac6a3f1e |
1511 | } |
| c6202663 |
1512 | delete track_vec; |
| 1513 | } |
| 1514 | } |
| 1515 | delete temp_jet; |
| 1516 | |
| 1517 | // Calculate the mean Background density |
| 1518 | TPC_rho=E_tracks_total/(fTPCArea-AreaWithinTPC(fJetR,myJet->Eta())); |
| 1519 | } |
| 1520 | else // i.e. No signal jets -> same as total background density |
| 1521 | { |
| 1522 | // Loop over all tracks |
| 1523 | for (i=0;i<fnTracks;i++) |
| 1524 | { |
| 1525 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 1526 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| 1527 | { |
| 1528 | E_tracks_total+=vtrack->Pt(); |
| 1529 | } |
| 1530 | } |
| 1531 | |
| 1532 | // Calculate the mean Background density |
| 1533 | TPC_rho=E_tracks_total/fTPCArea; |
| 1534 | } |
| 1535 | |
| 1536 | // Fill histograms |
| 1537 | fRhoCharged2->FillRho(fEventCentrality,TPC_rho); |
| 1538 | fRhoCharged2->FillBSJS(fEventCentrality,TPC_rho,fTPCJetThreshold,fmyAKTChargedJets,fTPCFullJet->GetJets(),fTPCFullJet->GetTotalJets()); |
| 1539 | fRhoCharged2->FillDeltaPt(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFluc,1); |
| 1540 | fRhoCharged2->FillDeltaPtSignal(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFlucSignal,1); |
| 7acc3e04 |
1541 | fRhoCharged2->FillDeltaPtNColl(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFlucNColl,1); |
| c6202663 |
1542 | fRhoCharged2->FillBackgroundFluctuations(fEventCentrality,TPC_rho,fJetR); |
| 1543 | fRhoCharged2->FillLeadingJetPtRho(fTPCFullJet->GetLeadingPt(),TPC_rho); |
| 1544 | } |
| ac6a3f1e |
1545 | |
| c6202663 |
1546 | void AliAnalysisTaskFullpAJets::EstimateChargedRhoN() |
| 1547 | { |
| 1548 | Int_t i,j; |
| 1549 | Bool_t track_away_from_jet; |
| 1550 | Double_t E_tracks_total=0.0; |
| 1551 | Double_t TPC_rho=0.0; |
| 1552 | Double_t jet_area_total=0.0; |
| 1553 | |
| 1554 | // First, sum all tracks within the EMCal that are away from jet(s) above Pt Threshold |
| 1555 | for (i=0;i<fnTracks;i++) |
| 1556 | { |
| 1557 | // First, check if track is in the EMCal!! |
| 1558 | AliVTrack* vtrack = (AliVTrack*) fmyTracks->At(i); |
| 1559 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| 1560 | { |
| 1561 | if (fTPCJet->GetTotalSignalJets()<1) |
| 1562 | { |
| 1563 | E_tracks_total+=vtrack->Pt(); |
| 1564 | } |
| 1565 | else |
| 1566 | { |
| 1567 | track_away_from_jet=kTRUE; |
| 1568 | j=0; |
| 1569 | TLorentzVector *track_vec = new TLorentzVector; |
| 1570 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 1571 | while (track_away_from_jet==kTRUE && j<fTPCJet->GetTotalSignalJets()) |
| ac6a3f1e |
1572 | { |
| c6202663 |
1573 | TLorentzVector *jet_vec= new TLorentzVector; |
| 1574 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetSignalJetIndex(j)); |
| 1575 | myJet->GetMom(*jet_vec); |
| 1576 | if (track_vec->DeltaR(*jet_vec)<=fJetRForRho) |
| 1577 | { |
| 1578 | track_away_from_jet=kFALSE; |
| 1579 | } |
| 1580 | delete jet_vec; |
| 1581 | j++; |
| ac6a3f1e |
1582 | } |
| c6202663 |
1583 | if (track_away_from_jet==kTRUE) |
| ac6a3f1e |
1584 | { |
| c6202663 |
1585 | E_tracks_total+=vtrack->Pt(); |
| ac6a3f1e |
1586 | } |
| c6202663 |
1587 | delete track_vec; |
| ac6a3f1e |
1588 | } |
| 1589 | } |
| c6202663 |
1590 | } |
| 1591 | |
| 1592 | // Determine area of all Jets that are within the EMCal |
| 1593 | if (fTPCJet->GetTotalSignalJets()==0) |
| 1594 | { |
| 1595 | jet_area_total=0.0; |
| 1596 | } |
| 1597 | else |
| 1598 | { |
| 1599 | for (i=0;i<fTPCJet->GetTotalSignalJets();i++) |
| 1600 | { |
| 1601 | AliEmcalJet *myJet = (AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetSignalJetIndex(i)); |
| 1602 | jet_area_total+=AreaWithinTPC(fJetR,myJet->Eta()); |
| 1603 | } |
| 1604 | } |
| 1605 | |
| 1606 | // Calculate Rho |
| 1607 | TPC_rho = E_tracks_total/(fTPCArea-jet_area_total); |
| 1608 | |
| 1609 | // Fill Histogram |
| 1610 | fRhoChargedN->FillRho(fEventCentrality,TPC_rho); |
| 1611 | fRhoChargedN->FillBSJS(fEventCentrality,TPC_rho,fTPCJetThreshold,fmyAKTChargedJets,fTPCFullJet->GetJets(),fTPCFullJet->GetTotalJets()); |
| 1612 | fRhoChargedN->FillDeltaPt(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFluc,1); |
| 1613 | fRhoChargedN->FillDeltaPtSignal(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFlucSignal,1); |
| 7acc3e04 |
1614 | fRhoChargedN->FillDeltaPtNColl(fEventCentrality,TPC_rho,fJetR,fTPCRCBckgFlucNColl,1); |
| c6202663 |
1615 | fRhoChargedN->FillBackgroundFluctuations(fEventCentrality,TPC_rho,fJetR); |
| 1616 | fRhoChargedN->FillLeadingJetPtRho(fTPCFullJet->GetLeadingPt(),TPC_rho); |
| 1617 | } |
| 1618 | |
| 1619 | void AliAnalysisTaskFullpAJets::EstimateChargedRhoScale() |
| 1620 | { |
| 1621 | Int_t i,j; |
| 1622 | Bool_t track_away_from_jet; |
| 1623 | Double_t E_tracks_total=0.0; |
| 1624 | Double_t TPC_rho=0.0; |
| 1625 | Double_t jet_area_total=0.0; |
| 1626 | |
| 1627 | // First, sum all tracks within the EMCal that are away from jet(s) above Pt Threshold |
| 1628 | for (i=0;i<fnTracks;i++) |
| 1629 | { |
| 1630 | // First, check if track is in the EMCal!! |
| 1631 | AliVTrack* vtrack = (AliVTrack*) fmyTracks->At(i); |
| 1632 | if (IsInTPC(fJetR,vtrack->Phi(),vtrack->Eta(),kFALSE)==kTRUE) |
| ac6a3f1e |
1633 | { |
| c6202663 |
1634 | if (fTPCJet->GetTotalSignalJets()<1) |
| ac6a3f1e |
1635 | { |
| c6202663 |
1636 | E_tracks_total+=vtrack->Pt(); |
| ac6a3f1e |
1637 | } |
| c6202663 |
1638 | else |
| ac6a3f1e |
1639 | { |
| c6202663 |
1640 | track_away_from_jet=kTRUE; |
| 1641 | j=0; |
| 1642 | TLorentzVector *track_vec = new TLorentzVector; |
| 1643 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 1644 | while (track_away_from_jet==kTRUE && j<fTPCJet->GetTotalSignalJets()) |
| ac6a3f1e |
1645 | { |
| c6202663 |
1646 | TLorentzVector *jet_vec= new TLorentzVector; |
| 1647 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetSignalJetIndex(j)); |
| 1648 | myJet->GetMom(*jet_vec); |
| 1649 | if (track_vec->DeltaR(*jet_vec)<=fJetRForRho) |
| 1650 | { |
| 1651 | track_away_from_jet=kFALSE; |
| 1652 | } |
| 1653 | delete jet_vec; |
| 1654 | j++; |
| ac6a3f1e |
1655 | } |
| c6202663 |
1656 | if (track_away_from_jet==kTRUE) |
| ac6a3f1e |
1657 | { |
| c6202663 |
1658 | E_tracks_total+=vtrack->Pt(); |
| ac6a3f1e |
1659 | } |
| c6202663 |
1660 | delete track_vec; |
| ac6a3f1e |
1661 | } |
| c6202663 |
1662 | } |
| 1663 | } |
| 1664 | |
| 7acc3e04 |
1665 | // Determine area of all Jets that are within the TPC |
| c6202663 |
1666 | if (fTPCJet->GetTotalSignalJets()==0) |
| 1667 | { |
| 1668 | jet_area_total=0.0; |
| 1669 | } |
| 1670 | else |
| 1671 | { |
| 1672 | for (i=0;i<fTPCJet->GetTotalSignalJets();i++) |
| 1673 | { |
| 1674 | AliEmcalJet *myJet = (AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetSignalJetIndex(i)); |
| 1675 | jet_area_total+=AreaWithinTPC(fJetR,myJet->Eta()); |
| 1676 | } |
| 1677 | } |
| 1678 | |
| 1679 | // Calculate Rho |
| 1680 | TPC_rho = E_tracks_total/(fTPCArea-jet_area_total); |
| 1681 | TPC_rho*=fScaleFactor; |
| 1682 | |
| 1683 | // Fill Histogram |
| 1684 | fRhoChargedScale->FillRho(fEventCentrality,TPC_rho); |
| 1685 | fRhoChargedScale->FillBSJS(fEventCentrality,TPC_rho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 1686 | fRhoChargedScale->FillDeltaPt(fEventCentrality,TPC_rho,fJetR,fEMCalRCBckgFluc,1); |
| 1687 | fRhoChargedScale->FillDeltaPtSignal(fEventCentrality,TPC_rho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
1688 | fRhoChargedScale->FillDeltaPtNColl(fEventCentrality,TPC_rho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
1689 | fRhoChargedScale->FillBackgroundFluctuations(fEventCentrality,TPC_rho,fJetR); |
| 1690 | fRhoChargedScale->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),TPC_rho); |
| 1691 | } |
| 1692 | |
| 1693 | void AliAnalysisTaskFullpAJets::EstimateChargedRhokT() |
| 1694 | { |
| 1695 | Int_t i; |
| 1696 | Double_t kTRho = 0.0; |
| 1697 | Double_t *pTArray = new Double_t[fTPCkTFullJet->GetTotalJets()]; |
| 1698 | Double_t *RhoArray = new Double_t[fTPCkTFullJet->GetTotalJets()]; |
| 1699 | |
| 1700 | for (i=0;i<fTPCkTFullJet->GetTotalJets();i++) |
| 1701 | { |
| 1702 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTChargedJets->At(fTPCkTFullJet->GetJetIndex(i)); |
| 1703 | pTArray[i]=myJet->Pt(); |
| 1704 | RhoArray[i]=myJet->Pt()/myJet->Area(); |
| 1705 | } |
| 1706 | |
| 1707 | if (fTPCkTFullJet->GetTotalJets()>=2) |
| 1708 | { |
| 1709 | kTRho=MedianRhokT(pTArray,RhoArray,fTPCkTFullJet->GetTotalJets()); |
| 1710 | |
| 1711 | fRhoChargedkT->FillRho(fEventCentrality,kTRho); |
| 1712 | fRhoChargedkT->FillBSJS(fEventCentrality,kTRho,fTPCJetThreshold,fmyAKTChargedJets,fTPCFullJet->GetJets(),fTPCFullJet->GetTotalJets()); |
| 1713 | fRhoChargedkT->FillDeltaPt(fEventCentrality,kTRho,fJetR,fTPCRCBckgFluc,1); |
| 1714 | fRhoChargedkT->FillDeltaPtSignal(fEventCentrality,kTRho,fJetR,fTPCRCBckgFlucSignal,1); |
| 7acc3e04 |
1715 | fRhoChargedkT->FillDeltaPtNColl(fEventCentrality,kTRho,fJetR,fTPCRCBckgFlucNColl,1); |
| c6202663 |
1716 | fRhoChargedkT->FillBackgroundFluctuations(fEventCentrality,kTRho,fJetR); |
| 1717 | fRhoChargedkT->FillLeadingJetPtRho(fTPCFullJet->GetLeadingPt(),kTRho); |
| 1718 | } |
| 1719 | delete [] RhoArray; |
| 1720 | delete [] pTArray; |
| 1721 | } |
| 1722 | |
| 1723 | void AliAnalysisTaskFullpAJets::EstimateChargedRhokTScale() |
| 1724 | { |
| 1725 | Int_t i; |
| 1726 | Double_t kTRho = 0.0; |
| 1727 | Double_t *pTArray = new Double_t[fTPCkTFullJet->GetTotalJets()]; |
| 1728 | Double_t *RhoArray = new Double_t[fTPCkTFullJet->GetTotalJets()]; |
| 1729 | |
| 1730 | for (i=0;i<fTPCkTFullJet->GetTotalJets();i++) |
| 1731 | { |
| 1732 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTChargedJets->At(fTPCkTFullJet->GetJetIndex(i)); |
| 1733 | pTArray[i]=myJet->Pt(); |
| 1734 | RhoArray[i]=myJet->Pt()/myJet->Area(); |
| 1735 | } |
| 1736 | |
| 1737 | if (fTPCkTFullJet->GetTotalJets()>=2) |
| 1738 | { |
| 1739 | kTRho=MedianRhokT(pTArray,RhoArray,fTPCkTFullJet->GetTotalJets()); |
| 1740 | kTRho*=fScaleFactor; |
| 1741 | |
| 1742 | fRhoChargedkTScale->FillRho(fEventCentrality,kTRho); |
| 1743 | fRhoChargedkTScale->FillBSJS(fEventCentrality,kTRho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 1744 | fRhoChargedkTScale->FillDeltaPt(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFluc,1); |
| 1745 | fRhoChargedkTScale->FillDeltaPtSignal(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
1746 | fRhoChargedkTScale->FillDeltaPtNColl(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
1747 | fRhoChargedkTScale->FillBackgroundFluctuations(fEventCentrality,kTRho,fJetR); |
| 1748 | fRhoChargedkTScale->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),kTRho); |
| 1749 | } |
| 1750 | delete [] RhoArray; |
| 1751 | delete [] pTArray; |
| 1752 | } |
| 1753 | |
| 1754 | void AliAnalysisTaskFullpAJets::EstimateChargedRhoCMS() |
| 1755 | { |
| 1756 | Int_t i,k; |
| 1757 | Double_t kTRho = 0.0; |
| 1758 | Double_t CMSTotalkTArea = 0.0; |
| 1759 | Double_t CMSTrackArea = 0.0; |
| 1760 | Double_t CMSCorrectionFactor = 1.0; |
| 1761 | Double_t *pTArray = new Double_t[fTPCkTFullJet->GetTotalJets()]; |
| 1762 | Double_t *RhoArray = new Double_t[fTPCkTFullJet->GetTotalJets()]; |
| 1763 | |
| 1764 | k=0; |
| 1765 | if ((fTPCJet->GetLeadingPt()>=fTPCJetThreshold) && (fTPCJet->GetSubLeadingPt()>=fTPCJetThreshold)) |
| 1766 | { |
| 1767 | AliEmcalJet *myJet1 =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetLeadingIndex()); |
| 1768 | AliEmcalJet *myJet2 =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetSubLeadingIndex()); |
| 1769 | |
| 1770 | for (i=0;i<fTPCkTFullJet->GetTotalJets();i++) |
| 1771 | { |
| 1772 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTChargedJets->At(fTPCkTFullJet->GetJetIndex(i)); |
| ac6a3f1e |
1773 | |
| c6202663 |
1774 | CMSTotalkTArea+=myJet->Area(); |
| 1775 | if (myJet->GetNumberOfTracks()>0) |
| 1776 | { |
| 1777 | CMSTrackArea+=myJet->Area(); |
| 1778 | } |
| 1779 | if (IsJetOverlap(myJet,myJet1,kFALSE)==kFALSE && IsJetOverlap(myJet,myJet2,kFALSE)==kFALSE) |
| ac6a3f1e |
1780 | { |
| c6202663 |
1781 | pTArray[k]=myJet->Pt(); |
| 1782 | RhoArray[k]=myJet->Pt()/myJet->Area(); |
| 1783 | k++; |
| ac6a3f1e |
1784 | } |
| 1785 | } |
| c6202663 |
1786 | if (k>0) |
| ac6a3f1e |
1787 | { |
| c6202663 |
1788 | kTRho=MedianRhokT(pTArray,RhoArray,k); |
| ac6a3f1e |
1789 | } |
| c6202663 |
1790 | else |
| ac6a3f1e |
1791 | { |
| c6202663 |
1792 | kTRho=0.0; |
| ac6a3f1e |
1793 | } |
| 1794 | } |
| c6202663 |
1795 | else if (fTPCJet->GetLeadingPt()>=fTPCJetThreshold) |
| ac6a3f1e |
1796 | { |
| c6202663 |
1797 | AliEmcalJet *myJet1 =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetLeadingIndex()); |
| ac6a3f1e |
1798 | |
| c6202663 |
1799 | for (i=0;i<fTPCkTFullJet->GetTotalJets();i++) |
| ac6a3f1e |
1800 | { |
| c6202663 |
1801 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTChargedJets->At(fTPCkTFullJet->GetJetIndex(i)); |
| 1802 | |
| 1803 | CMSTotalkTArea+=myJet->Area(); |
| 1804 | if (myJet->GetNumberOfTracks()>0) |
| 1805 | { |
| 1806 | CMSTrackArea+=myJet->Area(); |
| 1807 | } |
| 1808 | if (IsJetOverlap(myJet,myJet1,kFALSE)==kFALSE) |
| 1809 | { |
| 1810 | pTArray[k]=myJet->Pt(); |
| 1811 | RhoArray[k]=myJet->Pt()/myJet->Area(); |
| 1812 | k++; |
| 1813 | } |
| 1814 | } |
| 1815 | if (k>0) |
| 1816 | { |
| 1817 | kTRho=MedianRhokT(pTArray,RhoArray,k); |
| 1818 | } |
| 1819 | else |
| 1820 | { |
| 1821 | kTRho=0.0; |
| ac6a3f1e |
1822 | } |
| 1823 | } |
| c6202663 |
1824 | else |
| 78246241 |
1825 | { |
| c6202663 |
1826 | for (i=0;i<fTPCkTFullJet->GetTotalJets();i++) |
| 1827 | { |
| 1828 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTChargedJets->At(fTPCkTFullJet->GetJetIndex(i)); |
| 1829 | |
| 1830 | CMSTotalkTArea+=myJet->Area(); |
| 1831 | if (myJet->GetNumberOfTracks()>0) |
| 1832 | { |
| 1833 | CMSTrackArea+=myJet->Area(); |
| 1834 | } |
| 1835 | pTArray[k]=myJet->Pt(); |
| 1836 | RhoArray[k]=myJet->Pt()/myJet->Area(); |
| 1837 | k++; |
| 1838 | } |
| 1839 | if (k>0) |
| 1840 | { |
| 1841 | kTRho=MedianRhokT(pTArray,RhoArray,k); |
| 1842 | } |
| 1843 | else |
| 1844 | { |
| 1845 | kTRho=0.0; |
| 1846 | } |
| 78246241 |
1847 | } |
| c6202663 |
1848 | // Scale CMS Rho by Correction factor |
| 1849 | if (CMSTotalkTArea==0.0) |
| ac6a3f1e |
1850 | { |
| c6202663 |
1851 | CMSCorrectionFactor = 1.0; |
| ac6a3f1e |
1852 | } |
| c6202663 |
1853 | else |
| ac6a3f1e |
1854 | { |
| c6202663 |
1855 | //CMSCorrectionFactor = CMSTrackArea/CMSTotalkTArea; |
| 1856 | CMSCorrectionFactor = CMSTrackArea/(fTPCPhiTotal*(fTPCEtaTotal-2*fJetR)); // The total physical area should be reduced by the eta cut due to looping over only fully contained kT jets within the TPC |
| 1857 | } |
| 1858 | kTRho*=CMSCorrectionFactor; |
| 1859 | fRhoChargedCMS->FillRho(fEventCentrality,kTRho); |
| 1860 | fRhoChargedCMS->FillBSJS(fEventCentrality,kTRho,fTPCJetThreshold,fmyAKTChargedJets,fTPCFullJet->GetJets(),fTPCFullJet->GetTotalJets()); |
| 1861 | fRhoChargedCMS->FillDeltaPt(fEventCentrality,kTRho,fJetR,fTPCRCBckgFluc,1); |
| 1862 | fRhoChargedCMS->FillDeltaPtSignal(fEventCentrality,kTRho,fJetR,fTPCRCBckgFlucSignal,1); |
| 7acc3e04 |
1863 | fRhoChargedCMS->FillDeltaPtNColl(fEventCentrality,kTRho,fJetR,fTPCRCBckgFlucNColl,1); |
| c6202663 |
1864 | fRhoChargedCMS->FillBackgroundFluctuations(fEventCentrality,kTRho,fJetR); |
| 1865 | fRhoChargedCMS->FillLeadingJetPtRho(fTPCFullJet->GetLeadingPt(),kTRho); |
| 1866 | delete [] RhoArray; |
| 1867 | delete [] pTArray; |
| 1868 | } |
| ac6a3f1e |
1869 | |
| c6202663 |
1870 | void AliAnalysisTaskFullpAJets::EstimateChargedRhoCMSScale() |
| 1871 | { |
| 1872 | Int_t i,k; |
| 1873 | Double_t kTRho = 0.0; |
| 1874 | Double_t CMSTotalkTArea = 0.0; |
| 1875 | Double_t CMSTrackArea = 0.0; |
| 1876 | Double_t CMSCorrectionFactor = 1.0; |
| 1877 | Double_t *pTArray = new Double_t[fTPCkTFullJet->GetTotalJets()]; |
| 1878 | Double_t *RhoArray = new Double_t[fTPCkTFullJet->GetTotalJets()]; |
| 1879 | |
| 1880 | k=0; |
| 1881 | if ((fTPCJet->GetLeadingPt()>=fTPCJetThreshold) && (fTPCJet->GetSubLeadingPt()>=fTPCJetThreshold)) |
| 1882 | { |
| 1883 | AliEmcalJet *myJet1 =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetLeadingIndex()); |
| 1884 | AliEmcalJet *myJet2 =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetSubLeadingIndex()); |
| 1885 | |
| 1886 | for (i=0;i<fTPCkTFullJet->GetTotalJets();i++) |
| 1887 | { |
| 1888 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTChargedJets->At(fTPCkTFullJet->GetJetIndex(i)); |
| 1889 | |
| 1890 | CMSTotalkTArea+=myJet->Area(); |
| 1891 | if (myJet->GetNumberOfTracks()>0) |
| 1892 | { |
| 1893 | CMSTrackArea+=myJet->Area(); |
| 1894 | } |
| 1895 | if (IsJetOverlap(myJet,myJet1,kFALSE)==kFALSE && IsJetOverlap(myJet,myJet2,kFALSE)==kFALSE) |
| 1896 | { |
| 1897 | pTArray[k]=myJet->Pt(); |
| 1898 | RhoArray[k]=myJet->Pt()/myJet->Area(); |
| 1899 | k++; |
| 1900 | } |
| 1901 | } |
| 1902 | if (k>0) |
| 1903 | { |
| 1904 | kTRho=MedianRhokT(pTArray,RhoArray,k); |
| 1905 | } |
| 1906 | else |
| 1907 | { |
| 1908 | kTRho=0.0; |
| 1909 | } |
| 1910 | } |
| 1911 | else if (fTPCJet->GetLeadingPt()>=fTPCJetThreshold) |
| 1912 | { |
| 1913 | AliEmcalJet *myJet1 =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCJet->GetLeadingIndex()); |
| 1914 | |
| 1915 | for (i=0;i<fTPCkTFullJet->GetTotalJets();i++) |
| 1916 | { |
| 1917 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTChargedJets->At(fTPCkTFullJet->GetJetIndex(i)); |
| 1918 | |
| 1919 | CMSTotalkTArea+=myJet->Area(); |
| 1920 | if (myJet->GetNumberOfTracks()>0) |
| 1921 | { |
| 1922 | CMSTrackArea+=myJet->Area(); |
| 1923 | } |
| 1924 | if (IsJetOverlap(myJet,myJet1,kFALSE)==kFALSE) |
| 1925 | { |
| 1926 | pTArray[k]=myJet->Pt(); |
| 1927 | RhoArray[k]=myJet->Pt()/myJet->Area(); |
| 1928 | k++; |
| 1929 | } |
| 1930 | } |
| 1931 | if (k>0) |
| 1932 | { |
| 1933 | kTRho=MedianRhokT(pTArray,RhoArray,k); |
| 1934 | } |
| 1935 | else |
| 1936 | { |
| 1937 | kTRho=0.0; |
| 1938 | } |
| 1939 | } |
| 1940 | else |
| ac6a3f1e |
1941 | { |
| c6202663 |
1942 | for (i=0;i<fTPCkTFullJet->GetTotalJets();i++) |
| 1943 | { |
| 1944 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTChargedJets->At(fTPCkTFullJet->GetJetIndex(i)); |
| 1945 | |
| 1946 | CMSTotalkTArea+=myJet->Area(); |
| 1947 | if (myJet->GetNumberOfTracks()>0) |
| 1948 | { |
| 1949 | CMSTrackArea+=myJet->Area(); |
| 1950 | } |
| 1951 | pTArray[k]=myJet->Pt(); |
| 1952 | RhoArray[k]=myJet->Pt()/myJet->Area(); |
| 1953 | k++; |
| 1954 | } |
| 1955 | if (k>0) |
| 78246241 |
1956 | { |
| c6202663 |
1957 | kTRho=MedianRhokT(pTArray,RhoArray,k); |
| 78246241 |
1958 | } |
| c6202663 |
1959 | else |
| c54b626a |
1960 | { |
| c6202663 |
1961 | kTRho=0.0; |
| c54b626a |
1962 | } |
| ac6a3f1e |
1963 | } |
| c6202663 |
1964 | kTRho*=fScaleFactor; |
| 1965 | // Scale CMS Rho by Correction factor |
| 1966 | if (CMSTotalkTArea==0.0) |
| 1967 | { |
| 1968 | CMSCorrectionFactor = 1.0; |
| 1969 | } |
| 1970 | else |
| 1971 | { |
| 1972 | //CMSCorrectionFactor = CMSTrackArea/CMSTotalkTArea; |
| 1973 | CMSCorrectionFactor = CMSTrackArea/(fTPCPhiTotal*(fTPCEtaTotal-2*fJetR)); // The total physical area should be reduced by the eta cut due to looping over only fully contained kT jets within the TPC |
| 1974 | } |
| 1975 | kTRho*=CMSCorrectionFactor; |
| 1976 | |
| 1977 | fRhoChargedCMSScale->FillRho(fEventCentrality,kTRho); |
| 1978 | fRhoChargedCMSScale->FillBSJS(fEventCentrality,kTRho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 1979 | fRhoChargedCMSScale->FillDeltaPt(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFluc,1); |
| 1980 | fRhoChargedCMSScale->FillDeltaPtSignal(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
1981 | fRhoChargedCMSScale->FillDeltaPtNColl(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
1982 | fRhoChargedCMSScale->FillBackgroundFluctuations(fEventCentrality,kTRho,fJetR); |
| 1983 | fRhoChargedCMSScale->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),kTRho); |
| 1984 | delete [] RhoArray; |
| 1985 | delete [] pTArray; |
| ac6a3f1e |
1986 | } |
| 1987 | |
| c6202663 |
1988 | // Full Rho's |
| 1989 | void AliAnalysisTaskFullpAJets::EstimateFullRho0() |
| ac6a3f1e |
1990 | { |
| 1991 | Int_t i; |
| c6202663 |
1992 | Double_t E_tracks_total=0.0; |
| 1993 | Double_t E_caloclusters_total=0.0; |
| 1994 | Double_t EMCal_rho=0.0; |
| ac6a3f1e |
1995 | |
| 1996 | // Loop over all tracks |
| 1997 | for (i=0;i<fnTracks;i++) |
| 1998 | { |
| 1999 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 2000 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 2001 | { |
| 2002 | E_tracks_total+=vtrack->Pt(); |
| 2003 | } |
| 2004 | } |
| 2005 | |
| 2006 | // Loop over all caloclusters |
| 2007 | for (i=0;i<fnClusters;i++) |
| 2008 | { |
| 2009 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| c6202663 |
2010 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 2011 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 2012 | E_caloclusters_total+=cluster_vec->Pt(); |
| 2013 | //E_caloclusters_total+=0.5*cluster_vec->Pt(); |
| ac6a3f1e |
2014 | } |
| c6202663 |
2015 | |
| ac6a3f1e |
2016 | // Calculate the mean Background density |
| 2017 | EMCal_rho=(E_tracks_total+E_caloclusters_total)/fEMCalArea; |
| c6202663 |
2018 | fRhoFull=EMCal_rho; |
| ac6a3f1e |
2019 | |
| c6202663 |
2020 | // Fill Histograms |
| 2021 | if (fRhoCharged>0) |
| ac6a3f1e |
2022 | { |
| c6202663 |
2023 | fpRhoScale->Fill(fEventCentrality,fRhoFull/fRhoCharged); |
| 2024 | fhRhoScale->Fill(fRhoFull/fRhoCharged,fEventCentrality); |
| ac6a3f1e |
2025 | } |
| c6202663 |
2026 | |
| 2027 | fRhoFull0->FillRho(fEventCentrality,EMCal_rho); |
| 2028 | fRhoFull0->FillBSJS(fEventCentrality,EMCal_rho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 2029 | fRhoFull0->FillDeltaPt(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFluc,1); |
| 2030 | fRhoFull0->FillDeltaPtSignal(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
2031 | fRhoFull0->FillDeltaPtNColl(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
2032 | fRhoFull0->FillBackgroundFluctuations(fEventCentrality,EMCal_rho,fJetR); |
| 2033 | fRhoFull0->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),EMCal_rho); |
| ac6a3f1e |
2034 | } |
| 2035 | |
| c6202663 |
2036 | void AliAnalysisTaskFullpAJets::EstimateFullRho1() |
| ac6a3f1e |
2037 | { |
| 2038 | Int_t i; |
| c6202663 |
2039 | Double_t E_tracks_total=0.0; |
| 2040 | Double_t E_caloclusters_total=0.0; |
| 2041 | Double_t EMCal_rho=0.0; |
| ac6a3f1e |
2042 | |
| c6202663 |
2043 | if (fEMCalPartJet->GetLeadingPt()>=fEMCalJetThreshold) |
| ac6a3f1e |
2044 | { |
| c6202663 |
2045 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetLeadingIndex()); |
| ac6a3f1e |
2046 | TLorentzVector *temp_jet= new TLorentzVector; |
| 2047 | myJet->GetMom(*temp_jet); |
| 2048 | |
| 2049 | // Loop over all tracks |
| 2050 | for (i=0;i<fnTracks;i++) |
| 2051 | { |
| 2052 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 2053 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 2054 | { |
| 2055 | TLorentzVector *track_vec = new TLorentzVector; |
| 2056 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| c6202663 |
2057 | if (temp_jet->DeltaR(*track_vec)>fJetRForRho) |
| ac6a3f1e |
2058 | { |
| 2059 | E_tracks_total+=vtrack->Pt(); |
| 2060 | } |
| 2061 | delete track_vec; |
| 2062 | } |
| 2063 | } |
| 2064 | |
| 2065 | // Loop over all caloclusters |
| 2066 | for (i=0;i<fnClusters;i++) |
| 2067 | { |
| 2068 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 2069 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 2070 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| c6202663 |
2071 | if (temp_jet->DeltaR(*cluster_vec)>fJetRForRho) |
| ac6a3f1e |
2072 | { |
| 2073 | E_caloclusters_total+=vcluster->E(); |
| 2074 | } |
| 2075 | delete cluster_vec; |
| 2076 | } |
| 2077 | delete temp_jet; |
| 2078 | // Calculate the mean Background density |
| c6202663 |
2079 | EMCal_rho=(E_tracks_total+E_caloclusters_total)/(fEMCalArea-AreaWithinEMCal(fJetR,myJet->Phi(),myJet->Eta())); |
| ac6a3f1e |
2080 | } |
| c6202663 |
2081 | else // i.e. No signal jets -> same as total background density |
| ac6a3f1e |
2082 | { |
| 2083 | // Loop over all tracks |
| 2084 | for (i=0;i<fnTracks;i++) |
| 2085 | { |
| 2086 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 2087 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 2088 | { |
| 2089 | E_tracks_total+=vtrack->Pt(); |
| 2090 | } |
| 2091 | } |
| 2092 | |
| 2093 | // Loop over all caloclusters |
| 2094 | for (i=0;i<fnClusters;i++) |
| 2095 | { |
| 2096 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 2097 | E_caloclusters_total+=vcluster->E(); |
| 2098 | } |
| 2099 | // Calculate the mean Background density |
| 2100 | EMCal_rho=(E_tracks_total+E_caloclusters_total)/fEMCalArea; |
| 2101 | } |
| 2102 | |
| c6202663 |
2103 | // Fill histograms |
| 2104 | fRhoFull1->FillRho(fEventCentrality,EMCal_rho); |
| 2105 | fRhoFull1->FillBSJS(fEventCentrality,EMCal_rho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 2106 | fRhoFull1->FillDeltaPt(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFluc,1); |
| 2107 | fRhoFull1->FillDeltaPtSignal(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
2108 | fRhoFull1->FillDeltaPtNColl(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
2109 | fRhoFull1->FillBackgroundFluctuations(fEventCentrality,EMCal_rho,fJetR); |
| 2110 | fRhoFull1->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),EMCal_rho); |
| ac6a3f1e |
2111 | } |
| 2112 | |
| c6202663 |
2113 | void AliAnalysisTaskFullpAJets::EstimateFullRho2() |
| ac6a3f1e |
2114 | { |
| 2115 | Int_t i; |
| c6202663 |
2116 | Double_t E_tracks_total=0.0; |
| 2117 | Double_t E_caloclusters_total=0.0; |
| 2118 | Double_t EMCal_rho=0.0; |
| 2119 | |
| 2120 | if ((fEMCalPartJet->GetLeadingPt()>=fEMCalJetThreshold) && (fEMCalPartJet->GetSubLeadingPt()>=fEMCalJetThreshold)) |
| ac6a3f1e |
2121 | { |
| c6202663 |
2122 | AliEmcalJet *myhJet =(AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetLeadingIndex()); |
| 2123 | TLorentzVector *temp_jet1 = new TLorentzVector; |
| 2124 | myhJet->GetMom(*temp_jet1); |
| 2125 | |
| 2126 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetSubLeadingIndex()); |
| 2127 | TLorentzVector *temp_jet2 = new TLorentzVector; |
| 2128 | myJet->GetMom(*temp_jet2); |
| 2129 | |
| 2130 | // Loop over all tracks |
| 2131 | for (i=0;i<fnTracks;i++) |
| 2132 | { |
| 2133 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 2134 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 2135 | { |
| 2136 | TLorentzVector *track_vec = new TLorentzVector; |
| 2137 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 2138 | if ((temp_jet1->DeltaR(*track_vec)>fJetRForRho) && (temp_jet2->DeltaR(*track_vec)>fJetRForRho)) |
| 2139 | { |
| 2140 | E_tracks_total+=vtrack->Pt(); |
| 2141 | } |
| 2142 | delete track_vec; |
| 2143 | } |
| 2144 | } |
| 2145 | |
| 2146 | // Loop over all caloclusters |
| 2147 | for (i=0;i<fnClusters;i++) |
| 2148 | { |
| 2149 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 2150 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 2151 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 2152 | if ((temp_jet1->DeltaR(*cluster_vec)>fJetRForRho) && (temp_jet2->DeltaR(*cluster_vec)>fJetRForRho)) |
| 2153 | { |
| 2154 | E_caloclusters_total+=vcluster->E(); |
| 2155 | } |
| 2156 | delete cluster_vec; |
| 2157 | } |
| 2158 | delete temp_jet1; |
| 2159 | delete temp_jet2; |
| 2160 | |
| 2161 | // Calculate the mean Background density |
| 2162 | EMCal_rho=(E_tracks_total+E_caloclusters_total)/(fEMCalArea-AreaWithinEMCal(fJetR,myhJet->Phi(),myhJet->Eta())-AreaWithinEMCal(fJetR,myJet->Phi(),myJet->Eta())); |
| 2163 | } |
| 2164 | else if (fEMCalPartJet->GetLeadingPt()>=fEMCalJetThreshold) |
| 2165 | { |
| 2166 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetLeadingIndex()); |
| ac6a3f1e |
2167 | TLorentzVector *temp_jet= new TLorentzVector; |
| c6202663 |
2168 | myJet->GetMom(*temp_jet); |
| ac6a3f1e |
2169 | |
| c6202663 |
2170 | // Loop over all tracks |
| 2171 | for (i=0;i<fnTracks;i++) |
| ac6a3f1e |
2172 | { |
| c6202663 |
2173 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 2174 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| ac6a3f1e |
2175 | { |
| c6202663 |
2176 | TLorentzVector *track_vec = new TLorentzVector; |
| 2177 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 2178 | if (temp_jet->DeltaR(*track_vec)>fJetRForRho) |
| ac6a3f1e |
2179 | { |
| c6202663 |
2180 | E_tracks_total+=vtrack->Pt(); |
| ac6a3f1e |
2181 | } |
| c6202663 |
2182 | delete track_vec; |
| 2183 | } |
| 2184 | } |
| 2185 | |
| 2186 | // Loop over all caloclusters |
| 2187 | for (i=0;i<fnClusters;i++) |
| 2188 | { |
| 2189 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 2190 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 2191 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 2192 | if (temp_jet->DeltaR(*cluster_vec)>fJetRForRho) |
| 2193 | { |
| 2194 | E_caloclusters_total+=vcluster->E(); |
| ac6a3f1e |
2195 | } |
| c6202663 |
2196 | delete cluster_vec; |
| ac6a3f1e |
2197 | } |
| ac6a3f1e |
2198 | delete temp_jet; |
| c6202663 |
2199 | // Calculate the mean Background density |
| 2200 | EMCal_rho=(E_tracks_total+E_caloclusters_total)/(fEMCalArea-AreaWithinEMCal(fJetR,myJet->Phi(),myJet->Eta())); |
| 2201 | } |
| 2202 | else // i.e. No signal jets -> same as total background density |
| 2203 | { |
| 2204 | // Loop over all tracks |
| 2205 | for (i=0;i<fnTracks;i++) |
| 2206 | { |
| 2207 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| 2208 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 2209 | { |
| 2210 | E_tracks_total+=vtrack->Pt(); |
| 2211 | } |
| 2212 | } |
| 2213 | |
| 2214 | // Loop over all caloclusters |
| 2215 | for (i=0;i<fnClusters;i++) |
| 2216 | { |
| 2217 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 2218 | E_caloclusters_total+=vcluster->E(); |
| 2219 | } |
| 2220 | // Calculate the mean Background density |
| 2221 | EMCal_rho=(E_tracks_total+E_caloclusters_total)/fEMCalArea; |
| ac6a3f1e |
2222 | } |
| c6202663 |
2223 | |
| 2224 | // Fill histograms |
| 2225 | fRhoFull2->FillRho(fEventCentrality,EMCal_rho); |
| 2226 | fRhoFull2->FillBSJS(fEventCentrality,EMCal_rho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 2227 | fRhoFull2->FillDeltaPt(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFluc,1); |
| 2228 | fRhoFull2->FillDeltaPtSignal(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
2229 | fRhoFull2->FillDeltaPtNColl(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
2230 | fRhoFull2->FillBackgroundFluctuations(fEventCentrality,EMCal_rho,fJetR); |
| 2231 | fRhoFull2->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),EMCal_rho); |
| ac6a3f1e |
2232 | } |
| 2233 | |
| c6202663 |
2234 | void AliAnalysisTaskFullpAJets::EstimateFullRhoN() |
| ac6a3f1e |
2235 | { |
| 2236 | Int_t i,j; |
| 2237 | Bool_t track_away_from_jet; |
| c6202663 |
2238 | Bool_t cluster_away_from_jet; |
| 2239 | Double_t E_tracks_total=0.0; |
| 2240 | Double_t E_caloclusters_total=0.0; |
| 2241 | Double_t EMCal_rho=0.0; |
| 2242 | Double_t jet_area_total=0.0; |
| ac6a3f1e |
2243 | |
| 2244 | // First, sum all tracks within the EMCal that are away from jet(s) above Pt Threshold |
| ac6a3f1e |
2245 | for (i=0;i<fnTracks;i++) |
| 2246 | { |
| 2247 | // First, check if track is in the EMCal!! |
| c6202663 |
2248 | AliVTrack* vtrack = (AliVTrack*) fmyTracks->At(i); |
| ac6a3f1e |
2249 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 2250 | { |
| c6202663 |
2251 | if (fEMCalPartJet->GetTotalSignalJets()<1) |
| ac6a3f1e |
2252 | { |
| 2253 | E_tracks_total+=vtrack->Pt(); |
| 2254 | } |
| 2255 | else |
| 2256 | { |
| 2257 | track_away_from_jet=kTRUE; |
| 2258 | j=0; |
| 2259 | TLorentzVector *track_vec = new TLorentzVector; |
| 2260 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| c6202663 |
2261 | while (track_away_from_jet==kTRUE && j<fEMCalPartJet->GetTotalSignalJets()) |
| ac6a3f1e |
2262 | { |
| ac6a3f1e |
2263 | TLorentzVector *jet_vec= new TLorentzVector; |
| c6202663 |
2264 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetSignalJetIndex(j)); |
| ac6a3f1e |
2265 | myJet->GetMom(*jet_vec); |
| c6202663 |
2266 | if (track_vec->DeltaR(*jet_vec)<=fJetRForRho) |
| ac6a3f1e |
2267 | { |
| 2268 | track_away_from_jet=kFALSE; |
| 2269 | } |
| 2270 | delete jet_vec; |
| 2271 | j++; |
| 2272 | } |
| 2273 | if (track_away_from_jet==kTRUE) |
| 2274 | { |
| 2275 | E_tracks_total+=vtrack->Pt(); |
| 2276 | } |
| 2277 | delete track_vec; |
| 2278 | } |
| 2279 | } |
| 2280 | } |
| 2281 | |
| 2282 | // Next, sum all CaloClusters within the EMCal (obviously all clusters must be within EMCal!!) that are away from jet(s) above Pt Threshold |
| ac6a3f1e |
2283 | for (i=0;i<fnClusters;i++) |
| 2284 | { |
| c6202663 |
2285 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 2286 | if (fEMCalPartJet->GetTotalSignalJets()<1) |
| ac6a3f1e |
2287 | { |
| 2288 | E_caloclusters_total+=vcluster->E(); |
| 2289 | } |
| 2290 | else |
| 2291 | { |
| 2292 | cluster_away_from_jet=kTRUE; |
| 2293 | j=0; |
| 2294 | |
| 2295 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 2296 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| c6202663 |
2297 | while (cluster_away_from_jet==kTRUE && j<fEMCalPartJet->GetTotalSignalJets()) |
| ac6a3f1e |
2298 | { |
| 2299 | TLorentzVector *jet_vec= new TLorentzVector; |
| c6202663 |
2300 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetSignalJetIndex(j)); |
| ac6a3f1e |
2301 | myJet->GetMom(*jet_vec); |
| c6202663 |
2302 | if (cluster_vec->DeltaR(*jet_vec)<=fJetRForRho) |
| ac6a3f1e |
2303 | { |
| 2304 | cluster_away_from_jet=kFALSE; |
| 2305 | } |
| 2306 | delete jet_vec; |
| 2307 | j++; |
| 2308 | } |
| 2309 | if (cluster_away_from_jet==kTRUE) |
| 2310 | { |
| 2311 | E_caloclusters_total+=vcluster->E(); |
| 2312 | } |
| 2313 | delete cluster_vec; |
| 2314 | } |
| 2315 | } |
| 2316 | |
| 2317 | // Determine area of all Jets that are within the EMCal |
| c6202663 |
2318 | if (fEMCalPartJet->GetTotalSignalJets()==0) |
| ac6a3f1e |
2319 | { |
| c6202663 |
2320 | jet_area_total=0.0; |
| ac6a3f1e |
2321 | } |
| 2322 | else |
| 2323 | { |
| c6202663 |
2324 | for (i=0;i<fEMCalPartJet->GetTotalSignalJets();i++) |
| ac6a3f1e |
2325 | { |
| c6202663 |
2326 | AliEmcalJet *myJet = (AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetSignalJetIndex(i)); |
| ac6a3f1e |
2327 | jet_area_total+=AreaWithinEMCal(fJetR,myJet->Phi(),myJet->Eta()); |
| 2328 | } |
| 2329 | } |
| 2330 | |
| 2331 | // Calculate Rho |
| 2332 | EMCal_rho=(E_tracks_total+E_caloclusters_total)/(fEMCalArea-jet_area_total); |
| ac6a3f1e |
2333 | |
| c6202663 |
2334 | // Fill Histogram |
| 2335 | fRhoFullN->FillRho(fEventCentrality,EMCal_rho); |
| 2336 | fRhoFullN->FillBSJS(fEventCentrality,EMCal_rho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 2337 | fRhoFullN->FillDeltaPt(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFluc,1); |
| 2338 | fRhoFullN->FillDeltaPtSignal(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
2339 | fRhoFullN->FillDeltaPtNColl(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
2340 | fRhoFullN->FillBackgroundFluctuations(fEventCentrality,EMCal_rho,fJetR); |
| 2341 | fRhoFullN->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),EMCal_rho); |
| ac6a3f1e |
2342 | } |
| 2343 | |
| c6202663 |
2344 | void AliAnalysisTaskFullpAJets::EstimateFullRhoDijet() |
| ac6a3f1e |
2345 | { |
| 78246241 |
2346 | Int_t i; |
| 78246241 |
2347 | Double_t E_tracks_total=0.0; |
| 2348 | Double_t E_caloclusters_total=0.0; |
| 2349 | Double_t EMCal_rho=0.0; |
| 78246241 |
2350 | |
| 2351 | // Loop over all tracks |
| ac6a3f1e |
2352 | for (i=0;i<fnTracks;i++) |
| 2353 | { |
| 78246241 |
2354 | AliVTrack* vtrack =(AliVTrack*) fmyTracks->At(i); |
| ac6a3f1e |
2355 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 2356 | { |
| 78246241 |
2357 | E_tracks_total+=vtrack->Pt(); |
| ac6a3f1e |
2358 | } |
| 2359 | } |
| 2360 | |
| 78246241 |
2361 | // Loop over all caloclusters |
| ac6a3f1e |
2362 | for (i=0;i<fnClusters;i++) |
| 2363 | { |
| 78246241 |
2364 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(i); |
| 2365 | E_caloclusters_total+=vcluster->E(); |
| ac6a3f1e |
2366 | } |
| 2367 | |
| 78246241 |
2368 | // Calculate the mean Background density |
| 2369 | EMCal_rho=(E_tracks_total+E_caloclusters_total)/fEMCalArea; |
| ac6a3f1e |
2370 | |
| c6202663 |
2371 | // Fill Histograms |
| 2372 | fRhoFullDijet->FillRho(fEventCentrality,EMCal_rho); |
| 2373 | fRhoFullDijet->FillBSJS(fEventCentrality,EMCal_rho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 2374 | fRhoFullDijet->FillDeltaPt(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFluc,1); |
| 2375 | fRhoFullDijet->FillDeltaPtSignal(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
2376 | fRhoFullDijet->FillDeltaPtNColl(fEventCentrality,EMCal_rho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
2377 | fRhoFullDijet->FillBackgroundFluctuations(fEventCentrality,EMCal_rho,fJetR); |
| 2378 | fRhoFullDijet->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),EMCal_rho); |
| 2379 | } |
| 2380 | |
| 2381 | void AliAnalysisTaskFullpAJets::EstimateFullRhokT() |
| 2382 | { |
| 2383 | Int_t i; |
| 2384 | Double_t kTRho = 0.0; |
| 2385 | Double_t *pTArray = new Double_t[fEMCalkTFullJet->GetTotalJets()]; |
| 2386 | Double_t *RhoArray = new Double_t[fEMCalkTFullJet->GetTotalJets()]; |
| 2387 | |
| 2388 | for (i=0;i<fEMCalkTFullJet->GetTotalJets();i++) |
| 2389 | { |
| 2390 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTFullJets->At(fEMCalkTFullJet->GetJetIndex(i)); |
| 2391 | pTArray[i]=myJet->Pt(); |
| 2392 | RhoArray[i]=myJet->Pt()/myJet->Area(); |
| 2393 | } |
| ac6a3f1e |
2394 | |
| c6202663 |
2395 | if (fEMCalkTFullJet->GetTotalJets()>0) |
| ac6a3f1e |
2396 | { |
| c6202663 |
2397 | kTRho=MedianRhokT(pTArray,RhoArray,fEMCalkTFullJet->GetTotalJets()); |
| ac6a3f1e |
2398 | } |
| c6202663 |
2399 | else |
| 2400 | { |
| 2401 | kTRho=0.0; |
| 2402 | } |
| 2403 | fRhoFullkT->FillRho(fEventCentrality,kTRho); |
| 2404 | fRhoFullkT->FillBSJS(fEventCentrality,kTRho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 2405 | fRhoFullkT->FillDeltaPt(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFluc,1); |
| 2406 | fRhoFullkT->FillDeltaPtSignal(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
2407 | fRhoFullkT->FillDeltaPtNColl(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
2408 | fRhoFullkT->FillBackgroundFluctuations(fEventCentrality,kTRho,fJetR); |
| 2409 | fRhoFullkT->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),kTRho); |
| 2410 | delete [] RhoArray; |
| 2411 | delete [] pTArray; |
| ac6a3f1e |
2412 | } |
| 2413 | |
| c6202663 |
2414 | void AliAnalysisTaskFullpAJets::EstimateFullRhoCMS() |
| ac6a3f1e |
2415 | { |
| c6202663 |
2416 | Int_t i,k; |
| 2417 | Double_t kTRho = 0.0; |
| 2418 | Double_t CMSTotalkTArea = 0.0; |
| 2419 | Double_t CMSParticleArea = 0.0; |
| 2420 | Double_t CMSCorrectionFactor = 1.0; |
| 2421 | Double_t *pTArray = new Double_t[fEMCalkTFullJet->GetTotalJets()]; |
| 2422 | Double_t *RhoArray = new Double_t[fEMCalkTFullJet->GetTotalJets()]; |
| 2423 | |
| 2424 | k=0; |
| 2425 | if ((fEMCalPartJet->GetLeadingPt()>=fEMCalJetThreshold) && (fEMCalPartJet->GetSubLeadingPt()>=fEMCalJetThreshold)) |
| 2426 | { |
| 2427 | AliEmcalJet *myJet1 =(AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetLeadingIndex()); |
| 2428 | AliEmcalJet *myJet2 =(AliEmcalJet*) fmyAKTFullJets->At(fEMCalPartJet->GetSubLeadingIndex()); |
| 78246241 |
2429 | |
| c6202663 |
2430 | for (i=0;i<fEMCalkTFullJet->GetTotalJets();i++) |
| 78246241 |
2431 | { |
| c6202663 |
2432 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTFullJets->At(fEMCalkTFullJet->GetJetIndex(i)); |
| 2433 | |
| 2434 | CMSTotalkTArea+=myJet->Area(); |
| 2435 | if (myJet->GetNumberOfTracks()>0 || myJet->GetNumberOfClusters()>0) |
| 2436 | { |
| 2437 | CMSParticleArea+=myJet->Area(); |
| 2438 | } |
| 2439 | if (IsJetOverlap(myJet,myJet1,kTRUE)==kFALSE && IsJetOverlap(myJet,myJet2,kFALSE)==kTRUE) |
| 2440 | { |
| 2441 | pTArray[k]=myJet->Pt(); |
| 2442 | RhoArray[k]=myJet->Pt()/myJet->Area(); |
| 2443 | k++; |
| 2444 | } |
| 78246241 |
2445 | } |
| c6202663 |
2446 | if (k>0) |
| ac6a3f1e |
2447 | { |
| c6202663 |
2448 | kTRho=MedianRhokT(pTArray,RhoArray,k); |
| ac6a3f1e |
2449 | } |
| 2450 | else |
| 2451 | { |
| c6202663 |
2452 | kTRho=0.0; |
| 2453 | } |
| 2454 | } |
| 2455 | else if (fEMCalJet->GetLeadingPt()>=fEMCalJetThreshold) |
| 2456 | { |
| 2457 | AliEmcalJet *myJet1 =(AliEmcalJet*) fmyAKTFullJets->At(fEMCalJet->GetLeadingIndex()); |
| 2458 | |
| 2459 | for (i=0;i<fEMCalkTFullJet->GetTotalJets();i++) |
| 2460 | { |
| 2461 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTFullJets->At(fEMCalkTFullJet->GetJetIndex(i)); |
| 2462 | |
| 2463 | CMSTotalkTArea+=myJet->Area(); |
| 2464 | if (myJet->GetNumberOfTracks()>0 || myJet->GetNumberOfClusters()>0) |
| ac6a3f1e |
2465 | { |
| c6202663 |
2466 | CMSParticleArea+=myJet->Area(); |
| ac6a3f1e |
2467 | } |
| c6202663 |
2468 | if (IsJetOverlap(myJet,myJet1,kTRUE)==kFALSE) |
| ac6a3f1e |
2469 | { |
| c6202663 |
2470 | pTArray[k]=myJet->Pt(); |
| 2471 | RhoArray[k]=myJet->Pt()/myJet->Area(); |
| 2472 | k++; |
| ac6a3f1e |
2473 | } |
| ac6a3f1e |
2474 | } |
| c6202663 |
2475 | if (k>0) |
| ac6a3f1e |
2476 | { |
| c6202663 |
2477 | kTRho=MedianRhokT(pTArray,RhoArray,k); |
| 2478 | } |
| 2479 | else |
| 2480 | { |
| 2481 | kTRho=0.0; |
| ac6a3f1e |
2482 | } |
| 2483 | } |
| c6202663 |
2484 | else |
| ac6a3f1e |
2485 | { |
| c6202663 |
2486 | for (i=0;i<fEMCalkTFullJet->GetTotalJets();i++) |
| ac6a3f1e |
2487 | { |
| c6202663 |
2488 | AliEmcalJet *myJet =(AliEmcalJet*) fmyKTFullJets->At(fEMCalkTFullJet->GetJetIndex(i)); |
| 2489 | |
| 2490 | CMSTotalkTArea+=myJet->Area(); |
| 2491 | if (myJet->GetNumberOfTracks()>0 || myJet->GetNumberOfClusters()>0) |
| ac6a3f1e |
2492 | { |
| c6202663 |
2493 | CMSParticleArea+=myJet->Area(); |
| ac6a3f1e |
2494 | } |
| c6202663 |
2495 | pTArray[k]=myJet->Pt(); |
| 2496 | RhoArray[k]=myJet->Pt()/myJet->Area(); |
| 2497 | k++; |
| 2498 | } |
| 2499 | if (k>0) |
| 2500 | { |
| 2501 | kTRho=MedianRhokT(pTArray,RhoArray,k); |
| 2502 | } |
| 2503 | else |
| 2504 | { |
| 2505 | kTRho=0.0; |
| ac6a3f1e |
2506 | } |
| 2507 | } |
| c6202663 |
2508 | // Scale CMS Rho by Correction factor |
| 2509 | if (CMSTotalkTArea==0.0) |
| 78246241 |
2510 | { |
| c6202663 |
2511 | CMSCorrectionFactor = 1.0; |
| 78246241 |
2512 | } |
| c6202663 |
2513 | else |
| 78246241 |
2514 | { |
| c6202663 |
2515 | //CMSCorrectionFactor = CMSTrackArea/CMSTotalkTArea; |
| 2516 | CMSCorrectionFactor = CMSParticleArea/((fEMCalPhiTotal-2*fJetR)*(fEMCalEtaTotal-2*fJetR)); // The total physical area should be reduced by the eta & phi cuts due to looping over only fully contained kT jets within the EMCal |
| 78246241 |
2517 | } |
| c6202663 |
2518 | kTRho*=CMSCorrectionFactor; |
| 78246241 |
2519 | |
| c6202663 |
2520 | fRhoFullCMS->FillRho(fEventCentrality,kTRho); |
| 2521 | fRhoFullCMS->FillBSJS(fEventCentrality,kTRho,fEMCalJetThreshold,fmyAKTFullJets,fEMCalFullJet->GetJets(),fEMCalFullJet->GetTotalJets()); |
| 2522 | fRhoFullCMS->FillDeltaPt(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFluc,1); |
| 2523 | fRhoFullCMS->FillDeltaPtSignal(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFlucSignal,1); |
| 7acc3e04 |
2524 | fRhoFullCMS->FillDeltaPtNColl(fEventCentrality,kTRho,fJetR,fEMCalRCBckgFlucNColl,1); |
| c6202663 |
2525 | fRhoFullCMS->FillBackgroundFluctuations(fEventCentrality,kTRho,fJetR); |
| 2526 | fRhoFullCMS->FillLeadingJetPtRho(fEMCalFullJet->GetLeadingPt(),kTRho); |
| 2527 | delete [] RhoArray; |
| 2528 | delete [] pTArray; |
| 78246241 |
2529 | } |
| 2530 | |
| ac6a3f1e |
2531 | void AliAnalysisTaskFullpAJets::JetPtChargedProfile() |
| 2532 | { |
| 2533 | Int_t i,j; |
| 2534 | Double_t delta_R; |
| 2535 | Double_t ED_pT[fEDProfileRBins]; |
| 2536 | |
| c6202663 |
2537 | for (i=0;i<fTPCFullJet->GetTotalSignalJets();i++) |
| ac6a3f1e |
2538 | { |
| c6202663 |
2539 | AliEmcalJet *myJet = (AliEmcalJet*) fmyAKTChargedJets->At(fTPCFullJet->GetSignalJetIndex(i)); |
| ac6a3f1e |
2540 | if (InsideRect(myJet->Phi(),fTPCPhiMin,fTPCPhiMax,myJet->Eta(),fTPCEtaMin+fEDProfileRUp,fTPCEtaMax-fEDProfileRUp)==kTRUE) |
| 2541 | { |
| 2542 | for (j=0;j<fEDProfileRBins;j++) |
| 2543 | { |
| 2544 | ED_pT[j]=0; |
| 2545 | } |
| 2546 | TLorentzVector *jet_vec= new TLorentzVector; |
| 2547 | myJet->GetMom(*jet_vec); |
| 2548 | // Sum all tracks in concentric rings around jet vertex |
| 2549 | for (j=0;j<fnTracks;j++) |
| 2550 | { |
| 2551 | AliVTrack* vtrack = (AliVTrack*) fmyTracks->At(j); |
| 2552 | TLorentzVector *track_vec = new TLorentzVector; |
| 2553 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 2554 | delta_R=jet_vec->DeltaR(*track_vec); |
| 2555 | if (delta_R<=fEDProfileRUp) |
| 2556 | { |
| 2557 | ED_pT[TMath::FloorNint((fEDProfileRBins/fEDProfileRUp)*delta_R)]+=vtrack->Pt(); |
| 2558 | } |
| 2559 | delete track_vec; |
| 2560 | } |
| 2561 | |
| ac6a3f1e |
2562 | for (j=0;j<fEDProfileRBins;j++) |
| 2563 | { |
| 2564 | ED_pT[j]/=TMath::Pi()*TMath::Power((fEDProfileRUp/fEDProfileRBins),2)*(2*j+1); |
| ac6a3f1e |
2565 | fpChargedJetEDProfile[TMath::FloorNint(fEventCentrality/10.)]->Fill(myJet->Pt(),myJet->Eta(),(fEDProfileRUp/fEDProfileRBins)*j,ED_pT[j]); |
| 2566 | if (fEventCentrality<=20) |
| 2567 | { |
| 2568 | fpChargedJetRProfile[4+TMath::FloorNint(myJet->Eta()*10.)]->Fill((fEDProfileRUp/fEDProfileRBins)*j,ED_pT[j]); |
| 2569 | } |
| 2570 | } |
| 2571 | delete jet_vec; |
| 2572 | } |
| 2573 | } |
| 2574 | } |
| 2575 | |
| 2576 | void AliAnalysisTaskFullpAJets::JetPtFullProfile() |
| 2577 | { |
| 2578 | Int_t i,j; |
| 2579 | Double_t delta_R; |
| 2580 | Double_t ED_pT[fEDProfileRBins]; |
| 2581 | |
| c6202663 |
2582 | for (i=0;i<fEMCalFullJet->GetTotalSignalJets();i++) |
| ac6a3f1e |
2583 | { |
| c6202663 |
2584 | AliEmcalJet *myJet = (AliEmcalJet*) fmyAKTFullJets->At(fEMCalFullJet->GetSignalJetIndex(i)); |
| ac6a3f1e |
2585 | if (InsideRect(myJet->Phi(),fEMCalPhiMin+fEDProfileRUp,fEMCalPhiMax-fEDProfileRUp,myJet->Eta(),fEMCalEtaMin+fEDProfileRUp,fEMCalEtaMax-fEDProfileRUp)==kTRUE) |
| 2586 | { |
| 2587 | for (j=0;j<fEDProfileRBins;j++) |
| 2588 | { |
| 2589 | ED_pT[j]=0; |
| 2590 | } |
| 2591 | TLorentzVector *jet_vec= new TLorentzVector; |
| 2592 | myJet->GetMom(*jet_vec); |
| 2593 | // Sum all tracks in concentric rings around jet vertex |
| 2594 | for (j=0;j<fnTracks;j++) |
| 2595 | { |
| 2596 | AliVTrack* vtrack = (AliVTrack*) fmyTracks->At(j); |
| 2597 | TLorentzVector *track_vec = new TLorentzVector; |
| 2598 | track_vec->SetPtEtaPhiE(vtrack->Pt(),vtrack->Eta(),vtrack->Phi(),vtrack->E()); |
| 2599 | delta_R=jet_vec->DeltaR(*track_vec); |
| 2600 | if (delta_R<=fEDProfileRUp) |
| 2601 | { |
| 2602 | ED_pT[TMath::FloorNint((fEDProfileRBins/fEDProfileRUp)*delta_R)]+=vtrack->Pt(); |
| 2603 | } |
| 2604 | delete track_vec; |
| 2605 | } |
| 2606 | |
| 2607 | // Sum all clusters in concentric rings around jet vertex |
| 2608 | for (j=0;j<fnClusters;j++) |
| 2609 | { |
| 2610 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(j); |
| 2611 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 2612 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 2613 | delta_R=jet_vec->DeltaR(*cluster_vec); |
| 2614 | if (delta_R<=fEDProfileRUp) |
| 2615 | { |
| 2616 | ED_pT[TMath::FloorNint((fEDProfileRBins/fEDProfileRUp)*delta_R)]+=vcluster->E(); |
| 2617 | } |
| 2618 | delete cluster_vec; |
| 2619 | } |
| 2620 | |
| 2621 | for (j=0;j<fEDProfileRBins;j++) |
| 2622 | { |
| 2623 | ED_pT[j]/=TMath::Pi()*TMath::Power((fEDProfileRUp/fEDProfileRBins),2)*(2*j+1); |
| 2624 | fpJetEDProfile[TMath::FloorNint(fEventCentrality/10.)]->Fill(myJet->Pt(),myJet->Eta(),(fEDProfileRUp/fEDProfileRBins)*j,ED_pT[j]); |
| 2625 | // Fill profile if a "most" central event (0-20%) |
| 2626 | if (fEventCentrality<=20) |
| 2627 | { |
| 2628 | fpJetRProfile[2+TMath::FloorNint(myJet->Eta()*10.)]->Fill((fEDProfileRUp/fEDProfileRBins)*j,ED_pT[j]); |
| 2629 | } |
| 2630 | } |
| 2631 | delete jet_vec; |
| 2632 | |
| 2633 | // Fill constituent histogram |
| 2634 | for (j=0;j<myJet->GetNumberOfTracks();j++) |
| 2635 | { |
| c6202663 |
2636 | AliVTrack* vtrack = (AliVTrack*) fOrgTracks->At(myJet->TrackAt(j)); |
| 2637 | fhJetConstituentPt->Fill(myJet->Pt(),vtrack->Pt()); |
| ac6a3f1e |
2638 | } |
| 2639 | |
| 2640 | for (j=0;j<myJet->GetNumberOfClusters();j++) |
| 2641 | { |
| c6202663 |
2642 | AliVCluster* vcluster = (AliVCluster*) fOrgClusters->At(myJet->ClusterAt(j)); |
| 2643 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 2644 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 2645 | fhJetConstituentPt->Fill(myJet->Pt(),cluster_vec->Pt()); |
| 2646 | delete cluster_vec; |
| ac6a3f1e |
2647 | } |
| 2648 | } |
| 2649 | } |
| 2650 | } |
| 2651 | |
| 2652 | void AliAnalysisTaskFullpAJets::JetPtEtaProfile() |
| 2653 | { |
| 2654 | Int_t i,j; |
| 2655 | Double_t eta; |
| 2656 | Double_t delta_eta; |
| 2657 | Double_t Eta_pT[fEtaProfileBins]; |
| 2658 | Double_t Eta_abs_pT[Int_t(0.5*fEtaProfileBins)]; |
| 2659 | |
| c6202663 |
2660 | for (i=0;i<fEMCalFullJet->GetTotalSignalJets();i++) |
| ac6a3f1e |
2661 | { |
| c6202663 |
2662 | AliEmcalJet *myJet = (AliEmcalJet*) fmyAKTFullJets->At(fEMCalFullJet->GetSignalJetIndex(i)); |
| ac6a3f1e |
2663 | if (IsInEMCal(myJet->Phi(),myJet->Eta())==kTRUE) |
| 2664 | { |
| 2665 | for (j=0;j<fEtaProfileBins;j++) |
| 2666 | { |
| 2667 | Eta_pT[j]=0; |
| 2668 | Eta_abs_pT[j]=0; |
| 2669 | } |
| 2670 | |
| 2671 | // Sum all tracks in strips of eta away from the jet vertex |
| 2672 | for (j=0;j<fnTracks;j++) |
| 2673 | { |
| 2674 | AliVTrack* vtrack = (AliVTrack*) fmyTracks->At(j); |
| 2675 | eta=vtrack->Eta(); |
| 2676 | delta_eta=TMath::Abs(vtrack->Eta()-myJet->Eta()); |
| 2677 | if (IsInEMCal(vtrack->Phi(),vtrack->Eta())==kTRUE) |
| 2678 | { |
| 2679 | Eta_pT[Int_t(0.5*fEtaProfileBins)+TMath::FloorNint(10*eta)]+=vtrack->Pt(); |
| 2680 | Eta_abs_pT[TMath::FloorNint(10*delta_eta)]+=vtrack->Pt(); |
| 2681 | } |
| 2682 | } |
| 2683 | |
| 2684 | // Sum all clusters in strips of eta away from the jet vertex |
| 2685 | for (j=0;j<fnClusters;j++) |
| 2686 | { |
| 2687 | AliVCluster* vcluster = (AliVCluster*) fmyClusters->At(j); |
| 2688 | TLorentzVector *cluster_vec = new TLorentzVector; |
| 2689 | vcluster->GetMomentum(*cluster_vec,fvertex); |
| 2690 | eta=cluster_vec->Eta(); |
| 2691 | delta_eta=TMath::Abs(cluster_vec->Eta()-myJet->Eta()); |
| 2692 | Eta_pT[Int_t(0.5*fEtaProfileBins)+TMath::FloorNint(10*eta)]+=vcluster->E(); |
| 2693 | Eta_abs_pT[TMath::FloorNint(10*delta_eta)]+=vcluster->E(); |
| 2694 | delete cluster_vec; |
| 2695 | } |
| 2696 | |
| 2697 | for (j=0;j<fEtaProfileBins;j++) |
| 2698 | { |
| 2699 | Eta_pT[j]/=0.1*fEMCalPhiTotal; |
| 2700 | // Fill profile if a "most" central event (0-20%) |
| 2701 | if (j<(10*(fEMCalEtaMax-TMath::Abs(myJet->Eta())))) |
| 2702 | { |
| 2703 | Eta_abs_pT[j]/=0.2*fEMCalPhiTotal; |
| 2704 | } |
| 2705 | else |
| 2706 | { |
| 2707 | Eta_abs_pT[j]/=0.1*fEMCalPhiTotal; |
| 2708 | } |
| 2709 | // Fill profile if a "most" central event (0-20%) |
| 2710 | if (fEventCentrality<=20) |
| 2711 | { |
| 2712 | fpJetAbsEtaProfile[7+TMath::FloorNint(myJet->Eta()*10.)]->Fill(0.1*j,Eta_abs_pT[j]); |
| 2713 | fpJetEtaProfile[7+TMath::FloorNint(myJet->Eta()*10.)]->Fill(0.1*(j-7),Eta_pT[j]); |
| 2714 | } |
| 2715 | } |
| 2716 | } |
| 2717 | } |
| 2718 | } |
| 2719 | |
| c6202663 |
2720 | void AliAnalysisTaskFullpAJets::DeleteJetData(Bool_t EMCalOn) |
| ac6a3f1e |
2721 | { |
| c6202663 |
2722 | delete fmyTracks; |
| 2723 | delete fTPCJet; |
| 2724 | delete fTPCFullJet; |
| 2725 | delete fTPCOnlyJet; |
| 2726 | delete fTPCkTFullJet; |
| ac6a3f1e |
2727 | if (EMCalOn==kTRUE) |
| 2728 | { |
| c6202663 |
2729 | delete fmyClusters; |
| 2730 | delete fEMCalJet; |
| 2731 | delete fEMCalFullJet; |
| 2732 | delete fEMCalPartJet; |
| 2733 | delete fEMCalkTFullJet; |
| ac6a3f1e |
2734 | } |
| 2735 | } |
| 2736 | |
| 2737 | ///////////////////////////////////////////////////////////////////////////////////////// |
| 2738 | ///////////////// User Defined Functions /////////////////////////////////////// |
| 2739 | ///////////////////////////////////////////////////////////////////////////////////////// |
| 2740 | |
| 2741 | Bool_t AliAnalysisTaskFullpAJets::IsDiJetEvent() |
| 2742 | { |
| 78246241 |
2743 | // Determine if event contains a di-jet within the detector. Uses charged jets. |
| 2744 | // Requires the delta phi of the jets to be 180 +/- 15 degrees. |
| 2745 | // Requires both jets to be outside of the EMCal |
| 2746 | // Requires both jets to be signal jets |
| 2747 | |
| ac6a3f1e |
2748 | const Double_t dijet_delta_phi=(180/360.)*2*TMath::Pi(); |
| 2749 | const Double_t dijet_phi_acceptance=0.5*(30/360.)*2*TMath::Pi(); //Input the total acceptance within the paraenthesis to be +/- dijet_phi_acceptance |
| 78246241 |
2750 | Double_t dummy_phi=0.0; |
| c6202663 |
2751 | |
| 2752 | if (fTPCOnlyJet->GetTotalSignalJets()>1) |
| 2753 | { |
| 2754 | AliEmcalJet *myhJet =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCOnlyJet->GetLeadingIndex()); |
| 2755 | AliEmcalJet *myJet =(AliEmcalJet*) fmyAKTChargedJets->At(fTPCOnlyJet->GetSubLeadingIndex()); |
| 2756 | dummy_phi=TMath::Min(TMath::Abs(myhJet->Phi()-myJet->Phi()),2*TMath::Pi()-TMath::Abs(myhJet->Phi()-myJet->Phi())); |
| 2757 | if (dummy_phi>(dijet_delta_phi-dijet_phi_acceptance)) |
| 2758 | { |
| 2759 | fnDiJetEvents++; |
| 2760 | return kTRUE; |
| ac6a3f1e |
2761 | } |
| 2762 | } |
| 2763 | return kFALSE; |
| 2764 | } |
| 2765 | |
| 2766 | Bool_t AliAnalysisTaskFullpAJets::InsideRect(Double_t phi,Double_t phi_min,Double_t phi_max,Double_t eta,Double_t eta_min,Double_t eta_max) |
| 2767 | { |
| 2768 | if (phi>phi_min && phi<phi_max) |
| 2769 | { |
| 2770 | if (eta>eta_min && eta<eta_max) |
| 2771 | { |
| 2772 | return kTRUE; |
| 2773 | } |
| 2774 | } |
| 2775 | return kFALSE; |
| 2776 | } |
| 2777 | |
| 2778 | Bool_t AliAnalysisTaskFullpAJets::IsInEMCal(Double_t phi,Double_t eta) |
| 2779 | { |
| 2780 | return InsideRect(phi,fEMCalPhiMin,fEMCalPhiMax,eta,fEMCalEtaMin,fEMCalEtaMax); |
| 2781 | } |
| 2782 | |
| 2783 | Bool_t AliAnalysisTaskFullpAJets::IsInEMCalFull(Double_t r,Double_t phi,Double_t eta) |
| 2784 | { |
| 2785 | return InsideRect(phi,fEMCalPhiMin+r,fEMCalPhiMax-r,eta,fEMCalEtaMin+r,fEMCalEtaMax-r); |
| 2786 | } |
| 2787 | |
| 2788 | Bool_t AliAnalysisTaskFullpAJets::IsInEMCalPart(Double_t r,Double_t phi,Double_t eta) |
| 2789 | { |
| 2790 | return InsideRect(phi,fEMCalPhiMin-r,fEMCalPhiMax+r,eta,fEMCalEtaMin-r,fEMCalEtaMax+r); |
| 2791 | } |
| 2792 | |
| 2793 | Bool_t AliAnalysisTaskFullpAJets::IsInTPCFull(Double_t r,Double_t phi,Double_t eta) |
| 2794 | { |
| 2795 | Bool_t in_EMCal= InsideRect(phi,fEMCalPhiMin-r,fEMCalPhiMax+r,eta,fEMCalEtaMin-r,fEMCalEtaMax+r); |
| 2796 | Bool_t in_TPC= InsideRect(phi,fTPCPhiMin,fTPCPhiMax,eta,fTPCEtaMin+r,fTPCEtaMax-r); |
| 2797 | |
| 2798 | if (in_EMCal==kFALSE && in_TPC==kTRUE) |
| 2799 | { |
| 2800 | return kTRUE; |
| 2801 | } |
| 2802 | return kFALSE; |
| 2803 | } |
| 2804 | |
| 2805 | Bool_t AliAnalysisTaskFullpAJets::IsInTPC(Double_t r,Double_t phi,Double_t eta,Bool_t Complete) |
| 2806 | { |
| 2807 | if (Complete==kTRUE) |
| 2808 | { |
| 2809 | return InsideRect(phi,fTPCPhiMin,fTPCPhiMax,eta,fTPCEtaMin+r,fTPCEtaMax-r); |
| 2810 | } |
| 2811 | return InsideRect(phi,fTPCPhiMin,fTPCPhiMax,eta,fTPCEtaMin,fTPCEtaMax); |
| 2812 | } |
| 2813 | |
| c6202663 |
2814 | Bool_t AliAnalysisTaskFullpAJets::IsJetOverlap(AliEmcalJet *jet1,AliEmcalJet *jet2,Bool_t EMCalOn) |
| 2815 | { |
| 2816 | Int_t i,j; |
| 2817 | Int_t jetTrack1=0; |
| 2818 | Int_t jetTrack2=0; |
| 2819 | Int_t jetCluster1=0; |
| 2820 | Int_t jetCluster2=0; |
| 2821 | |
| 2822 | for (i=0;i<jet1->GetNumberOfTracks();i++) |
| 2823 | { |
| 2824 | jetTrack1=jet1->TrackAt(i); |
| 2825 | for (j=0;j<jet2->GetNumberOfTracks();j++) |
| 2826 | { |
| 2827 | jetTrack2=jet2->TrackAt(j); |
| 2828 | if (jetTrack1 == jetTrack2) |
| 2829 | { |
| 2830 | return kTRUE; |
| 2831 | } |
| 2832 | } |
| 2833 | } |
| 2834 | if (EMCalOn == kTRUE) |
| 2835 | { |
| 2836 | for (i=0;i<jet1->GetNumberOfClusters();i++) |
| 2837 | { |
| 2838 | jetCluster1=jet1->ClusterAt(i); |
| 2839 | for (j=0;j<jet2->GetNumberOfClusters();j++) |
| 2840 | { |
| 2841 | jetCluster2=jet2->ClusterAt(j); |
| 2842 | if (jetCluster1 == jetCluster2) |
| 2843 | { |
| 2844 | return kTRUE; |
| 2845 | } |
| 2846 | } |
| 2847 | } |
| 2848 | } |
| 2849 | return kFALSE; |
| 2850 | } |
| 2851 | |
| ac6a3f1e |
2852 | Double_t AliAnalysisTaskFullpAJets::AreaWithinTPC(Double_t r,Double_t eta) |
| 2853 | { |
| 2854 | Double_t z; |
| 2855 | if (eta<(fTPCEtaMin+r)) |
| 2856 | { |
| 2857 | z=eta-fTPCEtaMin; |
| 2858 | } |
| 2859 | else if(eta>(fTPCEtaMax-r)) |
| 2860 | { |
| 2861 | z=fTPCEtaMax-eta; |
| 2862 | } |
| 2863 | else |
| 2864 | { |
| 2865 | z=r; |
| 2866 | } |
| 2867 | return r*r*TMath::Pi()-AreaEdge(r,z); |
| 2868 | } |
| 2869 | |
| 2870 | Double_t AliAnalysisTaskFullpAJets::AreaWithinEMCal(Double_t r,Double_t phi,Double_t eta) |
| 2871 | { |
| 2872 | Double_t x,y; |
| 2873 | |
| 2874 | if (phi<(fEMCalPhiMin-r) || phi>(fEMCalPhiMax+r)) |
| 2875 | { |
| 2876 | x=-r; |
| 2877 | } |
| 2878 | else if (phi<(fEMCalPhiMin+r)) |
| 2879 | { |
| 2880 | x=phi-fEMCalPhiMin; |
| 2881 | } |
| 2882 | else if (phi>(fEMCalPhiMin+r) && phi<(fEMCalPhiMax-r)) |
| 2883 | { |
| 2884 | x=r; |
| 2885 | } |
| 2886 | else |
| 2887 | { |
| 2888 | x=fEMCalPhiMax-phi; |
| 2889 | } |
| 2890 | |
| 2891 | if (eta<(fEMCalEtaMin-r) || eta>(fEMCalEtaMax+r)) |
| 2892 | { |
| 2893 | y=-r; |
| 2894 | } |
| 2895 | else if (eta<(fEMCalEtaMin+r)) |
| 2896 | { |
| 2897 | y=eta-fEMCalEtaMin; |
| 2898 | } |
| 2899 | else if (eta>(fEMCalEtaMin+r) && eta<(fEMCalEtaMax-r)) |
| 2900 | { |
| 2901 | y=r; |
| 2902 | } |
| 2903 | else |
| 2904 | { |
| 2905 | y=fEMCalEtaMax-eta; |
| 2906 | } |
| 2907 | |
| 2908 | if (x>=0 && y>=0) |
| 2909 | { |
| 2910 | if (TMath::Sqrt(x*x+y*y)>=r) |
| 2911 | { |
| 2912 | return r*r*TMath::Pi()-AreaEdge(r,x)-AreaEdge(r,y); |
| 2913 | } |
| 2914 | return r*r*TMath::Pi()-AreaEdge(r,x)-AreaEdge(r,y)+AreaOverlap(r,x,y); |
| 2915 | } |
| 2916 | else if ((x>=r && y<0) || (y>=r && x<0)) |
| 2917 | { |
| 2918 | return r*r*TMath::Pi()-AreaEdge(r,x)-AreaEdge(r,y); |
| 2919 | } |
| 2920 | else if (x>0 && x<r && y<0) |
| 2921 | { |
| 2922 | Double_t a=TMath::Sqrt(r*r-x*x); |
| 2923 | Double_t b=TMath::Sqrt(r*r-y*y); |
| 2924 | if ((x-b)>0) |
| 2925 | { |
| 2926 | return r*r*TMath::ASin(b/r)+y*b; |
| 2927 | } |
| 2928 | else |
| 2929 | { |
| 2930 | return 0.5*x*a+0.5*r*r*TMath::ASin(x/r)+0.5*y*b+x*y+0.5*r*r*TMath::ASin(b/r); |
| 2931 | } |
| 2932 | } |
| 2933 | else if (y>0 && y<r && x<0) |
| 2934 | { |
| 2935 | Double_t a=TMath::Sqrt(r*r-x*x); |
| 2936 | Double_t b=TMath::Sqrt(r*r-y*y); |
| 2937 | if ((y-a)>0) |
| 2938 | { |
| 2939 | return r*r*TMath::ASin(a/r)+x*a; |
| 2940 | } |
| 2941 | else |
| 2942 | { |
| 2943 | return 0.5*y*b+0.5*r*r*TMath::ASin(y/r)+0.5*x*a+x*y+0.5*r*r*TMath::ASin(a/r); |
| 2944 | } |
| 2945 | } |
| 2946 | else |
| 2947 | { |
| 2948 | Double_t a=TMath::Sqrt(r*r-x*x); |
| 2949 | Double_t b=TMath::Sqrt(r*r-y*y); |
| 2950 | if ((x+b)<0) |
| 2951 | { |
| 2952 | return 0; |
| 2953 | } |
| 2954 | else |
| 2955 | { |
| 2956 | return 0.5*x*a+0.5*r*r*TMath::ASin(x/r)+0.5*y*b+x*y+0.5*r*r*TMath::ASin(b/r); |
| 2957 | } |
| 2958 | } |
| 2959 | } |
| 2960 | |
| 2961 | Double_t AliAnalysisTaskFullpAJets::AreaEdge(Double_t r,Double_t z) |
| 2962 | { |
| 2963 | Double_t a=TMath::Sqrt(r*r-z*z); |
| 2964 | return r*r*TMath::ASin(a/r)-a*z; |
| 2965 | } |
| 2966 | |
| 2967 | Double_t AliAnalysisTaskFullpAJets::AreaOverlap(Double_t r,Double_t x,Double_t y) |
| 2968 | { |
| 2969 | Double_t a=TMath::Sqrt(r*r-x*x); |
| 2970 | Double_t b=TMath::Sqrt(r*r-y*y); |
| 2971 | return x*y-0.5*(x*a+y*b)+0.5*r*r*(TMath::ASin(b/r)-TMath::ASin(x/r)); |
| 2972 | } |
| 2973 | |
| 2974 | Double_t AliAnalysisTaskFullpAJets::TransverseArea(Double_t r,Double_t psi0,Double_t phi,Double_t eta) |
| 2975 | { |
| c6202663 |
2976 | Double_t area_left=0; |
| 2977 | Double_t area_right=0; |
| 2978 | Double_t eta_a=0; |
| 2979 | Double_t eta_b=0; |
| 2980 | Double_t eta_up=0; |
| 2981 | Double_t eta_down=0; |
| ac6a3f1e |
2982 | |
| 2983 | Double_t u=eta-fEMCalEtaMin; |
| 2984 | Double_t v=fEMCalEtaMax-eta; |
| 2985 | |
| 2986 | Double_t phi1=phi+u*TMath::Tan(psi0); |
| 2987 | Double_t phi2=phi-u*TMath::Tan(psi0); |
| 2988 | Double_t phi3=phi+v*TMath::Tan(psi0); |
| 2989 | Double_t phi4=phi-v*TMath::Tan(psi0); |
| 2990 | |
| 2991 | //Calculate the Left side area |
| 2992 | if (phi1>=fEMCalPhiMax) |
| 2993 | { |
| 2994 | eta_a=eta-u*((fEMCalPhiMax-phi)/(phi1-phi)); |
| 2995 | } |
| 2996 | if (phi2<=fEMCalPhiMin) |
| 2997 | { |
| 2998 | eta_b=eta-u*((phi-fEMCalPhiMin)/(phi-phi2)); |
| 2999 | } |
| 3000 | |
| 3001 | if ((phi1>=fEMCalPhiMax) && (phi2<=fEMCalPhiMin)) |
| 3002 | { |
| 3003 | eta_up=TMath::Max(eta_a,eta_b); |
| 3004 | eta_down=TMath::Min(eta_a,eta_b); |
| 3005 | |
| 3006 | area_left=(eta_down-fEMCalEtaMin)*fEMCalPhiTotal + 0.5*(fEMCalPhiTotal+2*(eta-eta_up)*TMath::Tan(psi0))*(eta_up-eta_down) + (eta-eta_up+r)*TMath::Tan(psi0)*(eta-eta_up-r); |
| 3007 | } |
| 3008 | else if (phi1>=fEMCalPhiMax) |
| 3009 | { |
| 3010 | area_left=0.5*(fEMCalPhiMax-phi2+2*(eta-eta_a)*TMath::Tan(psi0))*(eta_a-fEMCalEtaMin) + (eta-eta_a+r)*TMath::Tan(psi0)*(eta-eta_a-r); |
| 3011 | } |
| 3012 | else if (phi2<=fEMCalPhiMin) |
| 3013 | { |
| 3014 | area_left=0.5*(phi1-fEMCalPhiMin+2*(eta-eta_b)*TMath::Tan(psi0))*(eta_b-fEMCalEtaMin) + (eta-eta_b+r)*TMath::Tan(psi0)*(eta-eta_b-r); |
| 3015 | } |
| 3016 | else |
| 3017 | { |
| 3018 | area_left=0.5*(phi1-phi2+2*r*TMath::Tan(psi0))*(u-r); |
| 3019 | } |
| 3020 | |
| c6202663 |
3021 | // Calculate the Right side area |
| ac6a3f1e |
3022 | if (phi3>=fEMCalPhiMax) |
| 3023 | { |
| 3024 | eta_a=eta+v*((fEMCalPhiMax-phi)/(phi3-phi)); |
| 3025 | } |
| 3026 | if (phi4<=fEMCalPhiMin) |
| 3027 | { |
| 3028 | eta_b=eta+v*((phi-fEMCalPhiMin)/(phi-phi4)); |
| 3029 | } |
| 3030 | |
| 3031 | if ((phi3>=fEMCalPhiMax) && (phi4<=fEMCalPhiMin)) |
| 3032 | { |
| 3033 | eta_up=TMath::Max(eta_a,eta_b); |
| 3034 | eta_down=TMath::Min(eta_a,eta_b); |
| 3035 | |
| 3036 | area_right=(fEMCalEtaMax-eta_up)*fEMCalPhiTotal + 0.5*(fEMCalPhiTotal+2*(eta_down-eta)*TMath::Tan(psi0))*(eta_down-eta_up) + (eta_down-eta+r)*TMath::Tan(psi0)*(eta_up-eta-r); |
| 3037 | } |
| 3038 | else if (phi3>=fEMCalPhiMax) |
| 3039 | { |
| 3040 | area_right=0.5*(fEMCalPhiMax-phi4+2*(eta_a-eta)*TMath::Tan(psi0))*(fEMCalEtaMax-eta_a) + (eta_a-eta+r)*TMath::Tan(psi0)*(eta_a-eta-r); |
| 3041 | } |
| 3042 | else if (phi4<=fEMCalPhiMin) |
| 3043 | { |
| 3044 | area_right=0.5*(phi3-fEMCalPhiMin+2*(eta_b-eta)*TMath::Tan(psi0))*(fEMCalEtaMax-eta_b) + (eta_b-eta+r)*TMath::Tan(psi0)*(eta_b-eta-r); |
| 3045 | } |
| 3046 | else |
| 3047 | { |
| 3048 | area_right=0.5*(phi3-phi4+2*r*TMath::Tan(psi0))*(v-r); |
| 3049 | } |
| 3050 | return area_left+area_right; |
| 3051 | } |
| c6202663 |
3052 | |
| 3053 | Double_t AliAnalysisTaskFullpAJets::MedianRhokT(Double_t *pTkTEntries, Double_t *RhokTEntries, Int_t nEntries) |
| 3054 | { |
| 3055 | // This function is used to calculate the median Rho kT value. The procedure is: |
| 3056 | // - Order the kT cluster array from highest rho value to lowest |
| 3057 | // - Exclude highest rho kT cluster |
| 3058 | // - Return the median rho value of the remaining subset |
| 3059 | |
| 3060 | // Sort Array |
| 3061 | const Double_t rho_min=-9.9999E+99; |
| 3062 | Int_t j,k; |
| 3063 | Double_t w[nEntries]; // Used for sorting |
| 3064 | Double_t smax=rho_min; |
| 3065 | Int_t sindex=-1; |
| 3066 | |
| 3067 | Double_t pTmax=0.0; |
| 3068 | Int_t pTmaxID=-1; |
| 3069 | |
| 3070 | for (j=0;j<nEntries;j++) |
| 3071 | { |
| 3072 | w[j]=0.0; |
| 3073 | } |
| 3074 | |
| 3075 | for (j=0;j<nEntries;j++) |
| 3076 | { |
| 3077 | if (pTkTEntries[j]>pTmax) |
| 3078 | { |
| 3079 | pTmax=pTkTEntries[j]; |
| 3080 | pTmaxID=j; |
| 3081 | } |
| 3082 | } |
| 3083 | |
| 3084 | for (j=0;j<nEntries;j++) |
| 3085 | { |
| 3086 | for (k=0;k<nEntries;k++) |
| 3087 | { |
| 3088 | if (RhokTEntries[k]>smax) |
| 3089 | { |
| 3090 | smax=RhokTEntries[k]; |
| 3091 | sindex=k; |
| 3092 | } |
| 3093 | } |
| 3094 | w[j]=smax; |
| 3095 | RhokTEntries[sindex]=rho_min; |
| 3096 | smax=rho_min; |
| 3097 | sindex=-1; |
| 3098 | } |
| 3099 | return w[nEntries/2]; |
| 3100 | } |
| 3101 | |
| 3102 | |
| 3103 | // AlipAJetData Class Member Defs |
| 3104 | // Constructors |
| d812e269 |
3105 | AliAnalysisTaskFullpAJets::AlipAJetData::AlipAJetData() : |
| 3106 | |
| 3107 | fName(0), |
| 3108 | fIsJetsFull(0), |
| 3109 | fnTotal(0), |
| 3110 | fnJets(0), |
| 3111 | fnJetsSC(0), |
| 3112 | fJetR(0), |
| 3113 | fSignalPt(0), |
| 3114 | fAreaCutFrac(0.6), |
| 3115 | fPtMaxIndex(0), |
| 3116 | fPtMax(0), |
| 3117 | fPtSubLeadingIndex(0), |
| 3118 | fPtSubLeading(0), |
| 3119 | fJetsIndex(0), |
| 3120 | fJetsSCIndex(0), |
| 3121 | fIsJetInArray(0) |
| c6202663 |
3122 | { |
| 3123 | fnTotal=0; |
| 3124 | // Dummy constructor ALWAYS needed for I/O. |
| 3125 | } |
| 3126 | |
| d812e269 |
3127 | AliAnalysisTaskFullpAJets::AlipAJetData::AlipAJetData(const char *name, Bool_t isFull, Int_t nEntries) : |
| 3128 | |
| 3129 | fName(0), |
| 3130 | fIsJetsFull(0), |
| 3131 | fnTotal(0), |
| 3132 | fnJets(0), |
| 3133 | fnJetsSC(0), |
| 3134 | fJetR(0), |
| 3135 | fSignalPt(0), |
| 3136 | fAreaCutFrac(0.6), |
| 3137 | fPtMaxIndex(0), |
| 3138 | fPtMax(0), |
| 3139 | fPtSubLeadingIndex(0), |
| 3140 | fPtSubLeading(0), |
| 3141 | fJetsIndex(0), |
| 3142 | fJetsSCIndex(0), |
| 3143 | fIsJetInArray(0) |
| c6202663 |
3144 | { |
| 3145 | SetName(name); |
| 3146 | SetIsJetsFull(isFull); |
| 3147 | SetTotalEntries(nEntries); |
| 3148 | SetLeading(0,-9.99E+099); |
| 3149 | SetSubLeading(0,-9.99E+099); |
| 3150 | SetSignalCut(0); |
| 3151 | SetAreaCutFraction(0.6); |
| d812e269 |
3152 | SetJetR(fJetR); |
| c6202663 |
3153 | } |
| 3154 | |
| 3155 | // Destructor |
| 3156 | AliAnalysisTaskFullpAJets::AlipAJetData::~AlipAJetData() |
| 3157 | { |
| 3158 | if (fnTotal!=0) |
| 3159 | { |
| 3160 | SetName(""); |
| 3161 | SetIsJetsFull(kFALSE); |
| 3162 | SetTotalEntries(0); |
| 3163 | SetTotalJets(0); |
| 3164 | SetTotalSignalJets(0); |
| 3165 | SetLeading(0,0); |
| 3166 | SetSubLeading(0,0); |
| 3167 | SetSignalCut(0); |
| 3168 | SetAreaCutFraction(0); |
| 3169 | SetJetR(0); |
| 3170 | |
| 3171 | delete [] fJetsIndex; |
| 3172 | delete [] fJetsSCIndex; |
| 3173 | delete [] fIsJetInArray; |
| 3174 | } |
| 3175 | } |
| 3176 | |
| 3177 | // User Defined Sub-Routines |
| 3178 | void AliAnalysisTaskFullpAJets::AlipAJetData::InitializeJetData(TClonesArray *jetList, Int_t nEntries) |
| 3179 | { |
| 3180 | Int_t i=0; |
| 3181 | Int_t k=0; |
| 3182 | Int_t l=0; |
| 3183 | Double_t AreaThreshold = fAreaCutFrac*TMath::Pi()*TMath::Power(fJetR,2); |
| 3184 | |
| 3185 | // Initialize Jet Data |
| 3186 | for (i=0;i<nEntries;i++) |
| 3187 | { |
| 3188 | AliEmcalJet *myJet =(AliEmcalJet*) jetList->At(i); |
| 3189 | |
| 3190 | if (fIsJetInArray[i]==kTRUE && myJet->Area()>AreaThreshold) |
| 3191 | { |
| 3192 | SetJetIndex(i,k); |
| 3193 | if (myJet->Pt()>fPtMax) |
| 3194 | { |
| 3195 | SetSubLeading(fPtMaxIndex,fPtMax); |
| 3196 | SetLeading(i,myJet->Pt()); |
| 3197 | } |
| 3198 | else if (myJet->Pt()>fPtSubLeading) |
| 3199 | { |
| 3200 | SetSubLeading(i,myJet->Pt()); |
| 3201 | } |
| 3202 | if (myJet->Pt()>=fSignalPt) |
| 3203 | { |
| 3204 | SetSignalJetIndex(i,l); |
| 3205 | l++; |
| 3206 | } |
| 3207 | k++; |
| 3208 | } |
| 3209 | } |
| 3210 | SetTotalJets(k); |
| 3211 | SetTotalSignalJets(l); |
| 3212 | } |
| 3213 | |
| 3214 | // Setters |
| 3215 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetName(const char *name) |
| 3216 | { |
| 3217 | fName = name; |
| 3218 | } |
| 3219 | |
| 3220 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetIsJetsFull(Bool_t isFull) |
| 3221 | { |
| 3222 | fIsJetsFull = isFull; |
| 3223 | } |
| 3224 | |
| 3225 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetTotalEntries(Int_t nEntries) |
| 3226 | { |
| 3227 | fnTotal = nEntries; |
| 3228 | fJetsIndex = new Int_t[fnTotal]; |
| 3229 | fJetsSCIndex = new Int_t[fnTotal]; |
| 3230 | fIsJetInArray = new Bool_t[fnTotal]; |
| 3231 | } |
| 3232 | |
| 3233 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetTotalJets(Int_t nJets) |
| 3234 | { |
| 3235 | fnJets = nJets; |
| 3236 | } |
| 3237 | |
| 3238 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetTotalSignalJets(Int_t nSignalJets) |
| 3239 | { |
| 3240 | fnJetsSC = nSignalJets; |
| 3241 | } |
| 3242 | |
| 3243 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetSignalCut(Double_t Pt) |
| 3244 | { |
| 3245 | fSignalPt = Pt; |
| 3246 | } |
| 3247 | |
| 3248 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetLeading(Int_t index, Double_t Pt) |
| 3249 | { |
| 3250 | fPtMaxIndex = index; |
| 3251 | fPtMax = Pt; |
| 3252 | } |
| 3253 | |
| 3254 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetSubLeading(Int_t index, Double_t Pt) |
| 3255 | { |
| 3256 | fPtSubLeadingIndex = index; |
| 3257 | fPtSubLeading = Pt; |
| 3258 | } |
| 3259 | |
| 3260 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetJetIndex(Int_t index, Int_t At) |
| 3261 | { |
| 3262 | fJetsIndex[At] = index; |
| 3263 | } |
| 3264 | |
| 3265 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetSignalJetIndex(Int_t index, Int_t At) |
| 3266 | { |
| 3267 | fJetsSCIndex[At] = index; |
| 3268 | } |
| 3269 | |
| 3270 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetIsJetInArray(Bool_t isInArray, Int_t At) |
| 3271 | { |
| 3272 | fIsJetInArray[At] = isInArray; |
| 3273 | } |
| 3274 | |
| 3275 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetAreaCutFraction(Double_t areaFraction) |
| 3276 | { |
| 3277 | fAreaCutFrac = areaFraction; |
| 3278 | } |
| 3279 | |
| 3280 | void AliAnalysisTaskFullpAJets::AlipAJetData::SetJetR(Double_t jetR) |
| 3281 | { |
| 3282 | fJetR = jetR; |
| 3283 | } |
| 3284 | |
| 3285 | // Getters |
| 3286 | Int_t AliAnalysisTaskFullpAJets::AlipAJetData::GetTotalEntries() |
| 3287 | { |
| 3288 | return fnTotal; |
| 3289 | } |
| 3290 | |
| 3291 | Int_t AliAnalysisTaskFullpAJets::AlipAJetData::GetTotalJets() |
| 3292 | { |
| 3293 | return fnJets; |
| 3294 | } |
| 3295 | |
| 3296 | Int_t AliAnalysisTaskFullpAJets::AlipAJetData::GetTotalSignalJets() |
| 3297 | { |
| 3298 | return fnJetsSC; |
| 3299 | } |
| 3300 | |
| 3301 | Double_t AliAnalysisTaskFullpAJets::AlipAJetData::GetSignalCut() |
| 3302 | { |
| 3303 | return fSignalPt; |
| 3304 | } |
| 3305 | |
| 3306 | Int_t AliAnalysisTaskFullpAJets::AlipAJetData::GetLeadingIndex() |
| 3307 | { |
| 3308 | return fPtMaxIndex; |
| 3309 | } |
| 3310 | |
| 3311 | Double_t AliAnalysisTaskFullpAJets::AlipAJetData::GetLeadingPt() |
| 3312 | { |
| 3313 | return fPtMax; |
| 3314 | } |
| 3315 | |
| 3316 | Int_t AliAnalysisTaskFullpAJets::AlipAJetData::GetSubLeadingIndex() |
| 3317 | { |
| 3318 | return fPtSubLeadingIndex; |
| 3319 | } |
| 3320 | |
| 3321 | Double_t AliAnalysisTaskFullpAJets::AlipAJetData::GetSubLeadingPt() |
| 3322 | { |
| 3323 | return fPtSubLeading; |
| 3324 | } |
| 3325 | |
| 3326 | Int_t AliAnalysisTaskFullpAJets::AlipAJetData::GetJetIndex(Int_t At) |
| 3327 | { |
| 3328 | return fJetsIndex[At]; |
| 3329 | } |
| 3330 | |
| 3331 | Int_t AliAnalysisTaskFullpAJets::AlipAJetData::GetSignalJetIndex(Int_t At) |
| 3332 | { |
| 3333 | return fJetsSCIndex[At]; |
| 3334 | } |
| 3335 | |
| 3336 | Bool_t AliAnalysisTaskFullpAJets::AlipAJetData::GetIsJetInArray(Int_t At) |
| 3337 | { |
| 3338 | return fIsJetInArray[At]; |
| 3339 | } |
| 3340 | |
| 3341 | |
| 3342 | // AlipAJetHistos Class Member Defs |
| 3343 | // Constructors |
| d812e269 |
3344 | AliAnalysisTaskFullpAJets::AlipAJetHistos::AlipAJetHistos() : |
| 3345 | |
| 3346 | fOutput(0), |
| 3347 | |
| 3348 | fh020Rho(0), |
| 3349 | fh80100Rho(0), |
| 3350 | fhRho(0), |
| 3351 | fhRhoCen(0), |
| 3352 | fh020BSPt(0), |
| 3353 | fh80100BSPt(0), |
| 3354 | fhBSPt(0), |
| 3355 | fhBSPtCen(0), |
| 3356 | fh020BSPtSignal(0), |
| 3357 | fh80100BSPtSignal(0), |
| 3358 | fhBSPtSignal(0), |
| 3359 | fhBSPtCenSignal(0), |
| 3360 | fh020DeltaPt(0), |
| 3361 | fh80100DeltaPt(0), |
| 3362 | fhDeltaPt(0), |
| 3363 | fhDeltaPtCen(0), |
| 3364 | fh020DeltaPtSignal(0), |
| 3365 | fh80100DeltaPtSignal(0), |
| 3366 | fhDeltaPtSignal(0), |
| 3367 | fhDeltaPtCenSignal(0), |
| 7acc3e04 |
3368 | fh020DeltaPtNColl(0), |
| 3369 | fh80100DeltaPtNColl(0), |
| 3370 | fhDeltaPtNColl(0), |
| 3371 | fhDeltaPtCenNColl(0), |
| d812e269 |
3372 | fh020BckgFlucPt(0), |
| 3373 | fh80100BckgFlucPt(0), |
| 3374 | fhBckgFlucPt(0), |
| 3375 | fhBckgFlucPtCen(0), |
| 3376 | |
| 3377 | fpRho(0), |
| 3378 | fpLJetRho(0), |
| 3379 | |
| 3380 | fName(0), |
| 3381 | fCentralityTag(0), |
| 3382 | fCentralityBins(0), |
| 3383 | fCentralityLow(0), |
| 3384 | fCentralityUp(0), |
| 3385 | fPtBins(0), |
| 3386 | fPtLow(0), |
| 3387 | fPtUp(0), |
| 3388 | fRhoPtBins(0), |
| 3389 | fRhoPtLow(0), |
| 3390 | fRhoPtUp(0), |
| 3391 | fDeltaPtBins(0), |
| 3392 | fDeltaPtLow(0), |
| 3393 | fDeltaPtUp(0), |
| 3394 | fBckgFlucPtBins(0), |
| 3395 | fBckgFlucPtLow(0), |
| 3396 | fBckgFlucPtUp(0), |
| 3397 | fLJetPtBins(0), |
| 3398 | fLJetPtLow(0), |
| 7acc3e04 |
3399 | fLJetPtUp(0), |
| 3400 | fRhoValue(0) |
| c6202663 |
3401 | { |
| 3402 | // Dummy constructor ALWAYS needed for I/O. |
| 3403 | } |
| 3404 | |
| d812e269 |
3405 | AliAnalysisTaskFullpAJets::AlipAJetHistos::AlipAJetHistos(const char *name) : |
| 3406 | |
| 3407 | fOutput(0), |
| 3408 | |
| 3409 | fh020Rho(0), |
| 3410 | fh80100Rho(0), |
| 3411 | fhRho(0), |
| 3412 | fhRhoCen(0), |
| 3413 | fh020BSPt(0), |
| 3414 | fh80100BSPt(0), |
| 3415 | fhBSPt(0), |
| 3416 | fhBSPtCen(0), |
| 3417 | fh020BSPtSignal(0), |
| 3418 | fh80100BSPtSignal(0), |
| 3419 | fhBSPtSignal(0), |
| 3420 | fhBSPtCenSignal(0), |
| 3421 | fh020DeltaPt(0), |
| 3422 | fh80100DeltaPt(0), |
| 3423 | fhDeltaPt(0), |
| 3424 | fhDeltaPtCen(0), |
| 3425 | fh020DeltaPtSignal(0), |
| 3426 | fh80100DeltaPtSignal(0), |
| 3427 | fhDeltaPtSignal(0), |
| 3428 | fhDeltaPtCenSignal(0), |
| 7acc3e04 |
3429 | fh020DeltaPtNColl(0), |
| 3430 | fh80100DeltaPtNColl(0), |
| 3431 | fhDeltaPtNColl(0), |
| 3432 | fhDeltaPtCenNColl(0), |
| d812e269 |
3433 | fh020BckgFlucPt(0), |
| 3434 | fh80100BckgFlucPt(0), |
| 3435 | fhBckgFlucPt(0), |
| 3436 | fhBckgFlucPtCen(0), |
| 3437 | |
| 3438 | fpRho(0), |
| 3439 | fpLJetRho(0), |
| 3440 | |
| 3441 | fName(0), |
| 3442 | fCentralityTag(0), |
| 3443 | fCentralityBins(0), |
| 3444 | fCentralityLow(0), |
| 3445 | fCentralityUp(0), |
| 3446 | fPtBins(0), |
| 3447 | fPtLow(0), |
| 3448 | fPtUp(0), |
| 3449 | fRhoPtBins(0), |
| 3450 | fRhoPtLow(0), |
| 3451 | fRhoPtUp(0), |
| 3452 | fDeltaPtBins(0), |
| 3453 | fDeltaPtLow(0), |
| 3454 | fDeltaPtUp(0), |
| 3455 | fBckgFlucPtBins(0), |
| 3456 | fBckgFlucPtLow(0), |
| 3457 | fBckgFlucPtUp(0), |
| 3458 | fLJetPtBins(0), |
| 3459 | fLJetPtLow(0), |
| 7acc3e04 |
3460 | fLJetPtUp(0), |
| 3461 | fRhoValue(0) |
| c6202663 |
3462 | { |
| 3463 | SetName(name); |
| 3464 | SetCentralityTag("V0A"); |
| 3465 | SetCentralityRange(100,0,100); |
| 3466 | SetPtRange(250,-50,200); |
| 3467 | SetRhoPtRange(500,0,50); |
| 3468 | SetDeltaPtRange(200,-100,100); |
| 3469 | SetBackgroundFluctuationsPtRange(100,0,100); |
| 3470 | SetLeadingJetPtRange(200,0,200); |
| 3471 | |
| 3472 | Init(); |
| 3473 | } |
| 3474 | |
| d812e269 |
3475 | AliAnalysisTaskFullpAJets::AlipAJetHistos::AlipAJetHistos(const char *name, const char *centag) : |
| 3476 | |
| 3477 | fOutput(0), |
| 3478 | |
| 3479 | fh020Rho(0), |
| 3480 | fh80100Rho(0), |
| 3481 | fhRho(0), |
| 3482 | fhRhoCen(0), |
| 3483 | fh020BSPt(0), |
| 3484 | fh80100BSPt(0), |
| 3485 | fhBSPt(0), |
| 3486 | fhBSPtCen(0), |
| 3487 | fh020BSPtSignal(0), |
| 3488 | fh80100BSPtSignal(0), |
| 3489 | fhBSPtSignal(0), |
| 3490 | fhBSPtCenSignal(0), |
| 3491 | fh020DeltaPt(0), |
| 3492 | fh80100DeltaPt(0), |
| 3493 | fhDeltaPt(0), |
| 3494 | fhDeltaPtCen(0), |
| 3495 | fh020DeltaPtSignal(0), |
| 3496 | fh80100DeltaPtSignal(0), |
| 3497 | fhDeltaPtSignal(0), |
| 3498 | fhDeltaPtCenSignal(0), |
| 7acc3e04 |
3499 | fh020DeltaPtNColl(0), |
| 3500 | fh80100DeltaPtNColl(0), |
| 3501 | fhDeltaPtNColl(0), |
| 3502 | fhDeltaPtCenNColl(0), |
| d812e269 |
3503 | fh020BckgFlucPt(0), |
| 3504 | fh80100BckgFlucPt(0), |
| 3505 | fhBckgFlucPt(0), |
| 3506 | fhBckgFlucPtCen(0), |
| 3507 | |
| 3508 | fpRho(0), |
| 3509 | fpLJetRho(0), |
| 3510 | |
| 3511 | fName(0), |
| 3512 | fCentralityTag(0), |
| 3513 | fCentralityBins(0), |
| 3514 | fCentralityLow(0), |
| 3515 | fCentralityUp(0), |
| 3516 | fPtBins(0), |
| 3517 | fPtLow(0), |
| 3518 | fPtUp(0), |
| 3519 | fRhoPtBins(0), |
| 3520 | fRhoPtLow(0), |
| 3521 | fRhoPtUp(0), |
| 3522 | fDeltaPtBins(0), |
| 3523 | fDeltaPtLow(0), |
| 3524 | fDeltaPtUp(0), |
| 3525 | fBckgFlucPtBins(0), |
| 3526 | fBckgFlucPtLow(0), |
| 3527 | fBckgFlucPtUp(0), |
| 3528 | fLJetPtBins(0), |
| 3529 | fLJetPtLow(0), |
| 7acc3e04 |
3530 | fLJetPtUp(0), |
| 3531 | fRhoValue(0) |
| c6202663 |
3532 | { |
| 3533 | SetName(name); |
| 3534 | SetCentralityTag(centag); |
| 3535 | SetCentralityRange(100,0,100); |
| 3536 | SetPtRange(250,-50,200); |
| 3537 | SetRhoPtRange(500,0,50); |
| 3538 | SetDeltaPtRange(200,-100,100); |
| 3539 | SetBackgroundFluctuationsPtRange(100,0,100); |
| 3540 | SetLeadingJetPtRange(200,0,200); |
| 3541 | |
| 3542 | Init(); |
| 3543 | } |
| 3544 | |
| 3545 | // Destructor |
| 3546 | AliAnalysisTaskFullpAJets::AlipAJetHistos::~AlipAJetHistos() |
| 3547 | { |
| 3548 | if (fOutput) |
| 3549 | { |
| 3550 | delete fOutput; |
| 3551 | } |
| 3552 | } |
| 3553 | |
| 3554 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::Init() |
| 3555 | { |
| 3556 | fOutput = new TList(); |
| 3557 | fOutput->SetOwner(); |
| 3558 | fOutput->SetName(fName); |
| 3559 | |
| 3560 | TString RhoString=""; |
| 3561 | TString PtString=""; |
| 3562 | TString DeltaPtString=""; |
| 3563 | TString BckgFlucPtString=""; |
| 3564 | TString CentralityString; |
| 3565 | CentralityString = Form("Centrality (%s)",fCentralityTag); |
| 3566 | |
| 3567 | // Rho Spectral Plots |
| 3568 | RhoString = Form("%d-%d Centrality, Rho Spectrum",0,20); |
| 3569 | fh020Rho = new TH1D("fh020Rho",RhoString,fRhoPtBins,fRhoPtLow,fRhoPtUp); |
| 3570 | fh020Rho->GetXaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 3571 | fh020Rho->GetYaxis()->SetTitle("1/N_{Events} dN/d#rho"); |
| 3572 | fh020Rho->Sumw2(); |
| 3573 | |
| 3574 | RhoString = Form("%d-%d Centrality, Rho Spectrum",80,100); |
| 3575 | fh80100Rho = new TH1D("fh80100Rho",RhoString,fRhoPtBins,fRhoPtLow,fRhoPtUp); |
| 3576 | fh80100Rho->GetXaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 3577 | fh80100Rho->GetYaxis()->SetTitle("1/N_{Events} dN/d#rho"); |
| 3578 | fh80100Rho->Sumw2(); |
| 3579 | |
| 3580 | RhoString = Form("%d-%d Centrality, Rho Spectrum",0,100); |
| 3581 | fhRho = new TH1D("fhRho",RhoString,fRhoPtBins,fRhoPtLow,fRhoPtUp); |
| 3582 | fhRho->GetXaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 3583 | fhRho->GetYaxis()->SetTitle("1/N_{Events} dN/d#rho"); |
| 3584 | fhRho->Sumw2(); |
| 3585 | |
| 3586 | RhoString = "Rho Spectrum vs Centrality"; |
| 3587 | fhRhoCen = new TH2D("fhRhoCen",RhoString,fRhoPtBins,fRhoPtLow,fRhoPtUp,fCentralityBins,fCentralityLow,fCentralityUp); |
| 3588 | fhRhoCen->GetXaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 3589 | fhRhoCen->GetYaxis()->SetTitle(Form("%s",CentralityString.Data())); |
| 3590 | fhRhoCen->GetZaxis()->SetTitle("1/N_{Events} dN/d#rho"); |
| 3591 | fhRhoCen->Sumw2(); |
| 3592 | |
| 3593 | // Background Subtracted Plots |
| 3594 | PtString = Form("%d-%d Centrality, Background Subtracted Jet Spectrum",0,20); |
| 3595 | fh020BSPt = new TH1D("fh020BSPt",PtString,fPtBins,fPtLow,fPtUp); |
| 3596 | fh020BSPt->GetXaxis()->SetTitle("p_{T} - #rhoA (GeV/c)"); |
| 3597 | fh020BSPt->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3598 | fh020BSPt->Sumw2(); |
| 3599 | |
| 3600 | PtString = Form("%d-%d Centrality, Background Subtracted Jet Spectrum",80,100); |
| 3601 | fh80100BSPt = new TH1D("fh80100BSPt",PtString,fPtBins,fPtLow,fPtUp); |
| 3602 | fh80100BSPt->GetXaxis()->SetTitle("p_{T} - #rhoA (GeV/c)"); |
| 3603 | fh80100BSPt->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3604 | fh80100BSPt->Sumw2(); |
| 3605 | |
| 3606 | PtString = Form("%d-%d Centrality, Background Subtracted Jet Spectrum",0,100); |
| 3607 | fhBSPt = new TH1D("fhBSPt",PtString,fPtBins,fPtLow,fPtUp); |
| 3608 | fhBSPt->GetXaxis()->SetTitle("p_{T} - #rhoA (GeV/c)"); |
| 3609 | fhBSPt->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3610 | fhBSPt->Sumw2(); |
| 3611 | |
| 3612 | PtString = "Background Subtracted Jet Spectrum vs Centrality"; |
| 3613 | fhBSPtCen = new TH2D("fhBSPtCen",PtString,fPtBins,fPtLow,fPtUp,fCentralityBins,fCentralityLow,fCentralityUp); |
| 3614 | fhBSPtCen->GetXaxis()->SetTitle("p_{T} - #rhoA (GeV/c)"); |
| 3615 | fhBSPtCen->GetYaxis()->SetTitle(Form("%s",CentralityString.Data())); |
| 3616 | fhBSPtCen->GetZaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3617 | fhBSPtCen->Sumw2(); |
| 3618 | |
| 3619 | PtString = Form("%d-%d Centrality, Background Subtracted Signal Jet Spectrum",0,20); |
| 3620 | fh020BSPtSignal = new TH1D("fh020BSPtSignal",PtString,fPtBins,fPtLow,fPtUp); |
| 3621 | fh020BSPtSignal->GetXaxis()->SetTitle("p_{T} - #rhoA (GeV/c)"); |
| 3622 | fh020BSPtSignal->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3623 | fh020BSPtSignal->Sumw2(); |
| 3624 | |
| 3625 | PtString = Form("%d-%d Centrality, Background Subtracted Signal Jet Spectrum",80,100); |
| 3626 | fh80100BSPtSignal = new TH1D("fh80100BSPtSignal",PtString,fPtBins,fPtLow,fPtUp); |
| 3627 | fh80100BSPtSignal->GetXaxis()->SetTitle("p_{T} - #rhoA (GeV/c)"); |
| 3628 | fh80100BSPtSignal->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3629 | fh80100BSPtSignal->Sumw2(); |
| 3630 | |
| 3631 | PtString = Form("%d-%d Centrality, Background Subtracted Signal Jet Spectrum",0,100); |
| 3632 | fhBSPtSignal = new TH1D("fhBSPtSignal",PtString,fPtBins,fPtLow,fPtUp); |
| 3633 | fhBSPtSignal->GetXaxis()->SetTitle("p_{T} - #rhoA (GeV/c)"); |
| 3634 | fhBSPtSignal->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3635 | fhBSPtSignal->Sumw2(); |
| 3636 | |
| 3637 | PtString = "Background Subtracted Signal Jet Spectrum vs Centrality"; |
| 3638 | fhBSPtCenSignal = new TH2D("fhBSPtCenSignal",PtString,fPtBins,fPtLow,fPtUp,fCentralityBins,fCentralityLow,fCentralityUp); |
| 3639 | fhBSPtCenSignal->GetXaxis()->SetTitle("p_{T} - #rhoA (GeV/c)"); |
| 3640 | fhBSPtCenSignal->GetYaxis()->SetTitle(Form("%s",CentralityString.Data())); |
| 3641 | fhBSPtCenSignal->GetZaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3642 | fhBSPtCenSignal->Sumw2(); |
| 3643 | |
| 3644 | // Delta Pt Plots with RC at least 2R away from Leading Signal |
| 3645 | DeltaPtString = Form("%d-%d Centrality, #deltap_{T} Spectrum",0,20); |
| 3646 | fh020DeltaPt = new TH1D("fh020DeltaPt",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp); |
| 3647 | fh020DeltaPt->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3648 | fh020DeltaPt->GetYaxis()->SetTitle("Probability Density"); |
| 3649 | fh020DeltaPt->Sumw2(); |
| 3650 | |
| 3651 | DeltaPtString = Form("%d-%d Centrality, #deltap_{T} Spectrum",80,100); |
| 3652 | fh80100DeltaPt = new TH1D("fh80100DeltaPt",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp); |
| 3653 | fh80100DeltaPt->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3654 | fh80100DeltaPt->GetYaxis()->SetTitle("Probability Density"); |
| 3655 | fh80100DeltaPt->Sumw2(); |
| 3656 | |
| 3657 | DeltaPtString = Form("%d-%d Centrality, #deltap_{T} Spectrum",0,100); |
| 3658 | fhDeltaPt = new TH1D("fhDeltaPt",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp); |
| 3659 | fhDeltaPt->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3660 | fhDeltaPt->GetYaxis()->SetTitle("Probability Density"); |
| 3661 | fhDeltaPt->Sumw2(); |
| 3662 | |
| 3663 | DeltaPtString = "#deltap_{T} Spectrum vs Centrality"; |
| 3664 | fhDeltaPtCen = new TH2D("fhDeltaPtCen",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp,fCentralityBins,fCentralityLow,fCentralityUp); |
| 3665 | fhDeltaPtCen->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3666 | fhDeltaPtCen->GetYaxis()->SetTitle(Form("%s",CentralityString.Data())); |
| 3667 | fhDeltaPtCen->GetZaxis()->SetTitle("Probability Density"); |
| 3668 | fhDeltaPtCen->Sumw2(); |
| 3669 | |
| 3670 | // Delta Pt Plots with no spatial restrictions on RC |
| 3671 | DeltaPtString = Form("%d-%d Centrality, #deltap_{T} Spectrum",0,20); |
| 3672 | fh020DeltaPtSignal = new TH1D("fh020DeltaPtSignal",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp); |
| 3673 | fh020DeltaPtSignal->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3674 | fh020DeltaPtSignal->GetYaxis()->SetTitle("Probability Density"); |
| 3675 | fh020DeltaPtSignal->Sumw2(); |
| 3676 | |
| 3677 | DeltaPtString = Form("%d-%d Centrality, #deltap_{T} Spectrum",80,100); |
| 3678 | fh80100DeltaPtSignal = new TH1D("fh80100DeltaPtSignal",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp); |
| 3679 | fh80100DeltaPtSignal->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3680 | fh80100DeltaPtSignal->GetYaxis()->SetTitle("Probability Density"); |
| 3681 | fh80100DeltaPtSignal->Sumw2(); |
| 3682 | |
| 3683 | DeltaPtString = Form("%d-%d Centrality, #deltap_{T} Spectrum",0,100); |
| 3684 | fhDeltaPtSignal = new TH1D("fhDeltaPtSignal",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp); |
| 3685 | fhDeltaPtSignal->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3686 | fhDeltaPtSignal->GetYaxis()->SetTitle("Probability Density"); |
| 3687 | fhDeltaPtSignal->Sumw2(); |
| 3688 | |
| 3689 | DeltaPtString = "#deltap_{T} Spectrum vs Centrality"; |
| 3690 | fhDeltaPtCenSignal = new TH2D("fhDeltaPtCenSignal",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp,fCentralityBins,fCentralityLow,fCentralityUp); |
| 3691 | fhDeltaPtCenSignal->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3692 | fhDeltaPtCenSignal->GetYaxis()->SetTitle(Form("%s",CentralityString.Data())); |
| 3693 | fhDeltaPtCenSignal->GetZaxis()->SetTitle("Probability Density"); |
| 3694 | fhDeltaPtCenSignal->Sumw2(); |
| 7acc3e04 |
3695 | |
| 3696 | // Delta Pt Plots with NColl restrictions on RC |
| 3697 | DeltaPtString = Form("%d-%d Centrality, #deltap_{T} Spectrum",0,20); |
| 3698 | fh020DeltaPtNColl = new TH1D("fh020DeltaPtNColl",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp); |
| 3699 | fh020DeltaPtNColl->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3700 | fh020DeltaPtNColl->GetYaxis()->SetTitle("Probability Density"); |
| 3701 | fh020DeltaPtNColl->Sumw2(); |
| 3702 | |
| 3703 | DeltaPtString = Form("%d-%d Centrality, #deltap_{T} Spectrum",80,100); |
| 3704 | fh80100DeltaPtNColl = new TH1D("fh80100DeltaPtNColl",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp); |
| 3705 | fh80100DeltaPtNColl->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3706 | fh80100DeltaPtNColl->GetYaxis()->SetTitle("Probability Density"); |
| 3707 | fh80100DeltaPtNColl->Sumw2(); |
| c6202663 |
3708 | |
| 7acc3e04 |
3709 | DeltaPtString = Form("%d-%d Centrality, #deltap_{T} Spectrum",0,100); |
| 3710 | fhDeltaPtNColl = new TH1D("fhDeltaPtNColl",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp); |
| 3711 | fhDeltaPtNColl->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3712 | fhDeltaPtNColl->GetYaxis()->SetTitle("Probability Density"); |
| 3713 | fhDeltaPtNColl->Sumw2(); |
| 3714 | |
| 3715 | DeltaPtString = "#deltap_{T} Spectrum vs Centrality"; |
| 3716 | fhDeltaPtCenNColl = new TH2D("fhDeltaPtCenNColl",DeltaPtString,fDeltaPtBins,fDeltaPtLow,fDeltaPtUp,fCentralityBins,fCentralityLow,fCentralityUp); |
| 3717 | fhDeltaPtCenNColl->GetXaxis()->SetTitle("#deltap_{T} (GeV/c)"); |
| 3718 | fhDeltaPtCenNColl->GetYaxis()->SetTitle(Form("%s",CentralityString.Data())); |
| 3719 | fhDeltaPtCenNColl->GetZaxis()->SetTitle("Probability Density"); |
| 3720 | fhDeltaPtCenNColl->Sumw2(); |
| 3721 | |
| c6202663 |
3722 | // Background Fluctuations Pt Plots |
| 3723 | BckgFlucPtString = Form("%d-%d Centrality, Background Fluctuation p_{T} Spectrum",0,20); |
| 3724 | fh020BckgFlucPt = new TH1D("fh020BckgFlucPt",PtString,fPtBins,fPtLow,fPtUp); |
| 3725 | fh020BckgFlucPt->GetXaxis()->SetTitle("p_{T} (GeV/c)"); |
| 3726 | fh020BckgFlucPt->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3727 | fh020BckgFlucPt->Sumw2(); |
| 3728 | |
| 3729 | BckgFlucPtString = Form("%d-%d Centrality, Background Fluctuation p_{T} Spectrum",80,100); |
| 3730 | fh80100BckgFlucPt = new TH1D("fh80100BckgFlucPt",BckgFlucPtString,fBckgFlucPtBins,fBckgFlucPtLow,fBckgFlucPtUp); |
| 3731 | fh80100BckgFlucPt->GetXaxis()->SetTitle("p_{T} (GeV/c)"); |
| 3732 | fh80100BckgFlucPt->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3733 | fh80100BckgFlucPt->Sumw2(); |
| 3734 | |
| 3735 | BckgFlucPtString = Form("%d-%d Centrality, Background Fluctuation p_{T} Spectrum",0,100); |
| 3736 | fhBckgFlucPt = new TH1D("fhBckgFlucPt",BckgFlucPtString,fBckgFlucPtBins,fBckgFlucPtLow,fBckgFlucPtUp); |
| 3737 | fhBckgFlucPt->GetXaxis()->SetTitle("p_{T} (GeV/c)"); |
| 3738 | fhBckgFlucPt->GetYaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3739 | fhBckgFlucPt->Sumw2(); |
| 3740 | |
| 3741 | BckgFlucPtString = "Background Fluctuation p_{T} Spectrum vs Centrality"; |
| 3742 | fhBckgFlucPtCen = new TH2D("fhBckgFlucPtCen",BckgFlucPtString,fBckgFlucPtBins,fBckgFlucPtLow,fBckgFlucPtUp,fCentralityBins,fCentralityLow,fCentralityUp); |
| 3743 | fhBckgFlucPtCen->GetXaxis()->SetTitle("#p_{T} (GeV/c)"); |
| 3744 | fhBckgFlucPtCen->GetYaxis()->SetTitle(Form("%s",CentralityString.Data())); |
| 3745 | fhBckgFlucPtCen->GetZaxis()->SetTitle("1/N_{Events} dN/dp_{T}d#etad#phi"); |
| 3746 | fhBckgFlucPtCen->Sumw2(); |
| 3747 | |
| 3748 | // Background Density vs Centrality Profile |
| 3749 | RhoString = "Background Density vs Centrality"; |
| 3750 | fpRho = new TProfile("fpRho",RhoString,fCentralityBins,fCentralityLow,fCentralityUp); |
| 3751 | fpRho->GetXaxis()->SetTitle(Form("%s",CentralityString.Data())); |
| 3752 | fpRho->GetYaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 3753 | |
| 3754 | // Background Density vs Leading Jet Profile |
| 3755 | fpLJetRho = new TProfile("fpLJetRho","#rho vs Leading Jet p_{T}",fLJetPtBins,fLJetPtLow,fLJetPtUp); |
| 3756 | fpLJetRho->GetXaxis()->SetTitle("Leading Jet p_{T}"); |
| 3757 | fpLJetRho->GetYaxis()->SetTitle("p_{T}/Area (GeV/c)"); |
| 3758 | |
| 3759 | // Add Histos & Profiles to List |
| 3760 | fOutput->Add(fh020Rho); |
| 3761 | fOutput->Add(fh80100Rho); |
| 3762 | fOutput->Add(fhRho); |
| 3763 | fOutput->Add(fhRhoCen); |
| 3764 | fOutput->Add(fh020BSPt); |
| 3765 | fOutput->Add(fh80100BSPt); |
| 3766 | fOutput->Add(fhBSPt); |
| 3767 | fOutput->Add(fhBSPtCen); |
| 3768 | fOutput->Add(fh020BSPtSignal); |
| 3769 | fOutput->Add(fh80100BSPtSignal); |
| 3770 | fOutput->Add(fhBSPtSignal); |
| 3771 | fOutput->Add(fhBSPtCenSignal); |
| 3772 | fOutput->Add(fh020DeltaPt); |
| 3773 | fOutput->Add(fh80100DeltaPt); |
| 3774 | fOutput->Add(fhDeltaPt); |
| 3775 | fOutput->Add(fhDeltaPtCen); |
| 3776 | fOutput->Add(fh020DeltaPtSignal); |
| 3777 | fOutput->Add(fh80100DeltaPtSignal); |
| 3778 | fOutput->Add(fhDeltaPtSignal); |
| 3779 | fOutput->Add(fhDeltaPtCenSignal); |
| 7acc3e04 |
3780 | fOutput->Add(fh020DeltaPtNColl); |
| 3781 | fOutput->Add(fh80100DeltaPtNColl); |
| 3782 | fOutput->Add(fhDeltaPtNColl); |
| 3783 | fOutput->Add(fhDeltaPtCenNColl); |
| c6202663 |
3784 | fOutput->Add(fh020BckgFlucPt); |
| 3785 | fOutput->Add(fh80100BckgFlucPt); |
| 3786 | fOutput->Add(fhBckgFlucPt); |
| 3787 | fOutput->Add(fhBckgFlucPtCen); |
| 3788 | fOutput->Add(fpRho); |
| 3789 | fOutput->Add(fpLJetRho); |
| 3790 | } |
| 3791 | |
| 3792 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::SetName(const char *name) |
| 3793 | { |
| 3794 | fName = name; |
| 3795 | } |
| 3796 | |
| 3797 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::SetCentralityTag(const char *name) |
| 3798 | { |
| 3799 | fCentralityTag = name; |
| 3800 | } |
| 3801 | |
| 3802 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::SetCentralityRange(Int_t bins, Double_t low, Double_t up) |
| 3803 | { |
| 3804 | fCentralityBins=bins; |
| 3805 | fCentralityLow=low; |
| 3806 | fCentralityUp=up; |
| 3807 | } |
| 3808 | |
| 3809 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::SetPtRange(Int_t bins, Double_t low, Double_t up) |
| 3810 | { |
| 3811 | fPtBins=bins; |
| 3812 | fPtLow=low; |
| 3813 | fPtUp=up; |
| 3814 | } |
| 3815 | |
| 3816 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::SetRhoPtRange(Int_t bins, Double_t low, Double_t up) |
| 3817 | { |
| 3818 | fRhoPtBins=bins; |
| 3819 | fRhoPtLow=low; |
| 3820 | fRhoPtUp=up; |
| 3821 | } |
| 3822 | |
| 3823 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::SetDeltaPtRange(Int_t bins, Double_t low, Double_t up) |
| 3824 | { |
| 3825 | fDeltaPtBins=bins; |
| 3826 | fDeltaPtLow=low; |
| 3827 | fDeltaPtUp=up; |
| 3828 | } |
| 3829 | |
| 3830 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::SetBackgroundFluctuationsPtRange(Int_t bins, Double_t low, Double_t up) |
| 3831 | { |
| 3832 | fBckgFlucPtBins=bins; |
| 3833 | fBckgFlucPtLow=low; |
| 3834 | fBckgFlucPtUp=up; |
| 3835 | } |
| 3836 | |
| 3837 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::SetLeadingJetPtRange(Int_t bins, Double_t low, Double_t up) |
| 3838 | { |
| 3839 | fLJetPtBins=bins; |
| 3840 | fLJetPtLow=low; |
| 3841 | fLJetPtUp=up; |
| 3842 | } |
| 3843 | |
| 3844 | TList* AliAnalysisTaskFullpAJets::AlipAJetHistos::GetOutputHistos() |
| 3845 | { |
| 3846 | return fOutput; |
| 3847 | } |
| 3848 | |
| 3849 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::FillRho(Double_t eventCentrality, Double_t rho) |
| 3850 | { |
| 7acc3e04 |
3851 | fRhoValue = rho; |
| 3852 | |
| c6202663 |
3853 | fhRho->Fill(rho); |
| 3854 | fhRhoCen->Fill(rho,eventCentrality); |
| 3855 | fpRho->Fill(eventCentrality,rho); |
| 3856 | |
| 3857 | if (eventCentrality<=20) |
| 3858 | { |
| 3859 | fh020Rho->Fill(rho); |
| 3860 | } |
| 3861 | else if (eventCentrality>=80) |
| 3862 | { |
| 3863 | fh80100Rho->Fill(rho); |
| 3864 | } |
| 3865 | } |
| 3866 | |
| 3867 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::FillBSJS(Double_t eventCentrality, Double_t rho, Double_t signalCut, TClonesArray *jetList, Int_t *indexJetList, Int_t nIndexJetList) |
| 3868 | { |
| 3869 | Int_t i; |
| 3870 | Double_t tempPt=0.0; |
| 3871 | |
| 3872 | for (i=0;i<nIndexJetList;i++) |
| 3873 | { |
| 3874 | AliEmcalJet *myJet = (AliEmcalJet*) jetList->At(indexJetList[i]); |
| 3875 | tempPt=myJet->Pt()-rho*myJet->Area(); |
| 3876 | |
| 3877 | fhBSPt->Fill(tempPt); |
| 3878 | fhBSPtCen->Fill(tempPt,eventCentrality); |
| 3879 | if (eventCentrality<=20) |
| 3880 | { |
| 3881 | fh020BSPt->Fill(tempPt); |
| 3882 | } |
| 3883 | else if (eventCentrality>=80) |
| 3884 | { |
| 3885 | fh80100BSPt->Fill(tempPt); |
| 3886 | } |
| 3887 | |
| 3888 | if (myJet->Pt()>=signalCut) |
| 3889 | { |
| 3890 | fhBSPtSignal->Fill(tempPt); |
| 3891 | fhBSPtCenSignal->Fill(tempPt,eventCentrality); |
| 3892 | if (eventCentrality<=20) |
| 3893 | { |
| 3894 | fh020BSPtSignal->Fill(tempPt); |
| 3895 | } |
| 3896 | else if (eventCentrality>=80) |
| 3897 | { |
| 3898 | fh80100BSPtSignal->Fill(tempPt); |
| 3899 | } |
| 3900 | } |
| 3901 | tempPt=0.0; |
| 3902 | } |
| 3903 | } |
| 3904 | |
| 3905 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::FillDeltaPt(Double_t eventCentrality, Double_t rho, Double_t jetRadius, Double_t *RCArray, Int_t nRC) |
| 3906 | { |
| 3907 | Int_t i; |
| 3908 | Double_t tempPt=0.0; |
| 3909 | |
| 3910 | for (i=0;i<nRC;i++) |
| 3911 | { |
| 3912 | tempPt=RCArray[i]-rho*TMath::Power(jetRadius,2); |
| 3913 | fhDeltaPt->Fill(tempPt); |
| 3914 | fhDeltaPtCen->Fill(tempPt,eventCentrality); |
| 3915 | if (eventCentrality<=20) |
| 3916 | { |
| 3917 | fh020DeltaPt->Fill(tempPt); |
| 3918 | } |
| 3919 | else if (eventCentrality>=80) |
| 3920 | { |
| 3921 | fh80100DeltaPt->Fill(tempPt); |
| 3922 | } |
| 3923 | tempPt=0.0; |
| 3924 | } |
| 3925 | } |
| 3926 | |
| 3927 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::FillDeltaPtSignal(Double_t eventCentrality, Double_t rho, Double_t jetRadius, Double_t *RCArray, Int_t nRC) |
| 3928 | { |
| 3929 | Int_t i; |
| 3930 | Double_t tempPt=0.0; |
| 3931 | |
| 3932 | for (i=0;i<nRC;i++) |
| 3933 | { |
| 3934 | tempPt=RCArray[i]-rho*TMath::Power(jetRadius,2); |
| 3935 | fhDeltaPtSignal->Fill(tempPt); |
| 3936 | fhDeltaPtCenSignal->Fill(tempPt,eventCentrality); |
| 3937 | if (eventCentrality<=20) |
| 3938 | { |
| 3939 | fh020DeltaPtSignal->Fill(tempPt); |
| 3940 | } |
| 3941 | else if (eventCentrality>=80) |
| 3942 | { |
| 3943 | fh80100DeltaPtSignal->Fill(tempPt); |
| 3944 | } |
| 3945 | tempPt=0.0; |
| 3946 | } |
| 3947 | } |
| 3948 | |
| 7acc3e04 |
3949 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::FillDeltaPtNColl(Double_t eventCentrality, Double_t rho, Double_t jetRadius, Double_t *RCArray, Int_t nRC) |
| 3950 | { |
| 3951 | Int_t i; |
| 3952 | Double_t tempPt=0.0; |
| 3953 | |
| 3954 | for (i=0;i<nRC;i++) |
| 3955 | { |
| 3956 | tempPt=RCArray[i]-rho*TMath::Power(jetRadius,2); |
| 3957 | fhDeltaPtNColl->Fill(tempPt); |
| 3958 | fhDeltaPtCenNColl->Fill(tempPt,eventCentrality); |
| 3959 | if (eventCentrality<=20) |
| 3960 | { |
| 3961 | fh020DeltaPtNColl->Fill(tempPt); |
| 3962 | } |
| 3963 | else if (eventCentrality>=80) |
| 3964 | { |
| 3965 | fh80100DeltaPtNColl->Fill(tempPt); |
| 3966 | } |
| 3967 | tempPt=0.0; |
| 3968 | } |
| 3969 | } |
| 3970 | |
| c6202663 |
3971 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::FillBackgroundFluctuations(Double_t eventCentrality, Double_t rho, Double_t jetRadius) |
| 3972 | { |
| 3973 | Double_t tempPt=0.0; |
| 3974 | |
| 3975 | tempPt=rho*TMath::Power(jetRadius,2); |
| 3976 | fhBckgFlucPt->Fill(tempPt); |
| 3977 | fhBckgFlucPtCen->Fill(tempPt,eventCentrality); |
| 3978 | if (eventCentrality<=20) |
| 3979 | { |
| 3980 | fh020BckgFlucPt->Fill(tempPt); |
| 3981 | } |
| 3982 | else if (eventCentrality>=80) |
| 3983 | { |
| 3984 | fh80100BckgFlucPt->Fill(tempPt); |
| 3985 | } |
| 3986 | } |
| 3987 | |
| 3988 | void AliAnalysisTaskFullpAJets::AlipAJetHistos::FillLeadingJetPtRho(Double_t jetPt, Double_t rho) |
| 3989 | { |
| 3990 | fpLJetRho->Fill(jetPt,rho); |
| 3991 | } |
| 3992 | |
| 7acc3e04 |
3993 | Double_t AliAnalysisTaskFullpAJets::AlipAJetHistos::GetRho() |
| 3994 | { |
| 3995 | return fRhoValue; |
| 3996 | } |
| 3997 | |
| c6202663 |
3998 | |
git://git.uio.no / u / mrichter / AliRoot.git / blame