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