]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/EMCALTasks/AliAnalysisTaskEMCALTriggerQA.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
add histograms for combination of threshold 2 trigger when there is no threshold...
[u/mrichter/AliRoot.git] / PWGGA / EMCALTasks / AliAnalysisTaskEMCALTriggerQA.cxx
CommitLineData
863e74f5 1 /**************************************************************************
bce9493b 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
863e74f5 16//------------------------------------------------------------------------//
bce9493b 17// Fill histograms with basic QA information for EMCAL offline trigger //
e395081d 18// Author: Nicolas Arbor (LPSC-Grenoble), Rachid Guernane (LPSC-Grenoble)//
bce9493b 19// Gustavo Conesa Balbastre (LPSC-Grenoble) //
20// //
863e74f5 21// $Id$ //
bce9493b 22//------------------------------------------------------------------------//
23
bce9493b 24#include <TList.h>
bce9493b 25#include <TH2F.h>
26#include <TF1.h>
863e74f5 27#include <TProfile2D.h>
3200214a 28#include <TStreamerInfo.h>
29#include <TFile.h>
bce9493b 30
31#include "AliLog.h"
32#include "AliVCluster.h"
33#include "AliVCaloCells.h"
34#include "AliVEvent.h"
ec77a234 35#include "AliCentrality.h"
36
997b261e 37#include "AliVEvent.h"
38//#include "AliVVZERO.h"
39#include "AliVCaloTrigger.h"
40
41//#include "AliESDEvent.h"
bce9493b 42#include "AliESDVZERO.h"
997b261e 43//#include "AliESDCaloTrigger.h"
44
bce9493b 45#include "AliEMCALGeometry.h"
6bfd1538 46#include "AliEMCALRecoUtils.h"
2b4e1cc5 47#include "AliOADBContainer.h"
31a3f95a 48#include "AliAnalysisManager.h"
bce9493b 49
50#include "AliAnalysisTaskEMCALTriggerQA.h"
51
52ClassImp(AliAnalysisTaskEMCALTriggerQA)
53
85196c29 54//______________________________________________________________
863e74f5 55AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA() :
56AliAnalysisTaskSE(),
ec77a234 57fOutputList(0), fRecoUtils(0x0),
863e74f5 58fGeoSet(0), fGeometry(0), fGeoName(""),
31a3f95a 59fOADBSet(kFALSE), fAccessOADB(kTRUE), fOADBFilePath(""),
60fBitEGA(0), fBitEJE(0),
61fEtaPhiEnMin(10.),
46fec84c 62fSTUTotal(0), fTRUTotal(0),
63fV0Trigger(0), fV0A(0), fV0C(0),
64fEventMB (0), fEventL0 (0),
65fEventL1G (0), fEventL1G2 (0),
66fEventL1J (0), fEventL1J2 (0),
67fEventCen (0), fEventSem (0),
31a3f95a 68//Histograms
ec77a234 69fhNEvents(0), fhFORAmp(0),
46fec84c 70fhFORAmpL1G(0), fhFORAmpL1G2(0),
71fhFORAmpL1J(0), fhFORAmpL1J2(0),
863e74f5 72fhL0Amp(0), fhL0AmpL1G(0), fhL0AmpL1J(0),
73fhL1Amp(0), fhL1GAmp(0), fhL1G2Amp(0),
74fhL1JAmp(0), fhL1J2Amp(0), fhL1FOREnergy(0),
75fhL0Patch(0), fhL1GPatch(0), fhL1G2Patch(0),
76fhL1GPatchNotFake(0), fhL1GPatchFake(0), fhL1GPatchNotAllFake(0),
77fhL1GPatchAllFake(0), fhL1GPatchNotAllFakeMax(0),
78fhL1GPatchAllFakeMax(0), fhL1GPatchNotAllFakeMaxE(0),
79fhL1GPatchAllFakeMaxE(0), fhL1GPatchNotAllFakeE(0),
80fhL1GPatchAllFakeE(0), fhL1GPatchFakeE(0),
46fec84c 81fhL1GPatchNotFakeE(0), fhNPatchFake(0), fhNPatchNotFake(0),
6be2314f 82fhL1JPatch(0), fhL1J2Patch(0),
ec77a234 83fhFEESTU(0), fhTRUSTU(0), fhV0STU(0),
84fhGPMaxVV0TT(0), fhJPMaxVV0TT(0),
85fhFORMeanAmp(0), fhL0MeanAmp(0), fhL1MeanAmp(0),
46fec84c 86fhL1GPatchMax(0), fhL1G2PatchMax(0),
87fhL1JPatchMax(0), fhL1J2PatchMax(0),
ec77a234 88//Histogram settings
89fNBinsSTUSignal (2000), fMaxSTUSignal (200000),
90fNBinsTRUSignal (2000), fMaxTRUSignal (200000),
91fNBinsV0Signal (5000), fMaxV0Signal (100000),
92fNBinsSTUFEERatio(1000), fMaxSTUFEERatio(100),
93fNBinsSTUTRURatio(1000), fMaxSTUTRURatio(100),
46fec84c 94fNBinsClusterE (500), fMaxClusterE (200),
95fMapCell (),
96fMapCellL1G (), fMapCellL1G2 (),
97fMapCellL1J (), fMapCellL1J2 (),
98fMapTrigL0 (), fMapTrigL1 (),
99fMapTrigL0L1G(), fMapTrigL0L1J(),
100fMapTrigL1G (), fMapTrigL1G2 (),
101fMapTrigL1J (), fMapTrigL1J2 ()
bce9493b 102{
103 // Constructor
863e74f5 104
31a3f95a 105 InitHistogramArrays();
106
ec77a234 107 DefineOutput(1, TList::Class());
108
863e74f5 109}
bce9493b 110
85196c29 111//______________________________________________________________________________
863e74f5 112AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA(const char *name) :
113AliAnalysisTaskSE(name),
ec77a234 114fOutputList(0), fRecoUtils(0x0),
863e74f5 115fGeoSet(0), fGeometry(0), fGeoName(""),
31a3f95a 116fOADBSet(kFALSE), fAccessOADB(kTRUE), fOADBFilePath(""),
117fBitEGA(0), fBitEJE(0),
118fEtaPhiEnMin(10.),
46fec84c 119fSTUTotal(0), fTRUTotal(0),
120fV0Trigger(0), fV0A(0), fV0C(0),
121fEventMB (0), fEventL0 (0),
122fEventL1G (0), fEventL1G2 (0),
123fEventL1J (0), fEventL1J2 (0),
124fEventCen (0), fEventSem (0),
31a3f95a 125//Histograms
ec77a234 126fhNEvents(0), fhFORAmp(0),
46fec84c 127fhFORAmpL1G(0), fhFORAmpL1G2(0),
128fhFORAmpL1J(0), fhFORAmpL1J2(0),
863e74f5 129fhL0Amp(0), fhL0AmpL1G(0), fhL0AmpL1J(0),
130fhL1Amp(0), fhL1GAmp(0), fhL1G2Amp(0),
131fhL1JAmp(0), fhL1J2Amp(0), fhL1FOREnergy(0),
132fhL0Patch(0), fhL1GPatch(0), fhL1G2Patch(0),
133fhL1GPatchNotFake(0), fhL1GPatchFake(0), fhL1GPatchNotAllFake(0),
134fhL1GPatchAllFake(0), fhL1GPatchNotAllFakeMax(0),
135fhL1GPatchAllFakeMax(0), fhL1GPatchNotAllFakeMaxE(0),
136fhL1GPatchAllFakeMaxE(0), fhL1GPatchNotAllFakeE(0),
137fhL1GPatchAllFakeE(0), fhL1GPatchFakeE(0),
46fec84c 138fhL1GPatchNotFakeE(0), fhNPatchFake(0), fhNPatchNotFake(0),
6be2314f 139fhL1JPatch(0), fhL1J2Patch(0),
ec77a234 140fhFEESTU(0), fhTRUSTU(0), fhV0STU(0),
141fhGPMaxVV0TT(0), fhJPMaxVV0TT(0),
142fhFORMeanAmp(0), fhL0MeanAmp(0), fhL1MeanAmp(0),
46fec84c 143fhL1GPatchMax(0), fhL1G2PatchMax(0),
144fhL1JPatchMax(0), fhL1J2PatchMax(0),
ec77a234 145//Histogram settings
146fNBinsSTUSignal (2000), fMaxSTUSignal (200000),
147fNBinsTRUSignal (2000), fMaxTRUSignal (200000),
148fNBinsV0Signal (5000), fMaxV0Signal (100000),
149fNBinsSTUFEERatio(1000), fMaxSTUFEERatio(100),
150fNBinsSTUTRURatio(1000), fMaxSTUTRURatio(100),
46fec84c 151fNBinsClusterE (500), fMaxClusterE (200),
152fMapCell (),
153fMapCellL1G (), fMapCellL1G2 (),
154fMapCellL1J (), fMapCellL1J2 (),
155fMapTrigL0 (), fMapTrigL1 (),
156fMapTrigL0L1G(), fMapTrigL0L1J(),
157fMapTrigL1G (), fMapTrigL1G2 (),
158fMapTrigL1J (), fMapTrigL1J2 ()
bce9493b 159{
160 // Constructor
863e74f5 161
31a3f95a 162 InitHistogramArrays();
863e74f5 163
2b4e1cc5 164 DefineOutput(1, TList::Class());
bce9493b 165
2b4e1cc5 166}
167
2b4e1cc5 168//______________________________________________
169void AliAnalysisTaskEMCALTriggerQA::AccessOADB()
170{
171 // Set the AODB bad channels at least once
ec77a234 172
2b4e1cc5 173 //Set it only once
863e74f5 174 if(fOADBSet) return ;
31a3f95a 175
863e74f5 176 if(fOADBFilePath == "") fOADBFilePath = "$ALICE_ROOT/OADB/EMCAL" ;
2b4e1cc5 177
178 Int_t runnumber = InputEvent()->GetRunNumber() ;
179
180 if(DebugLevel() > 0)
181 printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Get AODB parameters from EMCAL in %s for run %d\n",fOADBFilePath.Data(),runnumber);
182
183 Int_t nSM = fGeometry->GetNumberOfSuperModules();
184
185 // Bad map
186 if(fRecoUtils->IsBadChannelsRemovalSwitchedOn())
187 {
188 AliOADBContainer *contBC=new AliOADBContainer("");
863e74f5 189 contBC->InitFromFile(Form("%s/EMCALBadChannels.root",fOADBFilePath.Data()),"AliEMCALBadChannels");
2b4e1cc5 190
191 TObjArray *arrayBC=(TObjArray*)contBC->GetObject(runnumber);
192
193 if(arrayBC)
863e74f5 194 {
2b4e1cc5 195 if(DebugLevel() > 0)
196 printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Remove EMCAL bad cells \n");
197
863e74f5 198 for (Int_t i=0; i<nSM; ++i)
2b4e1cc5 199 {
200 TH2I *hbm = fRecoUtils->GetEMCALChannelStatusMap(i);
201
202 if (hbm)
203 delete hbm;
204
205 hbm=(TH2I*)arrayBC->FindObject(Form("EMCALBadChannelMap_Mod%d",i));
206
863e74f5 207 if (!hbm)
2b4e1cc5 208 {
209 AliError(Form("Can not get EMCALBadChannelMap_Mod%d",i));
210 continue;
211 }
212
213 hbm->SetDirectory(0);
214 fRecoUtils->SetEMCALChannelStatusMap(i,hbm);
215
216 } // loop
217 } else if(DebugLevel() > 0)
218 printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Do NOT remove EMCAL bad channels\n"); // run array
219 } // Remove bad
66bdaa44 220
221 fOADBSet = kTRUE;
222
863e74f5 223}
2b4e1cc5 224
46fec84c 225//________________________________________________
226void AliAnalysisTaskEMCALTriggerQA::FillCellMaps()
227{
228 // Cells analysis
229 // Fill FEE energy per channel array
230 Int_t posX = -1, posY = -1;
231 Int_t nSupMod = -1, ieta = -1, iphi = -1, nModule = -1, nIphi = -1, nIeta = -1;
232 Short_t absId = -1;
233 Int_t nCells = 0;
234
235 AliVCaloCells& cells= *(InputEvent()->GetEMCALCells());
236
237 if(cells.IsEMCAL())
238 {
239 for (Int_t icell = 0; icell < cells.GetNumberOfCells(); icell++)
240 {
241 nCells ++;
242
243 Double_t amp =0., time = 0., efrac = 0;
244 Int_t mclabel = -1;
245
246 cells.GetCell(icell, absId, amp, time,mclabel,efrac);
247
248 fGeometry->GetCellIndex(absId, nSupMod, nModule, nIphi, nIeta);
249 fGeometry->GetCellPhiEtaIndexInSModule(nSupMod, nModule, nIphi, nIeta, iphi, ieta);
250
251 posX = (nSupMod % 2) ? ieta + AliEMCALGeoParams::fgkEMCALCols : ieta;
252 posY = iphi + AliEMCALGeoParams::fgkEMCALRows * int(nSupMod / 2);
253
73c5a035 254 Int_t indexX = Int_t(posX/2);
255 Int_t indexY = Int_t(posY/2);
256
257 if(indexX > fgkFALTROCols || indexY > fgkFALTRORows )
46fec84c 258 {
259 if(DebugLevel() > 0) printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Wrong Position (x,y) = (%d,%d)\n",posX,posY);
260 continue;
261 }
262
263 // here it is the amplitude for each cell
73c5a035 264 fMapCell[indexY][indexX] += amp;
46fec84c 265
266 if(fEventL1G)
267 {
73c5a035 268 fMapCellL1G[indexY][indexX] += amp;
269 //printf("L1G cell[%i,%i] amp=%f\n",indexY,indexX,fMapCellL1G[indexY][indexX]);
46fec84c 270 }
271
272 if(fEventL1G2)
273 {
73c5a035 274 fMapCellL1G2[indexY][indexX] += amp;
275 //printf("L1G2 cell[%i,%i] amp=%f\n",indexY,indexX,fMapCellL1G2[indexY][indexX]);
46fec84c 276 }
277
73c5a035 278 if(fEventL1J) fMapCellL1J [indexY][indexX] += amp;
279 if(fEventL1J2) fMapCellL1J2[indexY][indexX] += amp;
46fec84c 280
73c5a035 281 //printf("cell[%i,%i] amp=%f\n",indexY,indexX,fMapCell[indexY][indexX]);
46fec84c 282
283 }
284 }
285
286}
287
288//______________________________________________________________________________
289void AliAnalysisTaskEMCALTriggerQA::FillTriggerPatchMaps(TString triggerclasses)
290{
291 // Trigger analysis, fill L0, L1 arrays
292
293 AliVCaloTrigger& trg= * (InputEvent()->GetCaloTrigger("EMCAL"));
294
295 fV0Trigger = trg.GetL1V0(0)+trg.GetL1V0(1); // used elsewhere
296
297 Int_t posX = -1, posY = -1;
298
299 Int_t nL0Patch = 0 ;
300 //Int_t nL1Patch = 0 ;
301 fSTUTotal = 0;
302 fTRUTotal = 0;
303
304 trg.Reset();
305 // loop on FASTOR
306
307 while (trg.Next())
308 {
309 trg.GetPosition(posX,posY);
310
311 if (posX > -1 && posY > -1)
312 {
313 //L0 analysis
314 Int_t nTimes = 0;
315 trg.GetNL0Times(nTimes);
316 Int_t l0Times[10];
317 trg.GetL0Times(l0Times);
318
319 Float_t ampL0 = 0.;
320 trg.GetAmplitude(ampL0);
321 if (ampL0 > 0) fMapTrigL0[posY][posX] = ampL0;
322
323 if(triggerclasses.Contains("CEMC7EGA-B-NOPF-CENTNOTRD") || triggerclasses.Contains("CPBI2EGA") || triggerclasses.Contains("CPBI2EG1")) fMapTrigL0L1G[posY][posX] += ampL0;
324 if(triggerclasses.Contains("CEMC7EJE-B-NOPF-CENTNOTRD") || triggerclasses.Contains("CPBI2EJE") || triggerclasses.Contains("CPBI2EJ1")) fMapTrigL0L1J[posY][posX] += ampL0;
325 fTRUTotal += ampL0;
326
327 int l0fired = 0;
328 for (int itime = 0; itime < nTimes; itime++)
329 {
330 if (l0Times[itime] > 7 && l0Times[itime] < 10) l0fired = 1;
331 // time bin too open? restrict to time bin 8-9?
332 }
333
334 if (l0fired)
335 {
336 nL0Patch += nTimes;
337 fhL0Patch->Fill(posX,posY);
338 }
339
340 //L1 analysis
341 Int_t bit = 0;
342 trg.GetTriggerBits(bit);
343
344 Int_t ts = 0;
345 trg.GetL1TimeSum(ts);
346 if (ts > 0) fMapTrigL1[posY][posX] = ts;
347 fSTUTotal += ts;
348 // cout << "ts =" <<ts<<endl;
349
350 //L1
28da9717 351 Bool_t isEGA1 = ((bit >> fBitEGA ) & 0x1) && fEventL1G ;
352 Bool_t isEGA2 = ((bit >> (fBitEGA+1)) & 0x1) && fEventL1G2 ;
353 Bool_t isEJE1 = ((bit >> fBitEJE ) & 0x1) && fEventL1J ;
354 Bool_t isEJE2 = ((bit >> (fBitEJE+1)) & 0x1) && fEventL1J2 ;
46fec84c 355
356 //if(isEGA1 || isEGA2 || isEJE1 || isEJE2) nL1Patch++;
357 //if(isEJE1 || isEJE2) printf("Jet STU patch %d, time sum %d, posX %d , posY %d\n",nL1Patch,ts,posX, posY);
358
359 // L1-Gamma
360
361 if (isEGA1)
362 {
363 fhL1GPatch ->Fill(posX,posY);
364 if (ts > 0) fMapTrigL1G [posY][posX] = ts;
365 }
366
367 if (isEGA2)
368 {
369 fhL1G2Patch->Fill(posX,posY);
370 if (ts > 0) fMapTrigL1G2[posY][posX] = ts;
371 }
372
373 // L1-Jet
374 if (isEJE1)
375 {
376 fhL1JPatch ->Fill(posX,posY);
377 if (ts > 0) fMapTrigL1J [posY][posX] = ts;
378
379 }
380
381 if (isEJE2)
382 {
383 fhL1J2Patch->Fill(posX,posY);
384 if (ts > 0) fMapTrigL1J2[posY][posX] = ts;
385 }
386
387 }
388 }
389
390 if (!nL0Patch)
391 {
392 fEventL0 = kFALSE;
393 if (!triggerclasses.Contains("CPBI2")) fEventL1G = fEventL1G2 = fEventL1J = fEventL1J2 = kFALSE; // pp running
394 }
395
396 if(fTRUTotal > fMaxTRUSignal && DebugLevel() > 0) printf("AliAnalysisTaskEMCALTriggerQA::FillTriggerPatchMaps() - Large fTRUTotal %f\n",fTRUTotal);
397 if(fSTUTotal > fMaxSTUSignal && DebugLevel() > 0) printf("AliAnalysisTaskEMCALTriggerQA::FillTriggerPatchMaps() - Large fSTUTotal %d\n",fSTUTotal);
398
399}
400
401//___________________________________________________
402void AliAnalysisTaskEMCALTriggerQA::ClusterAnalysis()
403{
404 // Loop on clusters and fill corresponding histograms
405
406 //Get Vertex
407 Double_t v[3] = {0,0,0};
408 InputEvent()->GetPrimaryVertex()->GetXYZ(v);
409
410 //clusters distribution
411 TRefArray* caloClus = new TRefArray();
412 InputEvent()->GetEMCALClusters(caloClus);
413
414 Int_t nCaloClusters = caloClus->GetEntriesFast();
415
416 Float_t emax = 0;
417 Float_t etamax = 0;
418 Float_t phimax = 0;
419 Float_t ietamax=-1;
420 Float_t iphimax=-1;
421
422 Float_t e = 0;
423 Float_t eta = 0;
424 Float_t phi = 0;
425
426 Int_t nSupMod = -1, ieta = -1, iphi = -1;
427
428 TLorentzVector mom;
429
430 //Get vertex for momentum calculation
431 Double_t vertex[] = {0.0,0.0,0.0};
432 //InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
433
434 Float_t centrality = -1;
435 if(InputEvent()->GetCentrality()) centrality = InputEvent()->GetCentrality()->GetCentralityPercentile("V0M");
436
437 for(Int_t icalo = 0; icalo < nCaloClusters; icalo++)
438 {
439 AliVCluster *clus = (AliVCluster*) (caloClus->At(icalo));
440
441 if(!clus->IsEMCAL()) continue;
442
443 if(!fRecoUtils->IsGoodCluster(clus,fGeometry,InputEvent()->GetEMCALCells(),InputEvent()->GetBunchCrossNumber()))
444 continue;
445
446 if(clus->GetNCells() < 2) continue ; // Avoid 1 cell clusters, noisy, exotic.
447
448 clus->GetMomentum(mom, vertex);
449
450 Bool_t shared = kFALSE;
451 Int_t idAbs = -1, iphi0 = -1, ieta0 = -1;
452 fRecoUtils->GetMaxEnergyCell(fGeometry, InputEvent()->GetEMCALCells(),clus,
453 idAbs,nSupMod,ieta0,iphi0,shared);
454 //Change index to be continuous over SM
455 ieta = (nSupMod % 2) ? ieta0 + AliEMCALGeoParams::fgkEMCALCols : ieta0;
456 iphi = iphi0 + AliEMCALGeoParams::fgkEMCALRows * int(nSupMod / 2);
457 ieta/=2;
458 iphi/=2;
459
460 if(ieta > fgkFALTROCols || iphi > fgkFALTRORows )
461 printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Wrong Position (x,y) = (%d,%d)\n",ieta,iphi);
462
463 e = clus->E();
464 eta = mom.Eta();
465 phi = mom.Phi();
466
467 if(e > emax)
468 {
469 emax = e;
470 etamax = eta;
471 phimax = phi;
472 ietamax = ieta;
473 iphimax = iphi;
474 }
475
476 // Fill cluster histograms depending on the event trigger selection
477 if( fEventMB ) FillClusterHistograms(kMBTrig ,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
478 if( fEventCen ) FillClusterHistograms(kCentralTrig ,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
479 if( fEventSem ) FillClusterHistograms(kSemiCentralTrig,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
480
481 if( fEventL0 ) FillClusterHistograms(kL0Trig ,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
482 if( fEventL1G ) FillClusterHistograms(kL1GammaTrig ,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
483 if( fEventL1G2) FillClusterHistograms(kL1GammaTrig2 ,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
484 if( fEventL1J ) FillClusterHistograms(kL1JetTrig ,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
485 if( fEventL1J2) FillClusterHistograms(kL1JetTrig2 ,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
4c0129b7 486
487 if( fEventL1G2 && !fEventL1G) FillClusterHistograms(kL1Gamma2OnlyGammaTrig,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
488 if( fEventL1J2 && !fEventL1J) FillClusterHistograms(kL1Jet2OnlyJetTrig ,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
489
46fec84c 490 if( fEventL1G && !fEventL1J )
491 FillClusterHistograms (kL1GammaOnlyTrig,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
492 if( fEventL1J && !fEventL1G )
493 FillClusterHistograms (kL1JetOnlyTrig ,kFALSE,e,eta,phi,ieta,iphi,centrality,fV0A+fV0C);
494
495 if( fEventMB && !fEventL1G && !fEventL1J && !fEventL0 ) fhClusMBPure[0] ->Fill(e);
496 if( fEventCen && !fEventL1G && !fEventL1J && !fEventL0 ) fhClusMBPure[1] ->Fill(e);
497 if( fEventSem && !fEventL1G && !fEventL1J && !fEventL0 ) fhClusMBPure[2] ->Fill(e);
498
499 }
500
501 // Maximum energy cluster per event histograms
502
503 if( fEventMB ) FillClusterHistograms(kMBTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
504 if( fEventCen ) FillClusterHistograms(kCentralTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
505 if( fEventSem ) FillClusterHistograms(kSemiCentralTrig,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
506
507 if( fEventL0 ) FillClusterHistograms(kL0Trig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
508 if( fEventL1G ) FillClusterHistograms(kL1GammaTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
509 if( fEventL1G2) FillClusterHistograms(kL1GammaTrig2 ,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
510 if( fEventL1J ) FillClusterHistograms(kL1JetTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
511 if( fEventL1J2) FillClusterHistograms(kL1JetTrig2 ,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
4c0129b7 512
513 if( fEventL1G2 && !fEventL1G) FillClusterHistograms(kL1Gamma2OnlyGammaTrig,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
514 if( fEventL1J2 && !fEventL1J) FillClusterHistograms(kL1Jet2OnlyJetTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
515
46fec84c 516 if( fEventL1G && !fEventL1J )
517 FillClusterHistograms (kL1GammaOnlyTrig,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
518 if( fEventL1J && !fEventL1G )
519 FillClusterHistograms (kL1JetOnlyTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,centrality,fV0A+fV0C);
520
521 if( fEventMB && !fEventL1G && !fEventL1J && !fEventL0 ) fhClusMaxMBPure[0] ->Fill(emax);
522 if( fEventCen && !fEventL1G && !fEventL1J && !fEventL0 ) fhClusMaxMBPure[1] ->Fill(emax);
523 if( fEventSem && !fEventL1G && !fEventL1J && !fEventL0 ) fhClusMaxMBPure[2] ->Fill(emax);
524
525}
526
527//______________________________________________________________________________________________
69aa892c 528void AliAnalysisTaskEMCALTriggerQA::FillClusterHistograms(Int_t triggerNumber, Bool_t max,
529 Float_t e, Float_t eta, Float_t phi,
530 Float_t ieta, Float_t iphi,
46fec84c 531 Float_t centrality, Float_t fV0AC)
31a3f95a 532{
cf170170 533 //Fill normal cluster related histograms depending on the trigger type selection
534 // (10 options, MB, L0, L1 Gamma ... defined in enum triggerType)
863e74f5 535
31a3f95a 536 if(!max)
537 {
cf170170 538 fhClus [triggerNumber]->Fill(e);
539 fhClusCen[triggerNumber]->Fill(e,centrality);
46fec84c 540 fhClusV0 [triggerNumber]->Fill(e,fV0AC);
cf170170 541 fhClusEta[triggerNumber]->Fill(e,eta);
542 fhClusPhi[triggerNumber]->Fill(e,phi);
863e74f5 543
544 if(e > fEtaPhiEnMin)
31a3f95a 545 {
cf170170 546 fhClusEtaPhiHigh [triggerNumber]->Fill( eta, phi);
547 fhClusEtaPhiHighCellMax[triggerNumber]->Fill(ieta,iphi);
31a3f95a 548 }
863e74f5 549 else
550 {
cf170170 551 fhClusEtaPhiLow [triggerNumber]->Fill( eta, phi);
552 fhClusEtaPhiLowCellMax[triggerNumber]->Fill(ieta,iphi);
31a3f95a 553 }
554 }
555 else
556 {
cf170170 557 fhClusMax [triggerNumber]->Fill(e);
558 fhClusCenMax[triggerNumber]->Fill(e,centrality);
46fec84c 559 fhClusV0Max [triggerNumber]->Fill(e,fV0AC);
cf170170 560 fhClusEtaMax[triggerNumber]->Fill(e,eta);
561 fhClusPhiMax[triggerNumber]->Fill(e,phi);
863e74f5 562
563 if(e > fEtaPhiEnMin)
31a3f95a 564 {
cf170170 565 fhClusEtaPhiHighCluMax [triggerNumber]->Fill( eta, phi);
566 fhClusEtaPhiHighCellMaxCluMax[triggerNumber]->Fill(ieta,iphi);
31a3f95a 567 }
863e74f5 568 else
569 {
cf170170 570 fhClusEtaPhiLowCluMax [triggerNumber]->Fill( eta, phi);
571 fhClusEtaPhiLowCellMaxCluMax[triggerNumber]->Fill(ieta,iphi);
31a3f95a 572 }
573 }
574}
575
46fec84c 576//_____________________________________________________________
577void AliAnalysisTaskEMCALTriggerQA::FillCorrelationHistograms()
2b4e1cc5 578{
46fec84c 579 //FEE-TRU-STU correlation checks
580
581 Double_t ampFOR[30] = {0.}, ampL0[30] = {0.}, ampL1[30] = {0.};
582 for (Int_t i = 0; i < fgkFALTRORows; i++)
583 {
584 for (Int_t j = 0; j < fgkFALTROCols; j++)
585 {
586 //method to get TRU number
587 Int_t idFOR = -1;
588 fGeometry->GetAbsFastORIndexFromPositionInEMCAL(j,i,idFOR);
589 Int_t iTRU = -1;
590 Int_t iADC = -1;
591 fGeometry->GetTRUFromAbsFastORIndex(idFOR,iTRU,iADC);
592
593 //printf("i %d, j %d, iTRU %d, iADC %d, idFOR %d; cell %f, L0 %f, L1 %f\n",
594 // i,j,iTRU,iADC,idFOR, fMapCell [i][j],fMapTrigL0[i][j],fMapTrigL1[i][j]);
595
596 if (iTRU >= 0)
597 {
598 ampFOR[iTRU] += fMapCell [i][j];
599 ampL0[iTRU] += fMapTrigL0[i][j];
600 ampL1[iTRU] += fMapTrigL1[i][j];
601 }
602 }
603 }
863e74f5 604
46fec84c 605 // FEE vs STU and TRU vs STU ratios
606 for (Int_t i = 0; i < 30; i++)
2b4e1cc5 607 {
46fec84c 608 if (ampFOR[i] != 0 && ampL1[i] != 0)
609 {
610 fhFEESTU->Fill(ampL1[i]/ampFOR[i],i);
611 if(ampL1[i]/ampFOR[i] > fMaxSTUFEERatio && DebugLevel() > 0 ) printf("AliAnalysisTaskEMCALTriggerQA::FillCorrelationHistograms() - Large STU/FEE ratio %f\n",ampL1[i]/ampFOR[i]);
612 }
613
614 if (ampL0[i] != 0 && ampL1[i] != 0)
615 {
616 fhTRUSTU->Fill(ampL1[i]/ampL0[i] ,i);
617 if(ampL1[i]/ampL0[i] > fMaxSTUTRURatio && DebugLevel() > 0 ) printf("AliAnalysisTaskEMCALTriggerQA::FillCorrelationHistograms() - Large STU/TRU ratio %f\n",ampL1[i]/ampL0[i]);
618 }
2b4e1cc5 619 }
863e74f5 620}
2b4e1cc5 621
46fec84c 622//_____________________________________________________________
623void AliAnalysisTaskEMCALTriggerQA::FillEventCounterHistogram()
2b4e1cc5 624{
46fec84c 625 // Fill a TH1 histogram, each bin corresponds to a even trigger type
626
627 fhNEvents->Fill(0.5); // All physics events
628
629 if( fEventMB )
630 {
631 fhNEvents->Fill(1.5);
632 if( !fEventL1G && !fEventL1J && !fEventL1G2 && !fEventL1J2 && !fEventL0 ) fhNEvents->Fill(12.5);
633 }
634 else
635 {
636 if( fEventL0 ) fhNEvents->Fill(13.5);
637 if( fEventL1G ) fhNEvents->Fill(14.5);
638 if( fEventL1J ) fhNEvents->Fill(15.5);
639 }
640
641 if( fEventCen) fhNEvents->Fill(2.5);
642 if( fEventSem) fhNEvents->Fill(3.5);
643
644 if( fEventL0 )
645 {
646 fhNEvents->Fill(4.5);
647 }
648
649 if( fEventL1G )
650 {
651 fhNEvents->Fill(5.5);
652 if(!fEventL1J) fhNEvents->Fill(9.5);
653 if(fEventCen || fEventSem) fhNEvents->Fill(16.5);
654 }
655
4c0129b7 656 if( fEventL1G2 )
657 {
658 fhNEvents->Fill(6.5);
659 if( !fEventL1G ) fhNEvents->Fill(18.5);
660
661 }
46fec84c 662
663 if( fEventL1J )
664 {
665 fhNEvents->Fill(7.5);
666 if(!fEventL1G) fhNEvents->Fill(10.5);
667 if(fEventCen || fEventSem) fhNEvents->Fill(17.5);
668 }
669
4c0129b7 670 if( fEventL1J2 )
671 {
672 fhNEvents->Fill(8.5);
673 if( !fEventL1J ) fhNEvents->Fill(19.5);
674 }
675
46fec84c 676 if(fEventL1J && fEventL1G) fhNEvents->Fill(11.5);
677
678}
679
680//______________________________________________________________
681void AliAnalysisTaskEMCALTriggerQA::FillL1GammaPatchHistograms()
682{
683 // L1 Gamma
684
685 // Study fakes - Make it more understandable!!!
686
73c5a035 687 Int_t areAllFakes = 2;
688 Int_t numberpatchNotFake = 0;
689 Int_t numberpatchFake = 0;
46fec84c 690
73c5a035 691 Int_t threshold = 10;// 10 GeV !it's not GeV it's ADC !!
692 Bool_t enoughE = kFALSE;
693 Double_t patchMax = 0;
694 Int_t colMax = -1;
695 Int_t rowMax = -1;
696 Int_t shiftCol = -1;
697 Int_t shiftRow = -1;
46fec84c 698
699 // loop on patchs
73c5a035 700 for (Int_t posx = 0; posx < fgkFALTROCols; posx++)
46fec84c 701 {
73c5a035 702 for (Int_t posy = 0; posy < fgkFALTRORows; posy++)
46fec84c 703 {
73c5a035 704 Double_t patchEnergy = 0;
46fec84c 705
73c5a035 706 if(fMapTrigL1G[posy][posx] > 0)
46fec84c 707 {
73c5a035 708 for(Int_t irow = 0; irow < 2; irow++)
46fec84c 709 {
73c5a035 710 for(Int_t icol = 0; icol < 2; icol++)
711 {
712 // loop on cells
713 shiftCol = posx+icol;
714 shiftRow = posy+irow;
715
716 // printf("cell[%i,%i]=%f\n",posy+icol,posx+irow, fMapCellL1G[posy+icol][posx+irow]);
717 if(shiftRow < fgkFALTRORows && shiftCol < fgkFALTROCols)
718 patchEnergy += fMapCellL1G[shiftRow][shiftCol] ;
719
720 if( fMapCellL1G[shiftRow][shiftCol] >threshold/2) enoughE = kTRUE;
721 }
46fec84c 722 }
723
724 if (patchEnergy > patchMax)
725 {
726 patchMax = patchEnergy;
727 colMax = posx;
728 rowMax = posy;
729 }
730
731 if(patchEnergy>threshold || (patchEnergy>threshold-3 && enoughE))
732 {
733 numberpatchNotFake++;
734 fhL1GPatchNotFake ->Fill(posx,posy);
735 fhL1GPatchNotFakeE->Fill(patchEnergy);
73c5a035 736 areAllFakes = 1;
46fec84c 737 }
738 else
739 {
740 numberpatchFake++;
73c5a035 741 areAllFakes = 0;
742 fhL1GPatchFake ->Fill(posx,posy);
46fec84c 743 fhL1GPatchFakeE->Fill(patchEnergy);
744 }
745 }
746 }
747 }
748
749 fhNPatchNotFake->Fill(areAllFakes,numberpatchNotFake);
750 fhNPatchFake ->Fill(areAllFakes,numberpatchFake);
751
73c5a035 752 if(areAllFakes == 0)
46fec84c 753 {
754 // loop on patchs
73c5a035 755 for (Int_t col = 0; col < fgkFALTROCols; col++)
46fec84c 756 {
73c5a035 757 for (Int_t row = 0; row < fgkFALTRORows; row++)
46fec84c 758 {
73c5a035 759 if(fMapTrigL1G[row][col] > 0)
46fec84c 760 {
761 // cout <<"checking fMapTrigL1G[row][col]"<<fMapTrigL1G[row][col]<<endl;
762 fhL1GPatchAllFake->Fill(col,row);
763
73c5a035 764 Double_t patchEnergy=0;
765 for(Int_t irow = 0; irow < 2; irow++)
766 {
767 for(Int_t icol = 0; icol < 2; icol++)
768 {
769 shiftCol = col+icol;
770 shiftRow = row+irow;
771
772 if(shiftRow < fgkFALTRORows && shiftCol < fgkFALTROCols)
773 patchEnergy += fMapCellL1G[shiftRow][shiftCol] ;
774
775 }
776 }
46fec84c 777 fhL1GPatchAllFakeE->Fill(patchEnergy);
778 }
779 }
780 }
781 // cout << "row max"<<rowMax<<" colmax"<<colMax<< " fMapTrigL1G[rowMax][colMax]"<< fMapTrigL1G[rowMax][colMax]<<endl;
782
73c5a035 783 if(fMapTrigL1G[rowMax][colMax] > 0)
46fec84c 784 {
785 // printf("\npatch max [%i,%i] = %f\n",rowMax,colMax,patchMax);
786 fhL1GPatchAllFakeMax ->Fill(colMax,rowMax);
787 fhL1GPatchAllFakeMaxE->Fill(patchMax);
788 }
789 }
790 else
791 {
792 // loop on patches
73c5a035 793 for (Int_t col = 0; col < fgkFALTROCols; col++)
46fec84c 794 {
73c5a035 795 for (Int_t row = 0; row < fgkFALTRORows; row++)
46fec84c 796 {
73c5a035 797 if(fMapTrigL1G[row][col] > 0)
46fec84c 798 {
73c5a035 799 fhL1GPatchNotAllFake->Fill(col,row);
800
801 Double_t patchEnergy = 0;
802 for(Int_t irow = 0; irow < 2; irow++)
803 {
804 for(Int_t icol = 0; icol < 2; icol++)
805 {
806 shiftCol = col+icol;
807 shiftRow = row+irow;
808
809 if(shiftRow < fgkFALTRORows && shiftCol < fgkFALTROCols)
810 patchEnergy += fMapCellL1G[shiftRow][shiftCol] ;
811 }
812 }
813
814 fhL1GPatchNotAllFakeE->Fill(patchEnergy);
815
46fec84c 816 }
46fec84c 817 }
818 }
819
73c5a035 820 if(fMapTrigL1G[rowMax][colMax] > 0 )
46fec84c 821 {
822 fhL1GPatchNotAllFakeMax ->Fill(colMax,rowMax);
823 fhL1GPatchNotAllFakeMaxE->Fill(patchMax);
824 }
825 }
826
827 fhGPMaxVV0TT->Fill(fV0Trigger, patchMax);
73c5a035 828 if( fEventL1G ) fhL1GPatchMax ->Fill(colMax,rowMax);
829 if( fEventL1G2 ) fhL1G2PatchMax->Fill(colMax,rowMax);
46fec84c 830
831}
832
833//____________________________________________________________
834void AliAnalysisTaskEMCALTriggerQA::FillL1JetPatchHistograms()
835{
836 // L1 Jet
837
73c5a035 838 Double_t patchMax = 0;
839 Int_t colMax = -1;
840 Int_t rowMax = -1;
841 Int_t col, row = 0;
842
46fec84c 843 for (Int_t i = 0; i < 9; i++)
844 {
845 for (Int_t j = 0; j < 12; j++)
846 {
847 Int_t patchJ = 0;
848 col = i;
849 row = j;
850
851 for (Int_t k = 0; k < 16; k++)
852 {
853 for (Int_t l = 0; l < 16; l++)
854 {
855 patchJ += Int_t(fMapTrigL1[4*j + l][4*i + k]);
856 }
857 }
858
859 if (patchJ > patchMax)
860 {
861 patchMax = patchJ;
862 colMax = 4*col;
863 rowMax = 4*row;
864 }
865 }
866 }
867
868 fhJPMaxVV0TT->Fill(fV0Trigger, patchMax);
73c5a035 869 if( fEventL1J ) fhL1JPatchMax ->Fill(colMax,rowMax);
870 if( fEventL1J2 ) fhL1J2PatchMax->Fill(colMax,rowMax);
46fec84c 871
872}
873
874//______________________________________________________
875void AliAnalysisTaskEMCALTriggerQA::FillMapHistograms()
876{
877 //Matrix with signal per channel
878
879 for (Int_t i = 0; i < fgkFALTRORows; i++)
880 {
881 for (Int_t j = 0; j < fgkFALTROCols; j++) //check x,y direction for reading FOR ((0,0) = top left);
882 {
883 fhFORAmp ->Fill( j, i, fMapCell [i][j]);
884 fhFORAmpL1G ->Fill( j, i, fMapCellL1G [i][j]);
885 fhFORAmpL1G2->Fill( j, i, fMapCellL1G2 [i][j]);
886 fhFORAmpL1J ->Fill( j, i, fMapCellL1J [i][j]);
887 fhFORAmpL1J2->Fill( j, i, fMapCellL1J2 [i][j]);
888 fhL0Amp ->Fill( j, i, fMapTrigL0 [i][j]);
889 fhL0AmpL1G ->Fill( j, i, fMapTrigL0L1G[i][j]);
890 fhL0AmpL1J ->Fill( j, i, fMapTrigL0L1J[i][j]);
891 fhL1Amp ->Fill( j, i, fMapTrigL1 [i][j]);
892
893 fhL1FOREnergy->Fill(i+fgkFALTRORows*j, fMapTrigL1 [i][j]);
894 fhL1GAmp ->Fill( j, i, fMapTrigL1G [i][j]);
895 fhL1G2Amp ->Fill( j, i, fMapTrigL1G2 [i][j]);
896 fhL1JAmp ->Fill( j, i, fMapTrigL1J [i][j]);
897 fhL1J2Amp ->Fill( j, i, fMapTrigL1J2 [i][j]);
898 fhFORMeanAmp->Fill( j, i, fMapCell [i][j]);
899 fhL0MeanAmp ->Fill( j, i, fMapTrigL0 [i][j]);
900 fhL1MeanAmp ->Fill( j, i, fMapTrigL1 [i][j]);
901 }
902 }
903}
904
905//____________________________________________________
906void AliAnalysisTaskEMCALTriggerQA::FillV0Histograms()
907{
908 //V0 analysis, only for ESDs
909
910 AliESDVZERO* eventV0 = dynamic_cast<AliESDVZERO*> (InputEvent()->GetVZEROData());
911
912 if(eventV0)
913 {
914 for (Int_t i = 0; i < 32; i++)
915 {
916 fV0C += eventV0->GetAdcV0C(i);
917 fV0A += eventV0->GetAdcV0A(i);
918 }
919
920 if (fSTUTotal != 0)
921 {
922 fhV0STU->Fill(fV0A+fV0C,fSTUTotal);
923 if( fV0A+fV0C > fMaxV0Signal && DebugLevel() > 0) printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large fV0A+fV0C %f\n",fV0A+fV0C);
924 }
925
926 if( fEventL1G ) fhV0[kL1GammaTrig] ->Fill(fV0A+fV0C);
927 if( fEventL1G2 ) fhV0[kL1GammaTrig2] ->Fill(fV0A+fV0C);
928 if( fEventL1J ) fhV0[kL1JetTrig] ->Fill(fV0A+fV0C);
929 if( fEventL1J2 ) fhV0[kL1JetTrig2] ->Fill(fV0A+fV0C);
930 if( fEventMB ) fhV0[kMBTrig] ->Fill(fV0A+fV0C);
931 if( fEventL0 ) fhV0[kL0Trig] ->Fill(fV0A+fV0C);
932 if( fEventCen ) fhV0[kCentralTrig] ->Fill(fV0A+fV0C);
933 if( fEventSem ) fhV0[kSemiCentralTrig]->Fill(fV0A+fV0C);
4c0129b7 934 if( fEventL1G && !fEventL1J) fhV0[kL1GammaOnlyTrig] ->Fill(fV0A+fV0C);
935 if( fEventL1J && !fEventL1G) fhV0[kL1JetOnlyTrig] ->Fill(fV0A+fV0C);
936 if( fEventL1G2 && !fEventL1G) fhV0[kL1Gamma2OnlyGammaTrig]->Fill(fV0A+fV0C);
937 if( fEventL1J2 && !fEventL1J) fhV0[kL1Jet2OnlyJetTrig] ->Fill(fV0A+fV0C);
46fec84c 938 //if(nL0Patch!=0 || nL1Patch!=0) printf("total TRU %f, total STU %f, V0C+V0A %f; nL0 %d, nL1 %d \n",
939 // fTRUTotal,fSTUTotal,fV0A+fV0C,nL0Patch,nL1Patch);
940 }
941}
942
943//________________________________________
944void AliAnalysisTaskEMCALTriggerQA::Init()
945{
946 //Init analysis parameters not set before
947
948 if(!fRecoUtils)
949 {
950 fRecoUtils = new AliEMCALRecoUtils ;
951 fRecoUtils->SwitchOnBadChannelsRemoval();
952 }
953
954}
955
956//_____________________________________________________
957void AliAnalysisTaskEMCALTriggerQA::InitCellPatchMaps()
958{
959 //Init to 0 and per event different cell/patch maps, depending on trigger type
960
961 for (Int_t i = 0; i < fgkFALTRORows; i++)
962 {
963 for (Int_t j = 0; j < fgkFALTROCols; j++)
964 {
965 fMapTrigL0 [i][j] = 0.;
966 fMapTrigL0L1G[i][j] = 0.;
967 fMapTrigL0L1J[i][j] = 0.;
968 fMapTrigL1G [i][j] = 0.;
969 fMapTrigL1G2 [i][j] = 0.;
970 fMapTrigL1J [i][j] = 0.;
971 fMapTrigL1J2 [i][j] = 0.;
972 fMapTrigL1 [i][j] = 0.;
973 fMapCell [i][j] = 0.;
974 fMapCellL1G [i][j] = 0.;
975 fMapCellL1G2 [i][j] = 0.;
976 fMapCellL1J [i][j] = 0.;
977 fMapCellL1J2 [i][j] = 0.;
978 }
979 }
980}
981
982//________________________________________________
983void AliAnalysisTaskEMCALTriggerQA::InitGeometry()
984{
985 // Init geometry and set the geometry matrix, for the first event, skip the rest
986 // Also set once the run dependent calibrations
2b4e1cc5 987
988 if(fGeoSet) return;
989
31a3f95a 990 // Init the trigger bit once, correct depending on version
863e74f5 991 fBitEGA = 4;
992 fBitEJE = 5;
31a3f95a 993
994 TFile* file = AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile();
863e74f5 995
31a3f95a 996 const TList *clist = file->GetStreamerInfoCache();
997
998 if(clist)
863e74f5 999 {
31a3f95a 1000 TStreamerInfo *cinfo = (TStreamerInfo*)clist->FindObject("AliESDCaloTrigger");
cf170170 1001 Int_t verid = 5; // newer ESD header version
1002 if(!cinfo)
1003 {
1004 cinfo = (TStreamerInfo*)clist->FindObject("AliAODCaloTrigger");
1005 verid = 2; // newer AOD header version
1006 }
863e74f5 1007 if(cinfo)
31a3f95a 1008 {
1009 Int_t classversionid = cinfo->GetClassVersion();
cf170170 1010 //printf("********* Header class version %d *********** \n",classversionid);
31a3f95a 1011
cf170170 1012 if (classversionid >= verid)
31a3f95a 1013 {
1014 fBitEGA = 6;
1015 fBitEJE = 8;
1016 }
1017 } else printf("AliAnalysisTaskEMCALTriggerQA - Streamer info for trigger class not available, bit not changed\n");
1018 } else printf("AliAnalysisTaskEMCALTriggerQA - Streamer list not available!, bit not changed\n");
1019
2b4e1cc5 1020 Int_t runnumber = InputEvent()->GetRunNumber() ;
1021
1022 if (!fGeometry)
1023 {
1024 if(fGeoName=="")
1025 {
1026 if (runnumber < 140000) fGeoName = "EMCAL_FIRSTYEARV1";
1027 else if(runnumber < 171000) fGeoName = "EMCAL_COMPLETEV1";
863e74f5 1028 else fGeoName = "EMCAL_COMPLETE12SMV1";
2b4e1cc5 1029 if(DebugLevel() > 0)
1030 printf("AliAnalysisTaskEMCALTriggerQA::InitGeometry() - Set EMCAL geometry name to <%s> for run %d\n",fGeoName.Data(),runnumber);
1031 }
1032
863e74f5 1033 fGeometry = AliEMCALGeometry::GetInstance(fGeoName);
1034 }
bce9493b 1035
66bdaa44 1036 fGeoSet = kTRUE;
863e74f5 1037
bce9493b 1038}
1039
31a3f95a 1040//_______________________________________________________
1041void AliAnalysisTaskEMCALTriggerQA::InitHistogramArrays()
1042{
31a3f95a 1043 //Histograms array initialization
1044
4c0129b7 1045 for (Int_t i = 0; i < fgkTriggerCombi; i++)
863e74f5 1046 {
cf170170 1047 fhV0 [i] = 0;
1048 fhClus [i] = 0; fhClusMax [i] = 0;
1049 fhClusCen[i] = 0; fhClusCenMax[i] = 0;
1050 fhClusV0 [i] = 0; fhClusV0Max [i] = 0;
1051 fhClusEta[i] = 0; fhClusEtaMax[i] = 0;
1052 fhClusPhi[i] = 0; fhClusPhiMax[i] = 0;
1053
1054 fhClusEtaPhiHigh [i] = 0; fhClusEtaPhiHighCluMax [i] = 0;
1055 fhClusEtaPhiHighCellMax[i] = 0; fhClusEtaPhiHighCellMaxCluMax[i] = 0;
1056 fhClusEtaPhiLow [i] = 0; fhClusEtaPhiLowCluMax [i] = 0;
1057 fhClusEtaPhiLowCellMax [i] = 0; fhClusEtaPhiLowCellMaxCluMax [i] = 0;
1058
1059 if(i<3){ fhClusMBPure[i] = 0; fhClusMaxMBPure[i] = 0; }
31a3f95a 1060 }
31a3f95a 1061}
1062
46fec84c 1063//_____________________________________________________________________________
1064void AliAnalysisTaskEMCALTriggerQA::SetTriggerEventBit( TString triggerclasses)
1065{
1066 // Check what trigger is the event, set the corresponding bit
1067
1068 // Init trigger event bit
1069 fEventMB = kFALSE;
1070 fEventL0 = kFALSE;
1071 fEventL1G = kFALSE;
1072 fEventL1G2 = kFALSE;
1073 fEventL1J = kFALSE;
1074 fEventL1J2 = kFALSE;
1075 fEventCen = kFALSE;
1076 fEventSem = kFALSE;
1077
1078 //Min bias event trigger?
1079 if((triggerclasses.Contains("CINT") || triggerclasses.Contains("CPBI2_B1") ) &&
1080 (triggerclasses.Contains("-B-") || triggerclasses.Contains("-I-")) &&
1081 triggerclasses.Contains("-NOPF-ALLNOTRD") ) fEventMB = kTRUE;
1082
1083 // EMC triggered event? Which type?
1084 if( triggerclasses.Contains("-B-") || triggerclasses.Contains("-S-") || triggerclasses.Contains("-I-") )
1085 {
1086 if( triggerclasses.Contains("CEMC") &&
1087 !triggerclasses.Contains("EGA" ) &&
1088 !triggerclasses.Contains("EJE" ) &&
1089 !triggerclasses.Contains("EG1" ) &&
1090 !triggerclasses.Contains("EJ1" ) &&
1091 !triggerclasses.Contains("EG2" ) &&
1092 !triggerclasses.Contains("EJ2" ) ) fEventL0 = kTRUE;
1093
1094 if( triggerclasses.Contains("EGA" ) || triggerclasses.Contains("EG1" ) ) fEventL1G = kTRUE;
1095 if( triggerclasses.Contains("EG2" ) ) fEventL1G2 = kTRUE;
1096
1097 if( triggerclasses.Contains("EJE" ) || triggerclasses.Contains("EJ1" ) ) fEventL1J = kTRUE;
1098 if( triggerclasses.Contains("EJ2" ) ) fEventL1J2 = kTRUE;
1099 }
1100
1101 // Semi/Central PbPb trigger
1102 if (triggerclasses.Contains("CCENT_R2-B-NOPF-ALLNOTRD")) fEventCen = kTRUE;
1103 else if(triggerclasses.Contains("CSEMI_R1-B-NOPF-ALLNOTRD")) fEventSem = kTRUE;
1104
1105 // printf("MB : %d; L0 : %d; L1-Gam : %d; L1-Jet : %d; Central : %d; SemiCentral : %d; Trigger Names : %s \n ",
1106 // fEventMB,fEventL0,fEventL1G,fEventL1J,fEventCen,fEventSem,triggerclasses.Data());
1107
1108}
1109
85196c29 1110//___________________________________________________________
863e74f5 1111void AliAnalysisTaskEMCALTriggerQA::UserCreateOutputObjects()
bce9493b 1112{
863e74f5 1113 // Init histograms and geometry
31a3f95a 1114
85196c29 1115 fOutputList = new TList;
1116 fOutputList ->SetOwner(kTRUE);
bce9493b 1117
4c0129b7 1118 fhNEvents = new TH1F("hNEvents","Number of selected events",20,0,20);
85196c29 1119 fhNEvents ->SetYTitle("N events");
77626b4a 1120 fhNEvents ->GetXaxis()->SetBinLabel(1 ,"All");
0d896539 1121 fhNEvents ->GetXaxis()->SetBinLabel(2 ,"MB");
31a3f95a 1122 fhNEvents ->GetXaxis()->SetBinLabel(3 ,"Central Pb");
1123 fhNEvents ->GetXaxis()->SetBinLabel(4 ,"SemiCentral Pb");
1124 fhNEvents ->GetXaxis()->SetBinLabel(5 ,"L0");
4c0129b7 1125 fhNEvents ->GetXaxis()->SetBinLabel(6 ,"L1-G1");
6be2314f 1126 fhNEvents ->GetXaxis()->SetBinLabel(7 ,"L1-G2");
4c0129b7 1127 fhNEvents ->GetXaxis()->SetBinLabel(8 ,"L1-J1");
6be2314f 1128 fhNEvents ->GetXaxis()->SetBinLabel(9 ,"L1-J2");
4c0129b7 1129 fhNEvents ->GetXaxis()->SetBinLabel(10 ,"L1-G1 & !L1-J1");
1130 fhNEvents ->GetXaxis()->SetBinLabel(11 ,"L1-J1 & !L1-G1");
1131 fhNEvents ->GetXaxis()->SetBinLabel(12 ,"L1-J1 & L1-G1");
6be2314f 1132 fhNEvents ->GetXaxis()->SetBinLabel(13 ,"MB & !L1 & !L0");
1133 fhNEvents ->GetXaxis()->SetBinLabel(14,"L0 & !MB");
4c0129b7 1134 fhNEvents ->GetXaxis()->SetBinLabel(15,"L1-G1 & !MB");
1135 fhNEvents ->GetXaxis()->SetBinLabel(16,"L1-J1 & !MB");
1136 fhNEvents ->GetXaxis()->SetBinLabel(17,"L1-G1 & (Cen | Semi)");
1137 fhNEvents ->GetXaxis()->SetBinLabel(18,"L1-J1 & (Cen | Semi)");
1138 fhNEvents ->GetXaxis()->SetBinLabel(19,"L1-G2 & !L1-G1");
1139 fhNEvents ->GetXaxis()->SetBinLabel(20,"L1-J2 & !L1-J1");
1140
75e10d6a 1141 fhFORAmp = new TH2F("hFORAmp", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column",
1142 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1143 fhFORAmp ->SetXTitle("Index #eta (columnns)");
e022364d 1144 fhFORAmp ->SetYTitle("Index #phi (rows)");
1145 fhFORAmp ->SetZTitle("Amplitude");
e395081d 1146
75e10d6a 1147 fhFORAmpL1G = new TH2F("hFORAmpL1G", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1G trigger condition",
1148 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1149 fhFORAmpL1G ->SetXTitle("Index #eta (columnns)");
a40222c8 1150 fhFORAmpL1G ->SetYTitle("Index #phi (rows)");
1151 fhFORAmpL1G ->SetZTitle("Amplitude");
863e74f5 1152
6be2314f 1153 fhFORAmpL1G2 = new TH2F("hFORAmpL1G2", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1G2 trigger condition",
cf170170 1154 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1155 fhFORAmpL1G2 ->SetXTitle("Index #eta (columnns)");
1156 fhFORAmpL1G2 ->SetYTitle("Index #phi (rows)");
1157 fhFORAmpL1G2 ->SetZTitle("Amplitude");
e395081d 1158
75e10d6a 1159 fhFORAmpL1J = new TH2F("hFORAmpL1J", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1J trigger condition",
1160 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1161 fhFORAmpL1J ->SetXTitle("Index #eta (columnns)");
a40222c8 1162 fhFORAmpL1J ->SetYTitle("Index #phi (rows)");
1163 fhFORAmpL1J ->SetZTitle("Amplitude");
863e74f5 1164
6be2314f 1165 fhFORAmpL1J2 = new TH2F("hFORAmpL1J2", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1J2 trigger condition",
cf170170 1166 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1167 fhFORAmpL1J2 ->SetXTitle("Index #eta (columnns)");
1168 fhFORAmpL1J2 ->SetYTitle("Index #phi (rows)");
1169 fhFORAmpL1J2 ->SetZTitle("Amplitude");
cf170170 1170
aff917ac 1171
75e10d6a 1172 fhL0Amp = new TH2F("hL0Amp","FALTRO signal per Row and Column",
1173 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1174 fhL0Amp ->SetXTitle("Index #eta (columnns)");
e022364d 1175 fhL0Amp ->SetYTitle("Index #phi (rows)");
1176 fhL0Amp ->SetZTitle("Amplitude");
e395081d 1177
75e10d6a 1178 fhL0AmpL1G = new TH2F("hL0AmpL1G","FALTRO signal per Row and Column, with L1G trigger condition",
1179 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1180 fhL0AmpL1G ->SetXTitle("Index #eta (columnns)");
a40222c8 1181 fhL0AmpL1G ->SetYTitle("Index #phi (rows)");
1182 fhL0AmpL1G ->SetZTitle("Amplitude");
863e74f5 1183
e395081d 1184
75e10d6a 1185 fhL0AmpL1J = new TH2F("hL0AmpL1J","FALTRO signal per Row and Column, with L1j trigger condition",
1186 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1187 fhL0AmpL1J ->SetXTitle("Index #eta (columnns)");
a40222c8 1188 fhL0AmpL1J ->SetYTitle("Index #phi (rows)");
1189 fhL0AmpL1J ->SetZTitle("Amplitude");
863e74f5 1190
aff917ac 1191
75e10d6a 1192 fhL1Amp = new TH2F("hL1Amp","STU signal per Row and Column",
1193 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1194 fhL1Amp ->SetXTitle("Index #eta (columnns)");
aff917ac 1195 fhL1Amp ->SetYTitle("Index #phi (rows)");
1196 fhL1Amp ->SetZTitle("Amplitude");
1197
75e10d6a 1198 fhL1GAmp = new TH2F("hL1GAmp","STU signal per Row and Column for L1 Gamma",
1199 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1200 fhL1GAmp ->SetXTitle("Index #eta (columnns)");
e022364d 1201 fhL1GAmp ->SetYTitle("Index #phi (rows)");
1202 fhL1GAmp ->SetZTitle("Amplitude");
863e74f5 1203
6be2314f 1204 fhL1G2Amp = new TH2F("hL1G2Amp","STU signal per Row and Column for L1 Gamma2",
cf170170 1205 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1206 fhL1G2Amp ->SetXTitle("Index #eta (columnns)");
1207 fhL1G2Amp ->SetYTitle("Index #phi (rows)");
1208 fhL1G2Amp ->SetZTitle("Amplitude");
aff917ac 1209
75e10d6a 1210 fhL1JAmp = new TH2F("hL1JAmp","STU signal per Row and Column for L1 Jet",
77626b4a 1211 fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
75e10d6a 1212 fhL1JAmp ->SetXTitle("Index #eta (columnns)");
e022364d 1213 fhL1JAmp ->SetYTitle("Index #phi (rows)");
1214 fhL1JAmp ->SetZTitle("Amplitude");
863e74f5 1215
6be2314f 1216 fhL1J2Amp = new TH2F("hL1J2Amp","STU signal per Row and Column for L1 Jet2",
cf170170 1217 fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
6be2314f 1218 fhL1J2Amp ->SetXTitle("Index #eta (columnns)");
1219 fhL1J2Amp ->SetYTitle("Index #phi (rows)");
1220 fhL1J2Amp ->SetZTitle("Amplitude");
863e74f5 1221
6be2314f 1222 fhL1FOREnergy = new TH2F("hL1FOREnergy","FOR index vs FOR energy",
cf170170 1223 fgkFALTROCols*fgkFALTRORows,0,fgkFALTROCols*fgkFALTRORows,200,0,200);
6be2314f 1224 fhL1FOREnergy ->SetXTitle("Index FOR");
1225 fhL1FOREnergy ->SetYTitle("Energy (ADC)");
aff917ac 1226
75e10d6a 1227 fhL0Patch = new TH2F("hL0Patch","FOR with associated L0 Patch",
1228 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1229 fhL0Patch ->SetXTitle("Index #eta (columnns)");
85196c29 1230 fhL0Patch ->SetYTitle("Index #phi (rows)");
e022364d 1231 fhL0Patch ->SetZTitle("counts");
aff917ac 1232
75e10d6a 1233 fhL1GPatch = new TH2F("hL1GPatch","FOR with associated L1 Gamma Patch",
1234 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1235 fhL1GPatch ->SetXTitle("Index #eta (columnns)");
85196c29 1236 fhL1GPatch ->SetYTitle("Index #phi (rows)");
e022364d 1237 fhL1GPatch ->SetZTitle("counts");
863e74f5 1238
6be2314f 1239 fhL1G2Patch = new TH2F("hL1G2Patch","FOR with associated L1 Gamma2 Patch",
cf170170 1240 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1241 fhL1G2Patch ->SetXTitle("Index #eta (columnns)");
1242 fhL1G2Patch ->SetYTitle("Index #phi (rows)");
1243 fhL1G2Patch ->SetZTitle("counts");
1244
1245 fhL1GPatchNotFake = new TH2F("hL1GPatchNotFake","FOR with L1 Gamma Patch associated to energetic cells",
cf170170 1246 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1247 fhL1GPatchNotFake ->SetXTitle("Index #eta (columnns)");
1248 fhL1GPatchNotFake ->SetYTitle("Index #phi (rows)");
1249 fhL1GPatchNotFake ->SetZTitle("counts");
863e74f5 1250
6be2314f 1251 fhL1GPatchFake = new TH2F("hL1GPatchFake","FOR without L1 Gamma Patch associated to energetic cells",
cf170170 1252 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1253 fhL1GPatchFake ->SetXTitle("Index #eta (columnns)");
1254 fhL1GPatchFake ->SetYTitle("Index #phi (rows)");
1255 fhL1GPatchFake ->SetZTitle("counts");
863e74f5 1256
1257
6be2314f 1258 fhL1GPatchNotAllFake = new TH2F("hL1GPatchNotAllFake","FOR with one L1 Gamma Patch associated to an energetic cell",
cf170170 1259 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1260 fhL1GPatchNotAllFake ->SetXTitle("Index #eta (columnns)");
1261 fhL1GPatchNotAllFake ->SetYTitle("Index #phi (rows)");
1262 fhL1GPatchNotAllFake ->SetZTitle("counts");
863e74f5 1263
6be2314f 1264 fhL1GPatchAllFake = new TH2F("hL1GPatchAllFake","FOR without any L1 Gamma Patch associated to an energetic cell",
cf170170 1265 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1266 fhL1GPatchAllFake ->SetXTitle("Index #eta (columnns)");
1267 fhL1GPatchAllFake ->SetYTitle("Index #phi (rows)");
1268 fhL1GPatchAllFake ->SetZTitle("counts");
863e74f5 1269
6be2314f 1270 fhL1GPatchAllFakeMax = new TH2F("hL1GPatchAllFakeMax","FOR with L1 Gamma Patch Max not associated to an energetic cell",
cf170170 1271 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1272 fhL1GPatchAllFakeMax ->SetXTitle("Index #eta (columnns)");
1273 fhL1GPatchAllFakeMax ->SetYTitle("Index #phi (rows)");
1274 fhL1GPatchAllFakeMax ->SetZTitle("counts");
863e74f5 1275
6be2314f 1276 fhL1GPatchNotAllFakeMax = new TH2F("hL1GPatchNotAllFakeMax","FOR with one L1 Gamma Patch Max associated to an energetic cell",
cf170170 1277 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1278 fhL1GPatchNotAllFakeMax ->SetXTitle("Index #eta (columnns)");
1279 fhL1GPatchNotAllFakeMax ->SetYTitle("Index #phi (rows)");
1280 fhL1GPatchNotAllFakeMax ->SetZTitle("counts");
863e74f5 1281
1282 fhL1GPatchNotAllFakeMaxE = new TH1F("hL1GPatchNotAllFakeMaxE","Energy distribution of FOR in events with L1 Gamma Patch Max associated to an energetic cell",
cf170170 1283 fNBinsClusterE,0,fMaxClusterE);
863e74f5 1284 fhL1GPatchNotAllFakeMaxE ->SetXTitle("Energy (GeV)");
aff917ac 1285
863e74f5 1286
6be2314f 1287 fhL1GPatchAllFakeMaxE = new TH1F("hL1GPatchAllFakeMaxE","Energy distribution of FOR in events with L1 Gamma Patch Max not associated to an energetic cell",
cf170170 1288 fNBinsClusterE,0,fMaxClusterE);
863e74f5 1289 fhL1GPatchAllFakeMaxE ->SetXTitle("Energy (GeV)");
6be2314f 1290
1291 fhL1GPatchNotAllFakeE = new TH1F("hL1GPatchNotAllFakeE","Energy distribution of FOR in events with L1 Gamma Patch not associated to an energetic cell",
cf170170 1292 fNBinsClusterE,0,fMaxClusterE);
863e74f5 1293 fhL1GPatchNotAllFakeE ->SetXTitle("Energy (GeV)");
1294
6be2314f 1295 fhL1GPatchAllFakeE = new TH1F("hL1GPatchAllFakeE","Energy distribution of FOR in events with L1 Gamma Patch associated to an energetic cell",
cf170170 1296 fNBinsClusterE,0,fMaxClusterE);
863e74f5 1297 fhL1GPatchAllFakeE ->SetXTitle("Energy (GeV)");
1298
1299
6be2314f 1300 fhL1GPatchFakeE = new TH1F("hL1GPatchFakeE","Energy distribution of FOR with L1 Gamma Patch not associated to an energetic cell",
cf170170 1301 fNBinsClusterE,0,fMaxClusterE);
863e74f5 1302 fhL1GPatchFakeE ->SetXTitle("Energy (GeV)");
1303
6be2314f 1304 fhL1GPatchNotFakeE = new TH1F("hL1GPatchNotFakeE","Energy distribution of FOR with L1 Gamma Patch associated to an energetic cell",
cf170170 1305 fNBinsClusterE,0,fMaxClusterE);
863e74f5 1306 fhL1GPatchNotFakeE ->SetXTitle("Energy (GeV)");
1307
73c5a035 1308 fhNPatchFake = new TH2F("hNPatchFake","number of fake patchs vs. all patchs are fake",
cf170170 1309 3,0,3, 2880,0,2880);
46fec84c 1310 fhNPatchFake ->SetYTitle("number of fake patchs");
1311 fhNPatchFake ->SetXTitle("all fake event");
1312 fhNPatchFake ->SetZTitle("counts");
863e74f5 1313
1314
73c5a035 1315 fhNPatchNotFake = new TH2F("hNPatchNotFake","number of Not fake patchs vs. all patchs are fake",
cf170170 1316 3, 0, 3, 2000,0,2000);
46fec84c 1317 fhNPatchNotFake ->SetYTitle("number of Not fake patchs");
1318 fhNPatchNotFake ->SetXTitle("all fake event");
1319 fhNPatchNotFake ->SetZTitle("counts");
863e74f5 1320
1321
75e10d6a 1322 fhL1JPatch = new TH2F("hL1JPatch","FOR with associated L1 Jet Patch",
77626b4a 1323 fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
75e10d6a 1324 fhL1JPatch ->SetXTitle("Index #eta (columnns)");
85196c29 1325 fhL1JPatch ->SetYTitle("Index #phi (rows)");
e022364d 1326 fhL1JPatch ->SetZTitle("counts");
863e74f5 1327
6be2314f 1328 fhL1J2Patch = new TH2F("hL1J2Patch","FOR with associated L1 Jet2 Patch",
cf170170 1329 fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
6be2314f 1330 fhL1J2Patch ->SetXTitle("Index #eta (columnns)");
1331 fhL1J2Patch ->SetYTitle("Index #phi (rows)");
1332 fhL1J2Patch ->SetZTitle("counts");
aff917ac 1333
75e10d6a 1334 fhV0STU = new TH2I("hV0STU","Total signal STU vs V0C+V0S",
1335 fNBinsV0Signal,0,fMaxV0Signal,fNBinsSTUSignal,0,fMaxSTUSignal);
85196c29 1336 fhV0STU ->SetXTitle("Signal V0C+V0A");
1337 fhV0STU ->SetYTitle("Total signal STU");
e022364d 1338 fhV0STU ->SetZTitle("counts");
aff917ac 1339
480b9db0 1340
85196c29 1341 fhFEESTU = new TH2F("hFEESTU","STU / FEE vs channel", fNBinsSTUFEERatio,0,fMaxSTUFEERatio,30,0,30);
1342 fhFEESTU ->SetXTitle("STU/FEE signal");
1343 fhFEESTU ->SetYTitle("channel");
e022364d 1344 fhFEESTU ->SetZTitle("counts");
aff917ac 1345
85196c29 1346 fhTRUSTU = new TH2F("hTRUSTU","STU / TRU vs channel", fNBinsSTUTRURatio,0,fMaxSTUTRURatio,30,0,30);
1347 fhTRUSTU ->SetXTitle("STU/TRU signal");
1348 fhTRUSTU ->SetYTitle("channel");
e022364d 1349 fhTRUSTU ->SetZTitle("counts");
aff917ac 1350
0d896539 1351 fhGPMaxVV0TT = new TH2F("hGPMaxVV0TT","Maximum patch of L1-Gamma vs V0 signal in STU",fNBinsV0Signal,0,fMaxV0Signal,1000,0,1000);
1352 fhGPMaxVV0TT ->SetXTitle("V0 from STU");
faa45c63 1353 fhGPMaxVV0TT ->SetYTitle("Patch Max");
4ee53435 1354
0d896539 1355 fhJPMaxVV0TT = new TH2F("hJPMaxVV0TT","Maximum patch of L1-Jet vs V0 signal in STU",fNBinsV0Signal,0,fMaxV0Signal,1000,0,1000);
1356 fhJPMaxVV0TT ->SetXTitle("V0 from STU");
faa45c63 1357 fhJPMaxVV0TT ->SetYTitle("Patch Max");
ec77a234 1358
0d896539 1359 fhFORMeanAmp = new TProfile2D("hFORMeanAmp", "Mean FastOR(FEE) signal per Row and Column", fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1360 fhFORMeanAmp->SetXTitle("Index #eta");
1361 fhFORMeanAmp->SetYTitle("Index #phi");
1362
1363 fhL0MeanAmp = new TProfile2D("hL0MeanAmp", "Mean FastOR(TRU) signal per Row and Column", fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1364 fhL0MeanAmp->SetXTitle("Index #eta");
1365 fhL0MeanAmp->SetYTitle("Index #phi");
4ee53435 1366
0d896539 1367 fhL1MeanAmp = new TProfile2D("hL1MeanAmp", "Mean FastOR(STU) signal per Row and Column", fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1368 fhL1MeanAmp->SetXTitle("Index #eta");
1369 fhL1MeanAmp->SetYTitle("Index #phi");
ec77a234 1370
0d896539 1371 fhL1GPatchMax = new TH2F("hL1GPatchMax","FOR of max amplitude patch with associated L1 Gamma Patch",
ec77a234 1372 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
0d896539 1373 fhL1GPatchMax ->SetXTitle("Index #eta (columnns)");
1374 fhL1GPatchMax ->SetYTitle("Index #phi (rows)");
1375 fhL1GPatchMax ->SetZTitle("counts");
863e74f5 1376
6be2314f 1377 fhL1G2PatchMax = new TH2F("hL1G2PatchMax","FOR of max amplitude patch with associated L1 Gamma2 Patch",
cf170170 1378 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
6be2314f 1379 fhL1G2PatchMax ->SetXTitle("Index #eta (columnns)");
1380 fhL1G2PatchMax ->SetYTitle("Index #phi (rows)");
1381 fhL1G2PatchMax ->SetZTitle("counts");
0d896539 1382
1383 fhL1JPatchMax = new TH2F("hL1JPatchMax","FOR of max amplitude patch with associated L1 Jet Patch",
ec77a234 1384 fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
0d896539 1385 fhL1JPatchMax ->SetXTitle("Index #eta (columnns)");
1386 fhL1JPatchMax ->SetYTitle("Index #phi (rows)");
1387 fhL1JPatchMax ->SetZTitle("counts");
863e74f5 1388
6be2314f 1389 fhL1J2PatchMax = new TH2F("hL1JPatchMax","FOR of max amplitude patch with associated L1 Jet2 Patch",
cf170170 1390 fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
6be2314f 1391 fhL1J2PatchMax ->SetXTitle("Index #eta (columnns)");
1392 fhL1J2PatchMax ->SetYTitle("Index #phi (rows)");
1393 fhL1J2PatchMax ->SetZTitle("counts");
0d896539 1394
bce9493b 1395 fOutputList->Add(fhNEvents);
1396 fOutputList->Add(fhV0STU);
e022364d 1397 fOutputList->Add(fhFORAmp);
a40222c8 1398 fOutputList->Add(fhFORAmpL1G);
6be2314f 1399 fOutputList->Add(fhFORAmpL1G2);
a40222c8 1400 fOutputList->Add(fhFORAmpL1J);
6be2314f 1401 fOutputList->Add(fhFORAmpL1J2);
e022364d 1402 fOutputList->Add(fhL0Amp);
a40222c8 1403 fOutputList->Add(fhL0AmpL1G);
1404 fOutputList->Add(fhL0AmpL1J);
aff917ac 1405 fOutputList->Add(fhL1Amp);
e022364d 1406 fOutputList->Add(fhL1GAmp);
6be2314f 1407 fOutputList->Add(fhL1G2Amp);
e022364d 1408 fOutputList->Add(fhL1JAmp);
6be2314f 1409 fOutputList->Add(fhL1J2Amp);
1410 fOutputList->Add(fhL1FOREnergy);
bce9493b 1411 fOutputList->Add(fhL0Patch);
1412 fOutputList->Add(fhL1GPatch);
6be2314f 1413 fOutputList->Add(fhL1G2Patch);
1414 fOutputList->Add(fhL1GPatchNotFake);
1415 fOutputList->Add(fhL1GPatchFake);
1416 fOutputList->Add(fhL1GPatchAllFake);
1417 fOutputList->Add(fhL1GPatchNotAllFake);
1418 fOutputList->Add(fhL1GPatchNotAllFakeMax);
1419 fOutputList->Add(fhL1GPatchAllFakeMax);
863e74f5 1420 fOutputList->Add(fhL1GPatchNotAllFakeMaxE);
6be2314f 1421 fOutputList->Add(fhL1GPatchAllFakeMaxE);
863e74f5 1422 fOutputList->Add(fhL1GPatchNotAllFakeE);
6be2314f 1423 fOutputList->Add(fhL1GPatchAllFakeE);
863e74f5 1424 fOutputList->Add(fhL1GPatchFakeE);
6be2314f 1425 fOutputList->Add(fhL1GPatchNotFakeE);
46fec84c 1426 fOutputList->Add(fhNPatchFake);
1427 fOutputList->Add(fhNPatchNotFake);
863e74f5 1428
bce9493b 1429 fOutputList->Add(fhL1JPatch);
6be2314f 1430 fOutputList->Add(fhL1J2Patch);
ec77a234 1431 fOutputList->Add(fhFEESTU);
1432 fOutputList->Add(fhTRUSTU);
1433
1434 fOutputList->Add(fhGPMaxVV0TT);
1435 fOutputList->Add(fhJPMaxVV0TT);
1436
1437 fOutputList->Add(fhFORMeanAmp);
1438 fOutputList->Add(fhL0MeanAmp);
1439 fOutputList->Add(fhL1MeanAmp);
863e74f5 1440
ec77a234 1441 fOutputList->Add(fhL1GPatchMax);
6be2314f 1442 fOutputList->Add(fhL1G2PatchMax);
ec77a234 1443 fOutputList->Add(fhL1JPatchMax);
6be2314f 1444 fOutputList->Add(fhL1J2PatchMax);
ec77a234 1445
1446 // Cluster histograms, E
4c0129b7 1447 TString hName [] = {"MB","L0","L1G1","L1G2","L1J1","L1J2","L1G1NoL1J1","L1J1NoLG1","L1G2NoL1G1","L1J2NoL1J1","Central","SemiCentral"};
1448 TString hTitle [] = {"MB trigger","L0 trigger","L1 Gamma1 trigger","L1 Gamma2 trigger","L1 Jet1 trigger","L1 Jet2 trigger",
1449 "L1 Gamma1 trigger and not L1 Jet1" ,"L1 Jet1 trigger and not L1 Gamma1",
1450 "L1 Gamma2 trigger and not L1 Gamma1","L1 Jet2 trigger and not L1 Jet1",
1451 "Central trigger","SemiCentral trigger"};
863e74f5 1452
31a3f95a 1453 for(Int_t i=0; i < 3; i++)
1454 {
1455 Int_t j = i+5;
1456 if(i==0)j=0;
1457
1458 fhClusMBPure[i] = new TH1F(Form("hClus%sPure",hName[j].Data()),
1459 Form("clusters E distribution for %s, no other EMCAL trigger on",hTitle[j].Data()),
1460 fNBinsClusterE,0,fMaxClusterE);
1461 fhClusMBPure[i] ->SetXTitle("Energy (GeV)");
1462 fOutputList->Add(fhClusMBPure[i]);
863e74f5 1463
31a3f95a 1464 fhClusMaxMBPure[i] = new TH1F(Form("hClusMax%sPure",hName[j].Data()),
1465 Form("maximum energy cluster per event for %s, no other EMCAL trigger on",hTitle[j].Data()),
cf170170 1466 fNBinsClusterE,0,fMaxClusterE);
31a3f95a 1467 fhClusMaxMBPure[i] ->SetXTitle("Energy (GeV)");
863e74f5 1468 fOutputList->Add(fhClusMaxMBPure[i]);
31a3f95a 1469 }
bce9493b 1470
4c0129b7 1471 for(Int_t i=0; i < fgkTriggerCombi; i++)
31a3f95a 1472 {
1473 fhV0[i] = new TH1F(Form("hV0%s",hName[i].Data()),
cf170170 1474 Form("V0 distribution for %s",hTitle[i].Data()),
1475 fNBinsV0Signal,0,fMaxV0Signal);
31a3f95a 1476 fhV0[i]->SetXTitle("V0");
1477 fOutputList->Add(fhV0[i] );
863e74f5 1478
31a3f95a 1479 fhClus[i] = new TH1F(Form("hClus%s",hName[i].Data()),
1480 Form("clusters E distribution for %s",hTitle[i].Data()),
1481 fNBinsClusterE,0,fMaxClusterE);
1482 fhClus[i] ->SetXTitle("Energy (GeV)");
1483 fOutputList->Add(fhClus[i]);
1484
1485 fhClusMax[i] = new TH1F(Form("hClusMax%s",hName[i].Data()),
1486 Form("maximum energy cluster per event for %s",hTitle[i].Data()),
1487 fNBinsClusterE,0,fMaxClusterE);
1488 fhClusMax[i]->SetXTitle("Energy (GeV)");
1489 fOutputList->Add(fhClusMax[i]);
1490
1491 // Cluster histograms, E vs Cen
1492
1493 fhClusCen[i] = new TH2F(Form("hClusCen%s",hName[i].Data()),
1494 Form("clusters E distribution vs centrality for %s",hTitle[i].Data()),
1495 fNBinsClusterE,0,fMaxClusterE,100, 0, 100);
1496 fhClusCen[i] ->SetXTitle("Energy (GeV)");
1497 fhClusCen[i] ->SetYTitle("Centrality");
863e74f5 1498 fOutputList->Add(fhClusCen[i]);
31a3f95a 1499
1500 fhClusCenMax[i] = new TH2F(Form("hClusCenMax%s",hName[i].Data()),
1501 Form("maximum energy cluster per event vs centrality for %s",hTitle[i].Data()),
1502 fNBinsClusterE,0,fMaxClusterE,100, 0, 100);
1503 fhClusCenMax[i]->SetXTitle("Energy (GeV)");
1504 fhClusCenMax[i]->SetYTitle("Centrality");
1505 fOutputList->Add(fhClusCenMax[i]);
1506
1507 // Cluster histograms, E vs V0
1508
1509 fhClusV0[i] = new TH2F(Form("hClusV0%s",hName[i].Data()),
1510 Form("clusters E distribution vs V0 for %s",hTitle[i].Data()),
1511 fNBinsClusterE,0,fMaxClusterE,fNBinsV0Signal,0,fMaxV0Signal);
1512 fhClusV0[i] ->SetXTitle("Energy (GeV)");
863e74f5 1513 fhClusV0[i] ->SetYTitle("V0");
31a3f95a 1514 fOutputList->Add(fhClusV0[i]);
1515
1516 fhClusV0Max[i] = new TH2F(Form("hClusV0Max%s",hName[i].Data()),
1517 Form("maximum energy cluster per event vs V0 for %s",hTitle[i].Data()),
1518 fNBinsClusterE,0,fMaxClusterE,fNBinsV0Signal,0,fMaxV0Signal);
1519 fhClusV0Max[i]->SetXTitle("Energy (GeV)");
1520 fhClusV0Max[i]->SetYTitle("V0");
1521 fOutputList->Add(fhClusV0Max[i]);
1522
1523 // Cluster histograms, E vs Pseudorapidity
1524 Float_t etamin =-0.8;
1525 Float_t etamax = 0.8;
1526 Int_t neta = 160;
1527 fhClusEta[i] = new TH2F(Form("hClusEta%s",hName[i].Data()),
1528 Form("clusters distribution vs #eta for %s",hTitle[i].Data()),
1529 fNBinsClusterE,0,fMaxClusterE,neta, etamin, etamax);
1530 fhClusEta[i] ->SetXTitle("Energy (GeV)");
1531 fhClusEta[i] ->SetYTitle("#eta");
863e74f5 1532 fOutputList->Add(fhClusEta[i]);
31a3f95a 1533
1534 fhClusEtaMax[i] = new TH2F(Form("hClusEtaMax%s",hName[i].Data()),
1535 Form("maximum energy cluster per event vs #eta for %s",hTitle[i].Data()),
1536 fNBinsClusterE,0,fMaxClusterE,neta, etamin, etamax);
1537 fhClusEtaMax[i]->SetXTitle("Energy (GeV)");
1538 fhClusEtaMax[i]->SetYTitle("#eta");
1539 fOutputList->Add(fhClusEtaMax[i]);
1540
1541 // Cluster histograms, E vs Azimuthal angle
1542 Float_t phimin = 80. *TMath::DegToRad();
1543 Float_t phimax = 190.*TMath::DegToRad();
1544 Int_t nphi = 110;
1545
1546 fhClusPhi[i] = new TH2F(Form("hClusPhi%s",hName[i].Data()),
1547 Form("clusters distribution vs #phi for %s",hTitle[i].Data()),
1548 fNBinsClusterE,0,fMaxClusterE,nphi, phimin, phimax);
1549 fhClusPhi[i] ->SetXTitle("Energy (GeV)");
1550 fhClusPhi[i] ->SetYTitle("#phi (rad)");
863e74f5 1551 fOutputList->Add(fhClusPhi[i]);
31a3f95a 1552
1553 fhClusPhiMax[i] = new TH2F(Form("hClusPhiMax%s",hName[i].Data()),
1554 Form("maximum energy cluster per event vs #phi for %s",hTitle[i].Data()),
1555 fNBinsClusterE,0,fMaxClusterE,nphi, phimin, phimax);
1556 fhClusPhiMax[i]->SetXTitle("Energy (GeV)");
863e74f5 1557 fhClusPhiMax[i]->SetYTitle("#phi (rad)");
31a3f95a 1558 fOutputList->Add(fhClusPhiMax[i]);
1559
1560 // Cluster histograms, Pseudorapidity vs Azimuthal angle
1561
1562 fhClusEtaPhiHigh[i] = new TH2F(Form("hClusEtaPhiHigh%s",hName[i].Data()),
1563 Form("clusters distribution #eta vs #phi for %s, E > 10 GeV",hTitle[i].Data()),
1564 neta, etamin, etamax,nphi, phimin, phimax);
1565 fhClusEtaPhiHigh[i] ->SetXTitle("#eta");
1566 fhClusEtaPhiHigh[i] ->SetYTitle("#phi (rad)");
863e74f5 1567 fOutputList->Add(fhClusEtaPhiHigh[i]);
31a3f95a 1568
1569 fhClusEtaPhiHighCluMax[i] = new TH2F(Form("hClusEtaPhiHighCluMax%s",hName[i].Data()),
1570 Form("maximum energy cluster per event #eta vs #phi for %s, E > 10 GeV",hTitle[i].Data()),
1571 neta, etamin, etamax,nphi, phimin, phimax);
1572 fhClusEtaPhiHighCluMax[i]->SetXTitle("#eta");
1573 fhClusEtaPhiHighCluMax[i]->SetYTitle("#phi (rad)");
1574 fOutputList->Add(fhClusEtaPhiHighCluMax[i]);
1575
1576 fhClusEtaPhiLow[i] = new TH2F(Form("hClusEtaPhiLow%s",hName[i].Data()),
1577 Form("clusters distribution #eta vs #phi for %s, E < 10 GeV",hTitle[i].Data()),
1578 neta, etamin, etamax,nphi, phimin, phimax);
1579 fhClusEtaPhiLow[i] ->SetXTitle("#eta");
1580 fhClusEtaPhiLow[i] ->SetYTitle("#phi (rad)");
1581 fOutputList->Add(fhClusEtaPhiLow[i]);
1582
1583 fhClusEtaPhiLowCluMax[i] = new TH2F(Form("hClusEtaPhiLowCluMax%s",hName[i].Data()),
1584 Form("maximum energy cluster per event #eta vs #phi for %s, E < 10 GeV",hTitle[i].Data()),
1585 neta, etamin, etamax,nphi, phimin, phimax);
1586 fhClusEtaPhiLowCluMax[i]->SetXTitle("#eta");
1587 fhClusEtaPhiLowCluMax[i]->SetYTitle("#phi (rad)");
1588 fOutputList->Add(fhClusEtaPhiLowCluMax[i]);
1589
1590 fhClusEtaPhiHighCellMax[i] = new TH2F(Form("hClusEtaPhiHighCellMax%s",hName[i].Data()),
1591 Form("Cluster hit map in calorimeter (max cell), column vs row for %s, E > 10 GeV",hTitle[i].Data()),
1592 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1593 fhClusEtaPhiHighCellMax[i] ->SetXTitle("Index #eta (columnns)");
1594 fhClusEtaPhiHighCellMax[i] ->SetYTitle("Index #phi (rows)");
1595 fOutputList->Add(fhClusEtaPhiHighCellMax[i]);
1596
1597 fhClusEtaPhiHighCellMaxCluMax[i] = new TH2F(Form("hClusEtaPhiHighCellMaxCluMax%s",hName[i].Data()),
1598 Form("Max E cluster hit map in calorimeter (max cell), column vs row for %s, E > 10 GeV",
1599 hTitle[i].Data()),fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1600 fhClusEtaPhiHighCellMaxCluMax[i]->SetXTitle("Index #eta (columnns)");
1601 fhClusEtaPhiHighCellMaxCluMax[i]->SetYTitle("Index #phi (rows)");
1602 fOutputList->Add(fhClusEtaPhiHighCellMaxCluMax[i]);
1603
1604 fhClusEtaPhiLowCellMax[i] = new TH2F(Form("hClusEtaPhiLowCellMax%s",hName[i].Data()),
1605 Form("Cluster hit map in calorimeter (max cell), column vs row for %s, E < 10 GeV",hTitle[i].Data()),
1606 fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1607 fhClusEtaPhiLowCellMax[i] ->SetXTitle("Index #eta (columnns)");
1608 fhClusEtaPhiLowCellMax[i] ->SetYTitle("#phi (rad)");
1609 fOutputList->Add(fhClusEtaPhiLowCellMax[i]);
1610
1611 fhClusEtaPhiLowCellMaxCluMax[i] = new TH2F(Form("hClusEtaPhiLowCellMaxCluMax%s",hName[i].Data()),
1612 Form("Max E cluster hit map in calorimeter (max cell), column vs row for %s, E < 10 GeV",
1613 hTitle[i].Data()),fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1614 fhClusEtaPhiLowCellMaxCluMax[i]->SetXTitle("Index #eta (columnns)");
863e74f5 1615 fhClusEtaPhiLowCellMaxCluMax[i]->SetYTitle("#phi (rad)");
31a3f95a 1616 fOutputList->Add(fhClusEtaPhiLowCellMaxCluMax[i]);
1617 }
ec77a234 1618
863e74f5 1619 PostData(1, fOutputList);
bce9493b 1620}
cf170170 1621
85196c29 1622//______________________________________________________
863e74f5 1623void AliAnalysisTaskEMCALTriggerQA::UserExec(Option_t *)
bce9493b 1624{
1625 // Main loop
863e74f5 1626
bce9493b 1627 AliVEvent* event = InputEvent();
1628
997b261e 1629 if (!event)
bce9493b 1630 {
997b261e 1631 AliError("No Event, exit");
bce9493b 1632 return;
1633 }
1634
2b4e1cc5 1635 InitGeometry(); // only once, must be done before OADB, geo OADB accessed here
1636
1637 if(fAccessOADB) AccessOADB(); // only once
1638
46fec84c 1639 InitCellPatchMaps(); //init to 0 map for cells and patches
1640
a40222c8 1641 //trigger configuration
997b261e 1642 TString triggerclasses = event->GetFiredTriggerClasses();
77626b4a 1643
997b261e 1644 Int_t eventType = ((AliVHeader*)event->GetHeader())->GetEventType();
46fec84c 1645 //std::cout << "trigger = " << triggerclasses << std::endl;
1646
6b4638cc 1647 // physics events eventType=7, select only those
6b4638cc 1648 if(triggerclasses=="" || eventType != 7) return;
0d896539 1649
46fec84c 1650 SetTriggerEventBit(triggerclasses);
997b261e 1651
46fec84c 1652 FillEventCounterHistogram();
0d896539 1653
46fec84c 1654 FillCellMaps();
0d896539 1655
46fec84c 1656 FillTriggerPatchMaps(triggerclasses);
bce9493b 1657
46fec84c 1658 FillMapHistograms();
bce9493b 1659
46fec84c 1660 FillV0Histograms();
bce9493b 1661
46fec84c 1662 FillL1GammaPatchHistograms();
bce9493b 1663
46fec84c 1664 FillL1JetPatchHistograms();
6be2314f 1665
46fec84c 1666 // FEE vs STU vs TRU
1667 FillCorrelationHistograms();
863e74f5 1668
46fec84c 1669 ClusterAnalysis();
0d896539 1670
863e74f5 1671 PostData(1, fOutputList);
85196c29 1672
1673}