]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG4/JetTasks/AliAnalysisTaskUE.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Updated V0 cuts. (B. Hippolyte <hippolyt@in2p3.fr>)
[u/mrichter/AliRoot.git] / PWG4 / JetTasks / AliAnalysisTaskUE.cxx
CommitLineData
f3050824 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id:$ */
6ef5bfa4 17
f3050824 18#include <TROOT.h>
19#include <TSystem.h>
20#include <TChain.h>
21#include <TFile.h>
22#include <TList.h>
23#include <TH1I.h>
24#include <TH1F.h>
25#include <TH2F.h>
26#include <TCanvas.h>
27#include <TVector3.h>
28#include <TLorentzVector.h>
29#include <TMath.h>
6ef5bfa4 30#include <TTree.h>
31#include <TBranch.h>
f3050824 32
33#include "AliAnalysisTaskUE.h"
34#include "AliAnalysisManager.h"
35#include "AliMCEventHandler.h"
36#include "AliAODEvent.h"
37#include "AliAODInputHandler.h"
38#include "AliAODHandler.h"
39#include "AliStack.h"
40#include "AliAODJet.h"
41#include "AliAODTrack.h"
42
43#include "AliLog.h"
44
45//
46// Analysis class for Underlying Event studies
47//
48// Look for correlations on the tranverse regions to
49// the leading charged jet
50//
51// This class needs as input AOD with track and Jets
52// the output is a list of histograms
53//
54// AOD can be either connected to the InputEventHandler
55// for a chain of AOD files
56// or
57// to the OutputEventHandler
58// for a chain of ESD files, so this case class should be
59// in the train after the Jet finder
60//
61// Arian.Abrahantes.Quintana@cern.ch
62// Ernesto.Lopez.Torres@cern.ch
63//
64
65
66ClassImp( AliAnalysisTaskUE)
67
68////////////////////////////////////////////////////////////////////////
69
70
71//____________________________________________________________________
72AliAnalysisTaskUE:: AliAnalysisTaskUE(const char* name):
6ef5bfa4 73AliAnalysisTask(name, ""),
74fDebug(kFALSE),
75fAOD(0x0),
76fAODjets(0x0),
77fListOfHistos(0x0),
78fBinsPtInHist(30),
79fMinJetPtInHist(0.),
80fMaxJetPtInHist(300.),
81fAnaType(1),
82fRegionType(1),
83fConeRadius(0.7),
84fAreaReg(1.5393), // Pi*0.7*0.7
85fUseChPartJet(kFALSE),
86fUseSingleCharge(kFALSE),
87fUsePositiveCharge(kTRUE),
88fOrdering(1),
89fFilterBit(0xFF),
90fJetsOnFly(kFALSE),
91fJet1EtaCut(0.2),
92fJet2DeltaPhiCut(2.616), // 150 degrees
93fJet2RatioPtCut(0.8),
94fJet3PtCut(15.),
95fTrackPtCut(0.),
96fTrackEtaCut(0.9),
97fhNJets(0x0),
98fhEleadingPt(0x0),
99fhMinRegPtDist(0x0),
100fhRegionMultMin(0x0),
101fhMinRegAvePt(0x0),
102fhMinRegSumPt(0x0),
103fhMinRegMaxPtPart(0x0),
104fhMinRegSumPtvsMult(0x0),
de6f8090 105fhdNdEtaPhiDist(0x0),
6ef5bfa4 106fhFullRegPartPtDistVsEt(0x0),
107fhTransRegPartPtDistVsEt(0x0),
108fhRegionSumPtMaxVsEt(0x0),
109fhRegionMultMax(0x0),
110fhRegionMultMaxVsEt(0x0),
111fhRegionSumPtMinVsEt(0x0), //fhRegionMultMin(0x0),
112fhRegionMultMinVsEt(0x0),
113fhRegionAveSumPtVsEt(0x0),
114fhRegionDiffSumPtVsEt(0x0),
115fhRegionAvePartPtMaxVsEt(0x0),
116fhRegionAvePartPtMinVsEt(0x0),
117fhRegionMaxPartPtMaxVsEt(0x0),
118fSettingsTree(0x0)//, fhValidRegion(0x0)
f3050824 119{
120 // Default constructor
121 // Define input and output slots here
122 // Input slot #0 works with a TChain
123 DefineInput(0, TChain::Class());
124 // Output slot #0 writes into a TList container
125 DefineOutput(0, TList::Class());
126}
127
f3050824 128//____________________________________________________________________
129void AliAnalysisTaskUE::ConnectInputData(Option_t* /*option*/)
130{
6ef5bfa4 131 // Connect the input data
f3050824 132
6ef5bfa4 133 // We need AOD with tracks and jets.
134 // Since AOD can be either connected to the InputEventHandler (input chain fron AOD files)
1e996f55 135 // or to the OutputEventHandler ( AOD is create by a previus task in the train )
6ef5bfa4 136 // we need to check where it is and get the pointer to AODEvent in the right way
f3050824 137
6ef5bfa4 138 if (fDebug > 1) AliInfo("ConnectInputData() \n");
f3050824 139
140 TObject* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
141
142 if( handler && handler->InheritsFrom("AliAODInputHandler") ) {
6ef5bfa4 143 fAOD = ((AliAODInputHandler*)handler)->GetEvent();
144 if (fDebug > 1) AliInfo(" ==== Tracks from AliAODInputHandler");
145 // Case when jets are reconstructed on the fly from AOD tracks
146 // (the Jet Finder is using the AliJetAODReader) of InputEventHandler
147 // and put in the OutputEventHandler AOD. Useful whe you want to reconstruct jets with
148 // different parameters to default ones stored in the AOD or to use a different algorithm
149 if( fJetsOnFly ) {
f3050824 150 handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
151 if( handler && handler->InheritsFrom("AliAODHandler") ) {
6ef5bfa4 152 fAODjets = ((AliAODHandler*)handler)->GetAOD();
153 if (fDebug > 1) AliInfo(" ==== Jets from AliAODHandler");
f3050824 154 }
6ef5bfa4 155 } else {
156 fAODjets = fAOD;
157 if (fDebug > 1) AliInfo(" ==== Jets from AliAODInputHandler");
158 }
159 } else {
160 handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
161 if( handler && handler->InheritsFrom("AliAODHandler") ) {
162 fAOD = ((AliAODHandler*)handler)->GetAOD();
163 fAODjets = fAOD;
164 if (fDebug > 1) AliInfo(" ==== Tracks and Jets from AliAODHandler");
165 } else {
166 AliFatal("I can't get any AOD Event Handler");
167 return;
168 }
169 }
f3050824 170}
171
172//____________________________________________________________________
173void AliAnalysisTaskUE::CreateOutputObjects()
174{
6ef5bfa4 175 // Create the output container
176 //
f3050824 177 if (fDebug > 1) AliInfo("CreateOutPutData()");
178 //
179 // Histograms
1e996f55 180
181 OpenFile(0);
f3050824 182 CreateHistos();
1e996f55 183 // fListOfHistos->SetOwner(kTRUE);
184
185
f3050824 186}
187
188
189//____________________________________________________________________
190void AliAnalysisTaskUE::Exec(Option_t */*option*/)
191{
6ef5bfa4 192 // Execute analysis for current event
193 //
194 if ( fDebug > 3 ) AliInfo( " Processing event..." );
195 AnalyseUE();
196
f3050824 197 // Post the data
198 PostData(0, fListOfHistos);
199}
f3050824 200
201//____________________________________________________________________
202void AliAnalysisTaskUE::AnalyseUE()
203{
204 //
205 // Look for correlations on the tranverse regions to
206 // the leading charged jet
207 //
6ef5bfa4 208
f3050824 209 // ------------------------------------------------
210 // Find Leading Jets 1,2,3
211 // (could be skipped if Jets are sort by Pt...)
212 Double_t maxPtJet1 = 0.;
213 Int_t index1 = -1;
214 Double_t maxPtJet2 = 0.; // jet 2 need for back to back inclusive
215 Int_t index2 = -1;
216 Double_t maxPtJet3 = 0.; // jet 3 need for back to back exclusive
217 Int_t index3 = -1;
6ef5bfa4 218 TVector3 jetVect[3];
219 Int_t nJets = 0;
220
221 if( !fUseChPartJet ) {
222
223 // Use AOD Jets
224 nJets = fAODjets->GetNJets();
225 // printf("AOD %d jets \n", nJets);
226 for( Int_t i=0; i<nJets; ++i ) {
227 AliAODJet* jet = fAODjets->GetJet(i);
228 Double_t jetPt = jet->Pt();//*1.666; // FIXME Jet Pt Correction ?????!!!
229 if( jetPt > maxPtJet1 ) {
230 maxPtJet3 = maxPtJet2; index3 = index2;
231 maxPtJet2 = maxPtJet1; index2 = index1;
232 maxPtJet1 = jetPt; index1 = i;
233 } else if( jetPt > maxPtJet2 ) {
234 maxPtJet3 = maxPtJet2; index3 = index2;
235 maxPtJet2 = jetPt; index2 = i;
236 } else if( jetPt > maxPtJet3 ) {
237 maxPtJet3 = jetPt; index3 = i;
238 }
239 }
240 if( index1 != -1 ) {
241 AliAODJet* jet = fAODjets->GetJet(index1);
242 jetVect[0].SetXYZ(jet->Px(), jet->Py(), jet->Pz());
243 }
244 if( index2 != -1 ) {
245 AliAODJet* jet = fAODjets->GetJet(index2);
246 jetVect[1].SetXYZ(jet->Px(), jet->Py(), jet->Pz());
247 }
248 if( index3 != -1 ) {
249 AliAODJet* jet = fAODjets->GetJet(index3);
250 jetVect[2].SetXYZ(jet->Px(), jet->Py(), jet->Pz());
251 }
252
253 } else {
254
255 // Use "Charged Particle Jets"
256 TObjArray* jets = FindChargedParticleJets();
257 if( jets ) {
258 nJets = jets->GetEntriesFast();
259 if( nJets > 0 ) {
260 index1 = 0;
261 AliAODJet* jet = (AliAODJet*)jets->At(0);
262 maxPtJet1 = jet->Pt();
263 jetVect[0].SetXYZ(jet->Px(), jet->Py(), jet->Pz());
264 }
265 if( nJets > 1 ) {
266 index2 = 1;
267 AliAODJet* jet = (AliAODJet*)jets->At(1);
268 maxPtJet1 = jet->Pt();
269 jetVect[1].SetXYZ(jet->Px(), jet->Py(), jet->Pz());
270 }
271 if( nJets > 2 ) {
272 index3 = 2;
273 AliAODJet* jet = (AliAODJet*)jets->At(2);
274 maxPtJet1 = jet->Pt();
275 jetVect[2].SetXYZ(jet->Px(), jet->Py(), jet->Pz());
276 }
277
278 jets->Delete();
279 delete jets;
f3050824 280 }
281 }
6ef5bfa4 282
f3050824 283
284 fhNJets->Fill(nJets);
285
6ef5bfa4 286 if( fDebug > 1 ) {
287 if( index1 < 0 ) {
288 AliInfo("\n Skipping Event, not jet found...");
289 return;
290 } else
291 AliInfo(Form("\n Pt Leading Jet = %6.1f eta=%5.3f ", maxPtJet1, jetVect[0].Eta() ));
292 }
293
f3050824 294
295 // ----------------------------------------------
6ef5bfa4 296 // Cut events by jets topology
f3050824 297 // fAnaType:
6ef5bfa4 298 // 1 = inclusive,
f3050824 299 // - Jet1 |eta| < fJet1EtaCut
300 // 2 = back to back inclusive
301 // - fulfill case 1
302 // - |Jet1.Phi - Jet2.Phi| > fJet2DeltaPhiCut
303 // - Jet2.Pt/Jet1Pt > fJet2RatioPtCut
6ef5bfa4 304 // 3 = back to back exclusive
f3050824 305 // - fulfill case 2
306 // - Jet3.Pt < fJet3PtCut
307
6ef5bfa4 308 if( index1 < 0 || TMath::Abs(jetVect[0].Eta()) > fJet1EtaCut) {
309 if( fDebug > 1 ) AliInfo("\n Skipping Event...Jet1 |eta| > fJet1EtaCut");
f3050824 310 return;
311 }
f3050824 312 // back to back inclusive
6ef5bfa4 313 if( fAnaType > 1 && index2 == -1 ) {
314 if( fDebug > 1 ) AliInfo("\n Skipping Event... no second Jet found");
315 return;
316 }
317 if( fAnaType > 1 && index2 > -1 ) {
f3050824 318 if( TMath::Abs(jetVect[0].DeltaPhi(jetVect[1])) < fJet2DeltaPhiCut ||
6ef5bfa4 319 maxPtJet2/maxPtJet1 < fJet2RatioPtCut ) {
320 if( fDebug > 1 ) AliInfo("\n Skipping Event... |Jet1.Phi - Jet2.Phi| < fJet2DeltaPhiCut");
321 return;
f3050824 322 }
f3050824 323 }
f3050824 324 // back to back exclusive
6ef5bfa4 325 if( fAnaType > 2 && index3 > -1 ) {
326 if( maxPtJet3 > fJet3PtCut ) {
327 if( fDebug > 1 ) AliInfo("\n Skipping Event... Jet3.Pt > fJet3PtCut ");
f3050824 328 return;
329 }
f3050824 330 }
f3050824 331
f3050824 332 fhEleadingPt->Fill( maxPtJet1 );
6ef5bfa4 333 //Area for Normalization Purpose at Display histos
334 SetRegionArea(jetVect);
335
f3050824 336 // ----------------------------------------------
337 // Find max and min regions
338 Double_t sumPtRegionPosit = 0.;
339 Double_t sumPtRegionNegat = 0.;
340 Double_t maxPartPtRegion = 0.;
341 Int_t nTrackRegionPosit = 0;
342 Int_t nTrackRegionNegat = 0;
343 static const Double_t k270rad = 270.*TMath::Pi()/180.;
344
345 Int_t nTracks = fAOD->GetNTracks();
346 for (Int_t ipart=0; ipart<nTracks; ++ipart) {
347 AliAODTrack* part = fAOD->GetTrack( ipart );
6ef5bfa4 348 if ( !part->TestFilterBit(fFilterBit) ) continue; // track cut selection
349 // PID Selection: Reject everything but hadrons
350 Bool_t isHadron = part->GetMostProbablePID()==AliAODTrack::kPion ||
351 part->GetMostProbablePID()==AliAODTrack::kKaon ||
352 part->GetMostProbablePID()==AliAODTrack::kProton;
353 if ( !isHadron ) continue;
354
355 if ( !part->Charge() ) continue; //Only charged
356 if ( fUseSingleCharge ) { // Charge selection
357 if ( fUsePositiveCharge && part->Charge() < 0.) continue; // keep Positives
358 if ( !fUsePositiveCharge && part->Charge() > 0.) continue; // keep Negatives
359 }
360
f3050824 361 if ( part->Pt() < fTrackPtCut ) continue;
6ef5bfa4 362
f3050824 363 TVector3 partVect(part->Px(), part->Py(), part->Pz());
364
365 Double_t deltaPhi = jetVect[0].DeltaPhi(partVect)+k270rad;
366 if( deltaPhi > 2.*TMath::Pi() ) deltaPhi-= 2.*TMath::Pi();
de6f8090 367 fhdNdEtaPhiDist->Fill( deltaPhi );
f3050824 368 fhFullRegPartPtDistVsEt->Fill( part->Pt(), maxPtJet1 );
6ef5bfa4 369
f3050824 370 Int_t region = IsTrackInsideRegion( jetVect, &partVect );
371
372 if (region > 0) {
6ef5bfa4 373 if( maxPartPtRegion < part->Pt() ) maxPartPtRegion = part->Pt();
374 sumPtRegionPosit += part->Pt();
375 nTrackRegionPosit++;
376 fhTransRegPartPtDistVsEt->Fill( part->Pt(), maxPtJet1 );
f3050824 377 }
378 if (region < 0) {
6ef5bfa4 379 if( maxPartPtRegion < part->Pt() ) maxPartPtRegion = part->Pt();
380 sumPtRegionNegat += part->Pt();
381 nTrackRegionNegat++;
382 fhTransRegPartPtDistVsEt->Fill( part->Pt(), maxPtJet1 );
f3050824 383 }
384 }
6ef5bfa4 385
f3050824 386 //How quantities will be sorted before Fill Min and Max Histogram
387 // 1=Plots will be CDF-like
388 // 2=Plots will be Marchesini-like
6ef5bfa4 389 if( fOrdering == 1 ) {
390 if( sumPtRegionPosit > sumPtRegionNegat ) {
391 FillSumPtRegion( maxPtJet1, sumPtRegionPosit/fAreaReg, sumPtRegionNegat/fAreaReg );
f3050824 392 } else {
6ef5bfa4 393 FillSumPtRegion( maxPtJet1, sumPtRegionNegat/fAreaReg, sumPtRegionPosit/fAreaReg );
f3050824 394 }
395 if (nTrackRegionPosit > nTrackRegionNegat ) {
6ef5bfa4 396 FillMultRegion( maxPtJet1, nTrackRegionPosit/fAreaReg, nTrackRegionNegat/fAreaReg, sumPtRegionNegat/fAreaReg );
f3050824 397 } else {
6ef5bfa4 398 FillMultRegion( maxPtJet1, nTrackRegionNegat/fAreaReg, nTrackRegionPosit/fAreaReg, sumPtRegionPosit/fAreaReg );
f3050824 399 }
6ef5bfa4 400 } else if( fOrdering == 2 ) {
f3050824 401 if (sumPtRegionPosit > sumPtRegionNegat) {
6ef5bfa4 402 FillSumPtRegion( maxPtJet1, sumPtRegionPosit/fAreaReg, sumPtRegionNegat/fAreaReg );
403 FillMultRegion( maxPtJet1, nTrackRegionPosit/fAreaReg, nTrackRegionNegat/fAreaReg, sumPtRegionNegat/fAreaReg );
f3050824 404 } else {
6ef5bfa4 405 FillSumPtRegion( maxPtJet1, sumPtRegionNegat/fAreaReg, sumPtRegionPosit/fAreaReg );
406 FillMultRegion( maxPtJet1, nTrackRegionNegat/fAreaReg, nTrackRegionPosit/fAreaReg, sumPtRegionPosit/fAreaReg );
f3050824 407 }
408 }
409
410 Double_t avePosRegion = (nTrackRegionPosit) ? sumPtRegionPosit/nTrackRegionPosit : 0.;
411 Double_t aveNegRegion = (nTrackRegionNegat) ? sumPtRegionNegat/nTrackRegionNegat : 0.;
6ef5bfa4 412 if( avePosRegion > aveNegRegion ) {
413 FillAvePartPtRegion( maxPtJet1, avePosRegion/fAreaReg, aveNegRegion/fAreaReg );
f3050824 414 } else {
6ef5bfa4 415 FillAvePartPtRegion( maxPtJet1, aveNegRegion/fAreaReg, avePosRegion/fAreaReg );
f3050824 416 }
6ef5bfa4 417
f3050824 418 fhRegionMaxPartPtMaxVsEt->Fill(maxPtJet1, maxPartPtRegion );
6ef5bfa4 419
420 // Compute pedestal like magnitudes
421 fhRegionDiffSumPtVsEt->Fill(maxPtJet1, TMath::Abs(sumPtRegionPosit-sumPtRegionNegat)/(2.0*fAreaReg));
422 fhRegionAveSumPtVsEt->Fill(maxPtJet1, (sumPtRegionPosit+sumPtRegionNegat)/(2.0*fAreaReg));
423
f3050824 424}
425
f3050824 426//____________________________________________________________________
427void AliAnalysisTaskUE::FillSumPtRegion( Double_t leadingE, Double_t ptMax, Double_t ptMin )
428{
6ef5bfa4 429 // Fill sumPt of control regions
430
431 // Max cone
432 fhRegionSumPtMaxVsEt->Fill( leadingE, ptMax );
433 // Min cone
434 fhRegionSumPtMinVsEt->Fill( leadingE, ptMin );
435 // MAke distributions for UE comparison with MB data
436 fhMinRegSumPt->Fill(ptMin);
f3050824 437}
438
439//____________________________________________________________________
440void AliAnalysisTaskUE::FillAvePartPtRegion( Double_t leadingE, Double_t ptMax, Double_t ptMin )
441{
6ef5bfa4 442 // Fill average particle Pt of control regions
443
444 // Max cone
445 fhRegionAvePartPtMaxVsEt->Fill( leadingE, ptMax );
446 // Min cone
447 fhRegionAvePartPtMinVsEt->Fill( leadingE, ptMin );
448 // MAke distributions for UE comparison with MB data
449 fhMinRegAvePt->Fill(ptMin);
f3050824 450}
451
452//____________________________________________________________________
453void AliAnalysisTaskUE::FillMultRegion( Double_t leadingE, Double_t nTrackPtmax, Double_t nTrackPtmin, Double_t ptMin )
454{
6ef5bfa4 455 // Fill Nch multiplicity of control regions
456
457 // Max cone
458 fhRegionMultMaxVsEt->Fill( leadingE, nTrackPtmax );
459 fhRegionMultMax->Fill( nTrackPtmax );
460 // Min cone
461 fhRegionMultMinVsEt->Fill( leadingE, nTrackPtmin );
462 fhRegionMultMin->Fill( nTrackPtmin );
463 // MAke distributions for UE comparison with MB data
464 fhMinRegSumPtvsMult->Fill(nTrackPtmin,ptMin);
f3050824 465}
466
467//____________________________________________________________________
468Int_t AliAnalysisTaskUE::IsTrackInsideRegion(TVector3 *jetVect, TVector3 *partVect)
469{
470 // return de region in delta phi
471 // -1 negative delta phi
472 // 1 positive delta phi
473 // 0 outside region
474 static const Double_t k60rad = 60.*TMath::Pi()/180.;
475 static const Double_t k120rad = 120.*TMath::Pi()/180.;
476
477 Int_t region = 0;
478 if( fRegionType == 1 ) {
479 if( TMath::Abs(partVect->Eta()) > fTrackEtaCut ) return 0;
480 // transverse regions
481 if (jetVect[0].DeltaPhi(*partVect) < -k60rad && jetVect[0].DeltaPhi(*partVect) > -k120rad ) region = -1;
482 if (jetVect[0].DeltaPhi(*partVect) > k60rad && jetVect[0].DeltaPhi(*partVect) < k120rad ) region = 1;
6ef5bfa4 483
f3050824 484 } else if( fRegionType == 2 ) {
485 // Cone regions
486 Double_t deltaR = 0.;
487
488 TVector3 positVect,negatVect;
489 positVect.SetMagThetaPhi(1, 2.*atan(exp(-jetVect[0].Eta())), jetVect[0].Phi()+TMath::PiOver2());
490 negatVect.SetMagThetaPhi(1, 2.*atan(exp(-jetVect[0].Eta())), jetVect[0].Phi()-TMath::PiOver2());
491
492 if (TMath::Abs(positVect.DeltaPhi(*partVect)) < fConeRadius ) {
6ef5bfa4 493 region = 1;
494 deltaR = positVect.DrEtaPhi(*partVect);
f3050824 495 } else if (TMath::Abs(negatVect.DeltaPhi(*partVect)) < fConeRadius) {
6ef5bfa4 496 region = -1;
497 deltaR = negatVect.DrEtaPhi(*partVect);
f3050824 498 }
499
500 if (deltaR > fConeRadius) region = 0;
6ef5bfa4 501
f3050824 502 } else
503 AliError("Unknow region type");
6ef5bfa4 504
f3050824 505 // For debug (to be removed)
506 //if( region != 0 ) fhValidRegion->Fill( partVect->Eta()-jetVect[0].Eta(), jetVect[0].DeltaPhi(*partVect) );
507
508 return region;
509}
510
6ef5bfa4 511
512//____________________________________________________________________
513TObjArray* AliAnalysisTaskUE::FindChargedParticleJets()
514{
515 // Return a TObjArray of "charged particle jets"
516 //
517 // Charged particle jet definition from reference:
518 //
519 // "Charged jet evolution and the underlying event
520 // in proton-antiproton collisions at 1.8 TeV"
521 // PHYSICAL REVIEW D 65 092002, CDF Collaboration
522 //
523 // We define "jets" as circular regions in eta-phi space with
524 // radius defined by R = sqrt( (eta-eta0)^2 +(phi-phi0)^2 ).
525 // Our jet algorithm is as follows:
526 // 1- Order all charged particles according to their pT .
527 // 2- Start with the highest pT particle and include in the jet all
528 // particles within the radius R=0.7 considering each particle
529 // in the order of decreasing pT and recalculating the centroid
530 // of the jet after each new particle is added to the jet .
531 // 3- Go to the next highest pT particle not already included in
532 // a jet and add to the jet all particles not already included in
533 // a jet within R=0.7.
534 // 4- Continue until all particles are in a jet.
535 // We define the transverse momentum of the jet to be
536 // the scalar pT sum of all the particles within the jet, where pT
537 // is measured with respect to the beam axis
538
539 // 1 - Order all charged particles according to their pT .
540 Int_t nTracks = fAOD->GetNTracks();
541 if( !nTracks ) return 0;
542 TObjArray tracks(nTracks);
543
544 for (Int_t ipart=0; ipart<nTracks; ++ipart) {
545 AliAODTrack* part = fAOD->GetTrack( ipart );
546 if( !part->TestFilterBit(fFilterBit) ) continue; // track cut selection
547 if( !part->Charge() ) continue;
548 if( part->Pt() < fTrackPtCut ) continue;
549 tracks.AddLast(part);
550 }
551 QSortTracks( tracks, 0, tracks.GetEntriesFast() );
552
553 nTracks = tracks.GetEntriesFast();
554 if( !nTracks ) return 0;
555 TObjArray *jets = new TObjArray(nTracks);
556 TIter itrack(&tracks);
557 while( nTracks ) {
558 // 2- Start with the highest pT particle ...
559 Float_t px,py,pz,pt;
560 AliAODTrack* track = (AliAODTrack*)itrack.Next();
561 if( !track ) continue;
562 px = track->Px();
563 py = track->Py();
564 pz = track->Pz();
565 pt = track->Pt(); // Use the energy member to store Pt
566 jets->AddLast( new TLorentzVector(px, py, pz, pt) );
567 tracks.Remove( track );
568 TLorentzVector* jet = (TLorentzVector*)jets->Last();
569 // 3- Go to the next highest pT particle not already included...
570 AliAODTrack* track1;
571 while ( (track1 = (AliAODTrack*)(itrack.Next())) ) {
572 Double_t dphi = TVector2::Phi_mpi_pi(jet->Phi()-track1->Phi());
573 Double_t r = TMath::Sqrt( (jet->Eta()-track1->Eta())*(jet->Eta()-track1->Eta()) +
574 dphi*dphi );
575 if( r < fConeRadius ) {
de6f8090 576 Double_t fPt = jet->E()+track1->Pt(); // Scalar sum of Pt
6ef5bfa4 577 // recalculating the centroid
de6f8090 578 Double_t eta = jet->Eta()*jet->E()/fPt + track1->Eta()/fPt;
579 Double_t phi = jet->Phi()*jet->E()/fPt + track1->Phi()/fPt;
580 jet->SetPtEtaPhiE( 1., eta, phi, fPt );
6ef5bfa4 581 tracks.Remove( track1 );
582 }
583 }
584
585 tracks.Compress();
586 nTracks = tracks.GetEntries();
587 // 4- Continue until all particles are in a jet.
588 itrack.Reset();
589 } // end while nTracks
590
591 // Convert to AODjets....
592 Int_t njets = jets->GetEntriesFast();
593 TObjArray* aodjets = new TObjArray(njets);
594 aodjets->SetOwner(kTRUE);
595 for(Int_t ijet=0; ijet<njets; ++ijet) {
596 TLorentzVector* jet = (TLorentzVector*)jets->At(ijet);
597 Float_t px, py,pz,en; // convert to 4-vector
598 px = jet->E() * TMath::Cos(jet->Phi()); // Pt * cos(phi)
599 py = jet->E() * TMath::Sin(jet->Phi()); // Pt * sin(phi)
600 pz = jet->E() / TMath::Tan(2.0 * TMath::ATan(TMath::Exp(-jet->Eta())));
601 en = TMath::Sqrt(px * px + py * py + pz * pz);
602 aodjets->AddLast( new AliAODJet(px, py, pz, en) );
603 }
604 // Order jets according to their pT .
605 QSortTracks( *aodjets, 0, aodjets->GetEntriesFast() );
606
607 // debug
608 if (fDebug>3) AliInfo(Form(" %d Charged jets found\n",njets));
609
610 return aodjets;
611}
612
613//____________________________________________________________________
614void AliAnalysisTaskUE::QSortTracks(TObjArray &a, Int_t first, Int_t last)
615{
616 // Sort array of TObjArray of tracks by Pt using a quicksort algorithm.
617
618 static TObject *tmp;
619 static int i; // "static" to save stack space
620 int j;
621
622 while (last - first > 1) {
623 i = first;
624 j = last;
625 for (;;) {
626 while (++i < last && ((AliVParticle*)a[i])->Pt() > ((AliVParticle*)a[first])->Pt() )
627 ;
628 while (--j > first && ((AliVParticle*)a[j])->Pt() < ((AliVParticle*)a[first])->Pt() )
629 ;
630 if (i >= j)
631 break;
632
633 tmp = a[i];
634 a[i] = a[j];
635 a[j] = tmp;
636 }
637 if (j == first) {
638 ++first;
639 continue;
640 }
641 tmp = a[first];
642 a[first] = a[j];
643 a[j] = tmp;
644 if (j - first < last - (j + 1)) {
645 QSortTracks(a, first, j);
646 first = j + 1; // QSortTracks(j + 1, last);
647 } else {
648 QSortTracks(a, j + 1, last);
649 last = j; // QSortTracks(first, j);
650 }
651 }
652}
653
654//____________________________________________________________________
655void AliAnalysisTaskUE::SetRegionArea(TVector3 *jetVect)
656{
657 Double_t fAreaCorrFactor=0.;
658 Double_t deltaEta = 0.;
659 if (fRegionType==1) fAreaReg = 2.*fTrackEtaCut*60.*TMath::Pi()/180.;
660 else if (fRegionType==2){
661 deltaEta = 0.9-TMath::Abs(jetVect[0].Eta());
662 if (deltaEta>fConeRadius) fAreaReg = TMath::Pi()*fConeRadius*fConeRadius;
663 else{
664 fAreaCorrFactor = fConeRadius*fConeRadius*TMath::ACos(deltaEta/fConeRadius) -
665 (deltaEta*fConeRadius)*TMath::Sqrt( 1. - deltaEta*deltaEta/(fConeRadius*fConeRadius));
666 fAreaReg=TMath::Pi()*fConeRadius*fConeRadius-fAreaCorrFactor;
667 }
668 }else AliWarning("Unknown Rgion Type");
669 if (fDebug>5) AliInfo(Form("\n dEta=%5.3f Angle =%5.3f Region Area = %5.3f Corr Factor=%5.4f \n",deltaEta,TMath::ACos(deltaEta/fConeRadius),fAreaReg,fAreaCorrFactor));
670}
671
f3050824 672//____________________________________________________________________
673void AliAnalysisTaskUE::CreateHistos()
674{
675 fListOfHistos = new TList();
676
677
678 fhNJets = new TH1F("fhNJets", "n Jet", 10, 0, 10);
679 fhNJets->SetXTitle("# of jets");
680 fhNJets->Sumw2();
f3050824 681 fListOfHistos->Add( fhNJets ); // At(0)
682
683 fhEleadingPt = new TH1F("hEleadingPt", "Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
684 fhEleadingPt->SetXTitle("P_{T} (GeV/c)");
685 fhEleadingPt->SetYTitle("dN/dP_{T}");
686 fhEleadingPt->Sumw2();
687 fListOfHistos->Add( fhEleadingPt ); // At(1)
688
689 fhMinRegPtDist = new TH1F("hMinRegPtDist", "P_{T} distribution in Min zone", 50,0.,20.);
690 fhMinRegPtDist->SetXTitle("P_{T} (GeV/c)");
691 fhMinRegPtDist->SetYTitle("dN/dP_{T}");
692 fhMinRegPtDist->Sumw2();
693 fListOfHistos->Add( fhMinRegPtDist ); // At(2)
694
695 fhRegionMultMin = new TH1F("hRegionMultMin", "N_{ch}^{90, min}", 21, -0.5, 20.5);
696 fhRegionMultMin->SetXTitle("N_{ch tracks}");
697 fhRegionMultMin->Sumw2();
698 fListOfHistos->Add( fhRegionMultMin ); // At(3)
699
700 fhMinRegAvePt = new TH1F("hMinRegAvePt", "#LTp_{T}#GT", 50, 0., 20.);
701 fhMinRegAvePt->SetXTitle("P_{T} (GeV/c)");
702 fhMinRegAvePt->Sumw2();
703 fListOfHistos->Add( fhMinRegAvePt ); // At(4)
704
705 fhMinRegSumPt = new TH1F("hMinRegSumPt", "#Sigma p_{T} ", 50, 0., 20.);
706 fhMinRegSumPt->SetYTitle("Ed^{3}N_{tracks}/dp^{3} (c^{3}/GeV^{2})");
707 fhMinRegSumPt->SetXTitle("#Sigma p_{T} (GeV/c)");
708 fhMinRegSumPt->Sumw2();
709 fListOfHistos->Add( fhMinRegSumPt ); // At(5)
6ef5bfa4 710
f3050824 711 fhMinRegMaxPtPart = new TH1F("hMinRegMaxPtPart", "max(p_{T})|_{event} ", 50, 0., 20.);
712 fhMinRegMaxPtPart->SetYTitle("Ed^{3}N_{tracks}/dp^{3} (c^{3}/GeV^{2})");
713 fhMinRegMaxPtPart->SetXTitle("p_{T} (GeV/c)");
714 fhMinRegMaxPtPart->Sumw2();
715 fListOfHistos->Add( fhMinRegMaxPtPart ); // At(6)
716
717 fhMinRegSumPtvsMult = new TH1F("hMinRegSumPtvsMult", "#Sigma p_{T} vs. Multiplicity ", 21, -0.5, 20.5);
718 fhMinRegSumPtvsMult->SetYTitle("#Sigma p_{T} (GeV/c)");
719 fhMinRegSumPtvsMult->SetXTitle("N_{charge}");
720 fhMinRegSumPtvsMult->Sumw2();
721 fListOfHistos->Add( fhMinRegSumPtvsMult ); // At(7);
6ef5bfa4 722
de6f8090 723 fhdNdEtaPhiDist = new TH1F("hdNdEtaPhiDist", "Charge particle density |#eta|< 1 vs #Delta#phi", 120, 0., 2.*TMath::Pi());
724 fhdNdEtaPhiDist->SetXTitle("#Delta#phi");
725 fhdNdEtaPhiDist->SetYTitle("dN_{ch}/d#etad#phi");
726 fhdNdEtaPhiDist->Sumw2();
727 fListOfHistos->Add( fhdNdEtaPhiDist ); // At(8)
6ef5bfa4 728
f3050824 729 // Can be use to get part pt distribution for differente Jet Pt bins
730 fhFullRegPartPtDistVsEt = new TH2F("hFullRegPartPtDistVsEt", "dN/dP_{T} |#eta|<1 vs Leading Jet P_{T}",
6ef5bfa4 731 50,0.,50., fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
f3050824 732 fhFullRegPartPtDistVsEt->SetYTitle("Leading Jet P_{T}");
733 fhFullRegPartPtDistVsEt->SetXTitle("p_{T}");
734 fhFullRegPartPtDistVsEt->Sumw2();
735 fListOfHistos->Add( fhFullRegPartPtDistVsEt ); // At(9)
6ef5bfa4 736
737 // Can be use to get part pt distribution for differente Jet Pt bins
f3050824 738 fhTransRegPartPtDistVsEt = new TH2F("hTransRegPartPtDistVsEt", "dN/dP_{T} in tranvese regions |#eta|<1 vs Leading Jet P_{T}",
6ef5bfa4 739 50,0.,50., fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
f3050824 740 fhTransRegPartPtDistVsEt->SetYTitle("Leading Jet P_{T}");
741 fhTransRegPartPtDistVsEt->SetXTitle("p_{T}");
742 fhTransRegPartPtDistVsEt->Sumw2();
743 fListOfHistos->Add( fhTransRegPartPtDistVsEt ); // At(10)
744
745
746 fhRegionSumPtMaxVsEt = new TH1F("hRegionSumPtMaxVsEt", "P_{T}^{90, max} vs Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
747 fhRegionSumPtMaxVsEt->SetXTitle("P_{T} (GeV/c)");
748 fhRegionSumPtMaxVsEt->Sumw2();
749 fListOfHistos->Add( fhRegionSumPtMaxVsEt ); // At(11)
6ef5bfa4 750
f3050824 751 fhRegionSumPtMinVsEt = new TH1F("hRegionSumPtMinVsEt", "P_{T}^{90, min} vs Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
752 fhRegionSumPtMinVsEt->SetXTitle("P_{T} (GeV/c)");
753 fhRegionSumPtMinVsEt->Sumw2();
754 fListOfHistos->Add( fhRegionSumPtMinVsEt ); // At(12)
755
756 fhRegionMultMax = new TH1I("hRegionMultMax", "N_{ch}^{90, max}", 21, -0.5, 20.5);
757 fhRegionMultMax->SetXTitle("N_{ch tracks}");
758 fhRegionMultMax->Sumw2();
759 fListOfHistos->Add( fhRegionMultMax ); // At(13)
6ef5bfa4 760
f3050824 761 fhRegionMultMaxVsEt = new TH1F("hRegionMultMaxVsEt", "N_{ch}^{90, max} vs Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
762 fhRegionMultMaxVsEt->SetXTitle("E (GeV hRegionAveSumPtVsEt/c)");
763 fhRegionMultMaxVsEt->Sumw2();
764 fListOfHistos->Add( fhRegionMultMaxVsEt ); // At(14)
6ef5bfa4 765
f3050824 766 fhRegionMultMinVsEt = new TH1F("hRegionMultMinVsEt", "N_{ch}^{90, min} vs Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
767 fhRegionMultMinVsEt->SetXTitle("E (GeV/c)");
768 fhRegionMultMinVsEt->Sumw2();
769 fListOfHistos->Add( fhRegionMultMinVsEt ); // At(15)
6ef5bfa4 770
f3050824 771 fhRegionAveSumPtVsEt = new TH1F("hRegionAveSumPtVsEt", "(P_{T}^{90, max} + P_{T}^{90, min})/2 vs Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
772 fhRegionAveSumPtVsEt->SetXTitle("P_{T} (GeV/c)");
773 fhRegionAveSumPtVsEt->Sumw2();
774 fListOfHistos->Add( fhRegionAveSumPtVsEt ); // At(16)
6ef5bfa4 775
f3050824 776 fhRegionDiffSumPtVsEt= new TH1F("hRegionPtDiffVsEt", "(P_{T}^{90, max} - P_{T}^{90, min}) vs Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
777 fhRegionDiffSumPtVsEt->SetXTitle("P_{T} (GeV/c)");
778 fhRegionDiffSumPtVsEt->Sumw2();
779 fListOfHistos->Add( fhRegionDiffSumPtVsEt ); // At(17)
780
781 fhRegionAvePartPtMaxVsEt = new TH1F("hRegionAvePartPtMaxVsEt", "#LTp_{T}#GT^{90, max} vs Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
782 fhRegionAvePartPtMaxVsEt->SetXTitle("P_{T} (GeV/c)");
783 fhRegionAvePartPtMaxVsEt->Sumw2();
784 fListOfHistos->Add( fhRegionAvePartPtMaxVsEt ); // At(18)
6ef5bfa4 785
f3050824 786 fhRegionAvePartPtMinVsEt = new TH1F("hRegionAvePartPtMinVsEt", "#LTp_{T}#GT^{90, min} vs Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
787 fhRegionAvePartPtMinVsEt->SetXTitle("P_{T} (GeV/c)");
788 fhRegionAvePartPtMinVsEt->Sumw2();
789 fListOfHistos->Add( fhRegionAvePartPtMinVsEt ); // At(19)
6ef5bfa4 790
f3050824 791 fhRegionMaxPartPtMaxVsEt = new TH1F("hRegionMaxPartPtMaxVsEt", "max(p_{T})^{90} vs Leading Jet P_{T}", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
792 fhRegionMaxPartPtMaxVsEt->SetXTitle("P_{T} (GeV/c)");
793 fhRegionMaxPartPtMaxVsEt->Sumw2();
794 fListOfHistos->Add( fhRegionMaxPartPtMaxVsEt ); // At(20)
6ef5bfa4 795
1e996f55 796
6ef5bfa4 797 fSettingsTree = new TTree("UEAnalysisSettings","Analysis Settings in UE estimation");
1e996f55 798 fSettingsTree->Branch("fConeRadius", &fConeRadius,"Rad/D");
799 fSettingsTree->Branch("fJet1EtaCut", &fJet1EtaCut, "LeadJetEtaCut/D");
800 fSettingsTree->Branch("fJet2DeltaPhiCut", &fJet2DeltaPhiCut, "DeltaPhi/D");
801 fSettingsTree->Branch("fJet2RatioPtCut", &fJet2RatioPtCut, "Jet2Ratio/D");
802 fSettingsTree->Branch("fJet3PtCut", &fJet3PtCut, "Jet3PtCut/D");
803 fSettingsTree->Branch("fTrackPtCut", &fTrackPtCut, "TrackPtCut/D");
804 fSettingsTree->Branch("fTrackEtaCut", &fTrackEtaCut, "TrackEtaCut/D");
805 fSettingsTree->Branch("fAnaType", &fAnaType, "Ana/I");
806 fSettingsTree->Branch("fRegionType", &fRegionType,"Reg/I");
807 fSettingsTree->Branch("fOrdering", &fOrdering,"OrderMeth/I");
808 fSettingsTree->Branch("fUseChPartJet", &fUseChPartJet,"UseChPart/O");
809 fSettingsTree->Branch("fUseSingleCharge", &fUseSingleCharge,"UseSingleCh/O");
810 fSettingsTree->Branch("fUsePositiveCharge", &fUsePositiveCharge,"UsePositiveCh/O");
811 fSettingsTree->Fill();
812
813
6ef5bfa4 814 fListOfHistos->Add( fSettingsTree ); // At(21)
815
816 /*
817 // For debug region selection
818 fhValidRegion = new TH2F("hValidRegion", "dN/d#eta/d#phi",
819 20, -2.,2., 62, -TMath::Pi(), TMath::Pi());
820 fhValidRegion->SetYTitle("#Delta#phi");
821 fhValidRegion->Sumw2();
822 fListOfHistos->Add( fhValidRegion ); // At(15)
823 */
f3050824 824}
f3050824 825
6ef5bfa4 826//____________________________________________________________________
827void AliAnalysisTaskUE::Terminate(Option_t */*option*/)
828{
829 // Terminate analysis
830 //
831
832 //Save Analysis Settings
1e996f55 833 // WriteSettings();
6ef5bfa4 834
835 // Normalize histos to region area TODO:
836 // Normalization done at Analysis, taking into account
837 // area variations on per-event basis (cone case)
838
839 // Draw some Test plot to the screen
840 if (!gROOT->IsBatch()) {
841
842 // Update pointers reading them from the output slot
843 fListOfHistos = dynamic_cast<TList*> (GetOutputData(0));
844 if( !fListOfHistos ) {
845 AliError("Histogram List is not available");
846 return;
847 }
848 fhEleadingPt = (TH1F*)fListOfHistos->At(1);
de6f8090 849 fhdNdEtaPhiDist = (TH1F*)fListOfHistos->At(8);
6ef5bfa4 850 fhRegionSumPtMaxVsEt = (TH1F*)fListOfHistos->At(11);
851 fhRegionSumPtMinVsEt = (TH1F*)fListOfHistos->At(12);
852 fhRegionMultMaxVsEt = (TH1F*)fListOfHistos->At(14);
853 fhRegionMultMinVsEt = (TH1F*)fListOfHistos->At(15);
854 fhRegionAveSumPtVsEt = (TH1F*)fListOfHistos->At(16);
855
856 fhNJets = (TH1F*)fListOfHistos->At(0);
857
858 // Canvas
859 TCanvas* c1 = new TCanvas("c1",Form("sumPt dist (%s)", GetTitle()),60,60,1200,800);
860 c1->Divide(2,2);
861 c1->cd(1);
862 TH1F *h1r = new TH1F("hRegionEtvsSumPtMax" , "", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
863 h1r->Divide(fhRegionSumPtMaxVsEt,fhEleadingPt,1,1);
864 //h1r->Scale( areafactor );
865 h1r->SetMarkerStyle(20);
866 h1r->SetXTitle("P_{T} of Leading Jet (GeV/c)");
867 h1r->SetYTitle("P_{T}^{90, max}");
868 h1r->DrawCopy("p");
869
870 c1->cd(2);
871
872 TH1F *h2r = new TH1F("hRegionEtvsSumPtMin" , "", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
873 h2r->Divide(fhRegionSumPtMinVsEt,fhEleadingPt,1,1);
874 //h2r->Scale( areafactor );
875 h2r->SetMarkerStyle(20);
876 h2r->SetXTitle("P_{T} of Leading Jet (GeV/c)");
877 h2r->SetYTitle("P_{T}^{90, min}");
878 h2r->DrawCopy("p");
879
880 c1->cd(3);
881 TH1F *h4r = new TH1F("hRegionEtvsDiffPt" , "", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
882 h4r->Divide(fhRegionAveSumPtVsEt,fhEleadingPt,1,1);
883 h4r->Scale(2.); // make average
884 //h4r->Scale( areafactor );
885 h4r->SetYTitle("#DeltaP_{T}^{90}");
886 h4r->SetXTitle("P_{T} of Leading Jet (GeV/c)");
887 h4r->SetMarkerStyle(20);
888 h4r->DrawCopy("p");
889
890 c1->cd(4);
891 TH1F *h5r = new TH1F("hRegionMultMaxVsEtleading", "", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
892 TH1F *h6r = new TH1F("hRegionMultMinVsEtleading", "", fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
893
894 h5r->Divide(fhRegionMultMaxVsEt,fhEleadingPt,1,1);
895 h6r->Divide(fhRegionMultMinVsEt,fhEleadingPt,1,1);
896 //h5r->Scale( areafactor );
897 //h6r->Scale( areafactor );
898 h5r->SetYTitle("N_{Tracks}^{90}");
899 h5r->SetXTitle("P_{T} of Leading Jet (GeV/c)");
900 h5r->SetMarkerStyle(20);
901 h5r->DrawCopy("p");
902 h6r->SetMarkerStyle(21);
903 h6r->SetMarkerColor(2);
904 h6r->SetYTitle("N_{Tracks}^{90}");
905 h6r->SetXTitle("P_{T} of Leading Jet (GeV/c)");
906 h6r->DrawCopy("p same");
907 c1->Update();
908
909 TCanvas* c2 = new TCanvas("c2","Jet Pt dist",160,160,1200,800);
910 c2->Divide(2,2);
911 c2->cd(1);
912 fhEleadingPt->SetMarkerStyle(20);
913 fhEleadingPt->SetMarkerColor(2);
914 fhEleadingPt->DrawCopy("p");
915 gPad->SetLogy();
916
917 c2->cd(2);
de6f8090 918 fhdNdEtaPhiDist->SetMarkerStyle(20);
919 fhdNdEtaPhiDist->SetMarkerColor(2);
920 fhdNdEtaPhiDist->DrawCopy("p");
6ef5bfa4 921 gPad->SetLogy();
922
923 c2->cd(3);
924 fhNJets->DrawCopy();
925
926 //fhTransRegPartPtDist = (TH1F*)fListOfHistos->At(2);
927 fhRegionMultMin = (TH1F*)fListOfHistos->At(3);
928 fhMinRegAvePt = (TH1F*)fListOfHistos->At(4);
929 fhMinRegSumPt = (TH1F*)fListOfHistos->At(5);
930 //fhMinRegMaxPtPart = (TH1F*)fListOfHistos->At(6);
931 fhMinRegSumPtvsMult = (TH1F*)fListOfHistos->At(7);
932
933 // Canvas
934 TCanvas* c3 = new TCanvas("c3"," p_{T} dist",160,160,1200,800);
935 c3->Divide(2,2);
936 c3->cd(1);
937 /*fhTransRegPartPtDist->SetMarkerStyle(20);
938 fhTransRegPartPtDist->SetMarkerColor(2);
939 fhTransRegPartPtDist->Scale(areafactor/fhTransRegPartPtDist->GetEntries());
940 fhTransRegPartPtDist->DrawCopy("p");
941 gPad->SetLogy();
942 */
943 c3->cd(2);
944 fhMinRegSumPt->SetMarkerStyle(20);
945 fhMinRegSumPt->SetMarkerColor(2);
946 //fhMinRegSumPt->Scale(areafactor);
947 fhMinRegSumPt->DrawCopy("p");
948 gPad->SetLogy();
949
950 c3->cd(3);
951 fhMinRegAvePt->SetMarkerStyle(20);
952 fhMinRegAvePt->SetMarkerColor(2);
953 //fhMinRegAvePt->Scale(areafactor);
954 fhMinRegAvePt->DrawCopy("p");
955 gPad->SetLogy();
956
957 c3->cd(4);
958
959 TH1F *h7r = new TH1F("hRegionMultMinVsMult", "", 21, -0.5, 20.5);
960
961 h7r->Divide(fhMinRegSumPtvsMult,fhRegionMultMin,1,1);
962
963 h7r->SetMarkerStyle(20);
964 h7r->SetMarkerColor(2);
965 h7r->DrawCopy("p");
966
967 c3->Update();
968
969
970 /* c2->cd(3);
971 fhValidRegion->SetMarkerStyle(20);
972 fhValidRegion->SetMarkerColor(2);
973 fhValidRegion->DrawCopy("p");
974 */
975 c2->Update();
976 } else {
977 AliInfo(" Batch mode, not histograms will be shown...");
978 }
979
980 if( fDebug > 1 )
981 AliInfo("End analysis");
982
983}
f3050824 984
6ef5bfa4 985void AliAnalysisTaskUE::WriteSettings()
1e996f55 986{
6ef5bfa4 987 if (fDebug>5){
988 AliInfo(" All Analysis Settings in Saved Tree");
989 fSettingsTree->Scan();
990 }
991}