AliPhysics  fc9925d (fc9925d)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEMCALTriggerQA.cxx
Go to the documentation of this file.
1  /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes is hereby granted *
9  * without fee, provided that the above copyright notice appears in all *
10  * copies and that both the copyright notice and this permission notice *
11  * appear in the supporting documentation. The authors make no claims *
12  * about the suitability of this software for any purpose. It is *
13  * provided "as is" without express or implied warranty. *
14  **************************************************************************/
15 
16 #include <TList.h>
17 #include <TH2F.h>
18 #include <TF1.h>
19 #include <TProfile2D.h>
20 #include <TStreamerInfo.h>
21 #include <TFile.h>
22 
23 #include "AliLog.h"
24 #include "AliVCluster.h"
25 #include "AliVCaloCells.h"
26 #include "AliVEvent.h"
27 #include "AliCentrality.h"
28 
29 #include "AliVEvent.h"
30 #include "AliVCaloTrigger.h"
31 #include "AliESDVZERO.h"
32 
33 #include "AliEMCALGeometry.h"
34 #include "AliEMCALRecoUtils.h"
35 #include "AliOADBContainer.h"
36 #include "AliAnalysisManager.h"
37 #include "AliMultSelection.h"
38 
39 #include "AliAnalysisTaskEMCALTriggerQA.h"
40 
42 ClassImp(AliAnalysisTaskEMCALTriggerQA) ;
44 
45 //______________________________________________________________________________
48 //______________________________________________________________________________
49 AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA() :
50 AliAnalysisTaskSE(),
51 fOutputList(0), fRecoUtils(0x0),
52 fGeoSet(0), fGeometry(0), fGeoName(""),
53 fOADBSet(kFALSE), fAccessOADB(kTRUE), fOADBFilePath(""),
54 fBitEGA(0), fBitEJE(0),
55 fEtaPhiEnMin(2.),
56 fSTUTotal(0), fTRUTotal(0),
57 fV0Trigger(0), fV0A(0), fV0C(0),
58 fFillV0SigHisto(0), fFillCenHisto(0), fFillClusAcceptHisto(0),
59 fMCData(kFALSE),
60 fFirstSM (0), fLastSM (0),
61 fCentEstimator("V0M"), fUseAliCentrality(0),
62 fEventMB (0),
63 fEventL0 (0), fEventL0D (0),
64 fEventL1G (0), fEventL1GD (0),
65 fEventL1G2 (0), fEventL1G2D(0),
66 fEventL1J (0), fEventL1JD (0),
67 fEventL1J2 (0), fEventL1J2D(0),
68 fEventCen (0), fEventSem (0),
69 fMomentum(),
70 //Histograms
71 fhNEvents(0), fhFORAmp(0),
72 fhFORAmpL1G(0), fhFORAmpL1G2(0),
73 fhFORAmpL1J(0), fhFORAmpL1J2(0),
74 fhL0Amp(0), fhL0AmpL1G(0), fhL0AmpL1J(0),
75 fhL1Amp(0), fhL1GAmp(0), fhL1G2Amp(0),
76 fhL1JAmp(0), fhL1J2Amp(0), fhL1FOREnergy(0),
77 fhL0Patch(0), fhL1GPatch(0), fhL1G2Patch(0),
78 fhL1GPatchNotFake(0), fhL1GPatchFake(0), fhL1GPatchNotAllFake(0),
79 fhL1GPatchAllFake(0), fhL1GPatchNotAllFakeMax(0),
80 fhL1GPatchAllFakeMax(0), fhL1GPatchNotAllFakeMaxE(0),
81 fhL1GPatchAllFakeMaxE(0), fhL1GPatchNotAllFakeE(0),
82 fhL1GPatchAllFakeE(0), fhL1GPatchFakeE(0),
83 fhL1GPatchNotFakeE(0), fhNPatchFake(0), fhNPatchNotFake(0),
84 fhL1JPatch(0), fhL1J2Patch(0),
85 fhFEESTU(0), fhTRUSTU(0), fhV0STU(0),
86 fhGPMaxVV0TT(0), fhJPMaxVV0TT(0),
87 fhFORMeanAmp(0), fhL0MeanAmp(0), fhL1MeanAmp(0),
88 fhL1GPatchMax(0), fhL1G2PatchMax(0),
89 fhL1JPatchMax(0), fhL1J2PatchMax(0),
90 //Histogram settings
91 fNBinsSTUSignal (300), fMaxSTUSignal (30000),
92 fNBinsTRUSignal (300), fMaxTRUSignal (30000),
93 fNBinsV0Signal (300), fMaxV0Signal (30000),
94 fNBinsSTUFEERatio(300), fMaxSTUFEERatio(100),
95 fNBinsSTUTRURatio(300), fMaxSTUTRURatio(100),
96 fNBinsClusterE (100), fMaxClusterE (50),
97 fNBinsClusterPhi (250), fMaxClusterPhi (5.71), fMinClusterPhi (1.39),
98 fNBinsClusterEta (96), fMaxClusterEta (0.7),
99 fMapCell (),
100 fMapCellL1G (), fMapCellL1G2 (),
101 fMapCellL1J (), fMapCellL1J2 (),
102 fMapTrigL0 (), fMapTrigL1 (),
103 fMapTrigL0L1G(), fMapTrigL0L1J(),
104 fMapTrigL1G (), fMapTrigL1G2 (),
105 fMapTrigL1J (), fMapTrigL1J2 ()
106 {
107  InitHistogramArrays();
108 }
109 
110 //______________________________________________________________________________
112 //______________________________________________________________________________
113 AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA(const char *name) :
114 AliAnalysisTaskSE(name),
115 fOutputList(0), fRecoUtils(0x0),
116 fGeoSet(0), fGeometry(0), fGeoName(""),
117 fOADBSet(kFALSE), fAccessOADB(kTRUE), fOADBFilePath(""),
118 fBitEGA(0), fBitEJE(0),
119 fEtaPhiEnMin(2.),
120 fSTUTotal(0), fTRUTotal(0),
121 fV0Trigger(0), fV0A(0), fV0C(0),
122 fFillV0SigHisto(0), fFillCenHisto(0), fFillClusAcceptHisto(0),
123 fMCData(kFALSE),
124 fFirstSM (0), fLastSM (0),
125 fCentEstimator("V0M"), fUseAliCentrality(0),
126 fEventMB (0),
127 fEventL0 (0), fEventL0D (0),
128 fEventL1G (0), fEventL1GD (0),
129 fEventL1G2 (0), fEventL1G2D(0),
130 fEventL1J (0), fEventL1JD (0),
131 fEventL1J2 (0), fEventL1J2D(0),
132 fEventCen (0), fEventSem (0),
133 fMomentum(),
134 //Histograms
135 fhNEvents(0), fhFORAmp(0),
136 fhFORAmpL1G(0), fhFORAmpL1G2(0),
137 fhFORAmpL1J(0), fhFORAmpL1J2(0),
138 fhL0Amp(0), fhL0AmpL1G(0), fhL0AmpL1J(0),
139 fhL1Amp(0), fhL1GAmp(0), fhL1G2Amp(0),
140 fhL1JAmp(0), fhL1J2Amp(0), fhL1FOREnergy(0),
141 fhL0Patch(0), fhL1GPatch(0), fhL1G2Patch(0),
142 fhL1GPatchNotFake(0), fhL1GPatchFake(0), fhL1GPatchNotAllFake(0),
143 fhL1GPatchAllFake(0), fhL1GPatchNotAllFakeMax(0),
144 fhL1GPatchAllFakeMax(0), fhL1GPatchNotAllFakeMaxE(0),
145 fhL1GPatchAllFakeMaxE(0), fhL1GPatchNotAllFakeE(0),
146 fhL1GPatchAllFakeE(0), fhL1GPatchFakeE(0),
147 fhL1GPatchNotFakeE(0), fhNPatchFake(0), fhNPatchNotFake(0),
148 fhL1JPatch(0), fhL1J2Patch(0),
149 fhFEESTU(0), fhTRUSTU(0), fhV0STU(0),
150 fhGPMaxVV0TT(0), fhJPMaxVV0TT(0),
151 fhFORMeanAmp(0), fhL0MeanAmp(0), fhL1MeanAmp(0),
152 fhL1GPatchMax(0), fhL1G2PatchMax(0),
153 fhL1JPatchMax(0), fhL1J2PatchMax(0),
154 //Histogram settings
155 fNBinsSTUSignal (300), fMaxSTUSignal (30000),
156 fNBinsTRUSignal (300), fMaxTRUSignal (30000),
157 fNBinsV0Signal (300), fMaxV0Signal (30000),
158 fNBinsSTUFEERatio(300), fMaxSTUFEERatio(100),
159 fNBinsSTUTRURatio(300), fMaxSTUTRURatio(100),
160 fNBinsClusterE (100), fMaxClusterE (50),
161 fNBinsClusterPhi (250), fMaxClusterPhi (5.71), fMinClusterPhi (1.39),
162 fNBinsClusterEta (96), fMaxClusterEta (0.7),
163 fMapCell (),
164 fMapCellL1G (), fMapCellL1G2 (),
165 fMapCellL1J (), fMapCellL1J2 (),
166 fMapTrigL0 (), fMapTrigL1 (),
167 fMapTrigL0L1G(), fMapTrigL0L1J(),
168 fMapTrigL1G (), fMapTrigL1G2 (),
169 fMapTrigL1J (), fMapTrigL1J2 ()
170 {
171  InitHistogramArrays();
172 
173  DefineOutput(1, TList::Class());
174 }
175 
176 //______________________________________________
178 //______________________________________________
179 void AliAnalysisTaskEMCALTriggerQA::AccessOADB()
180 {
181  // Set it only once
182  if(fOADBSet) return ;
183 
184  if(fOADBFilePath == "") fOADBFilePath = "$ALICE_PHYSICS/OADB/EMCAL" ;
185 
186  Int_t runnumber = InputEvent()->GetRunNumber() ;
187 
188  AliInfo(Form("Get AODB parameters from EMCAL in %s for run %d",fOADBFilePath.Data(),runnumber));
189 
190  Int_t nSM = fGeometry->GetNumberOfSuperModules();
191 
192  // Bad map
193  if(fRecoUtils->IsBadChannelsRemovalSwitchedOn())
194  {
195  AliOADBContainer *contBC=new AliOADBContainer("");
196  contBC->InitFromFile(Form("%s/EMCALBadChannels.root",fOADBFilePath.Data()),"AliEMCALBadChannels");
197 
198  TObjArray *arrayBC=(TObjArray*)contBC->GetObject(runnumber);
199 
200  if(arrayBC)
201  {
202  AliInfo("Remove EMCAL bad cells");
203 
204  for (Int_t i=0; i<nSM; ++i)
205  {
206  TH2I *hbm = fRecoUtils->GetEMCALChannelStatusMap(i);
207 
208  if (hbm)
209  delete hbm;
210 
211  hbm=(TH2I*)arrayBC->FindObject(Form("EMCALBadChannelMap_Mod%d",i));
212  if (!hbm)
213  {
214  AliError(Form("Can not get EMCALBadChannelMap_Mod%d",i));
215  continue;
216  }
217 
218  hbm->SetDirectory(0);
219  fRecoUtils->SetEMCALChannelStatusMap(i,hbm);
220 
221  //printf("Bad map for SM %d: %3.0f entries\n",i,fRecoUtils->GetEMCALChannelStatusMap(i)->Integral());
222 
223  } // loop
224  } else AliInfo("Do NOT remove EMCAL bad channels"); // run array
225 
226  delete contBC;
227  } // Remove bad
228 
229  fOADBSet = kTRUE;
230 }
231 
232 //________________________________________________
234 //________________________________________________
235 void AliAnalysisTaskEMCALTriggerQA::FillCellMaps()
236 {
237  Int_t posX = -1, posY = -1;
238  Int_t nSupMod = -1, ieta = -1, iphi = -1, nModule = -1, nIphi = -1, nIeta = -1;
239  Short_t absId = -1;
240  Int_t nCells = 0;
241 
242  AliVCaloCells& cells= *(InputEvent()->GetEMCALCells());
243 
244  if(cells.IsEMCAL())
245  {
246  for (Int_t icell = 0; icell < cells.GetNumberOfCells(); icell++)
247  {
248  nCells ++;
249 
250  Double_t amp =0., time = 0., efrac = 0;
251  Int_t mclabel = -1;
252 
253  cells.GetCell(icell, absId, amp, time,mclabel,efrac);
254 
255  fGeometry->GetCellIndex(absId, nSupMod, nModule, nIphi, nIeta);
256  fGeometry->GetCellPhiEtaIndexInSModule(nSupMod, nModule, nIphi, nIeta, iphi, ieta);
257 
258  //
259  // Shift collumns in even SM
260  Int_t shiftEta = AliEMCALGeoParams::fgkEMCALCols;
261 
262  // Shift collumn even more due to smaller acceptance of DCal collumns
263  if ( nSupMod > 11 && nSupMod < 18) shiftEta+=AliEMCALGeoParams::fgkEMCALCols/3;
264 
265  posX = (nSupMod % 2) ? ieta + shiftEta : ieta;
266  posY = iphi + AliEMCALGeoParams::fgkEMCALRows * int(nSupMod / 2);
267 
268  // Shift row less due to smaller acceptance of SM 10 and 11 to count DCal rows
269  if ( nSupMod > 11 && nSupMod < 20) posY -= (2*AliEMCALGeoParams::fgkEMCALRows / 3);
270 
271  Int_t indexX = Int_t(posX/2);
272  Int_t indexY = Int_t(posY/2);
273 
274  if(indexX >= fgkFALTROCols || indexY >= fgkFALTRORows )
275  {
276  AliWarning(Form("Wrong Position (x,y) = (%d,%d)",posX,posY));
277 
278  continue;
279  }
280 
281  // here it is the amplitude for each cell
282  fMapCell[indexY][indexX] += amp;
283 
284  if(fEventL1G || fEventL1GD)
285  {
286  fMapCellL1G[indexY][indexX] += amp;
287  //printf("L1G cell[%i,%i] amp=%f\n",indexY,indexX,fMapCellL1G[indexY][indexX]);
288  }
289 
290  if(fEventL1G2 || fEventL1G2D)
291  {
292  fMapCellL1G2[indexY][indexX] += amp;
293  //printf("L1G2 cell[%i,%i] amp=%f\n",indexY,indexX,fMapCellL1G2[indexY][indexX]);
294  }
295 
296  if(fEventL1J || fEventL1JD) fMapCellL1J [indexY][indexX] += amp;
297  if(fEventL1J2 || fEventL1J2D) fMapCellL1J2[indexY][indexX] += amp;
298 
299  //printf("cell[%i,%i] amp=%f\n",indexY,indexX,fMapCell[indexY][indexX]);
300  }
301  }
302 }
303 
304 //______________________________________________________________________________
306 //______________________________________________________________________________
307 void AliAnalysisTaskEMCALTriggerQA::FillTriggerPatchMaps(TString triggerclasses)
308 {
309  AliVCaloTrigger& trg= * (InputEvent()->GetCaloTrigger("EMCAL"));
310 
311  fV0Trigger = trg.GetL1V0(0)+trg.GetL1V0(1); // used elsewhere
312 
313  Int_t posX = -1, posY = -1;
314 
315  Int_t nL0Patch = 0 ;
316  //Int_t nL1Patch = 0 ;
317  fSTUTotal = 0;
318  fTRUTotal = 0;
319 
320  trg.Reset();
321  // loop on FASTOR
322 
323  while (trg.Next())
324  {
325  trg.GetPosition(posX,posY);
326 
327  if (posX > -1 && posY > -1)
328  {
329  //L0 analysis
330  Int_t nTimes = 0;
331  trg.GetNL0Times(nTimes);
332  Int_t l0Times[10];
333  trg.GetL0Times(l0Times);
334 
335  Float_t ampL0 = 0.;
336  trg.GetAmplitude(ampL0);
337  if (ampL0 > 0) fMapTrigL0[posY][posX] = ampL0;
338 
339  if(triggerclasses.Contains("CEMC7EGA-B-NOPF-CENTNOTRD") || triggerclasses.Contains("CPBI2EGA") ||
340  triggerclasses.Contains("CPBI2EG1") || triggerclasses.Contains("CINT7EG1-B-NOPF-CENTNOPMD") ||
341  triggerclasses.Contains("CINT7DG1-B-NOPF-CENTNOPMD")) fMapTrigL0L1G[posY][posX] += ampL0;
342 
343  if(triggerclasses.Contains("CEMC7EJE-B-NOPF-CENTNOTRD") || triggerclasses.Contains("CPBI2EJE") ||
344  triggerclasses.Contains("CPBI2EJ1") || triggerclasses.Contains("CINT7EJ1-B-NOPF-CENTNOPMD") ||
345  triggerclasses.Contains("CINT7DJ1-B-NOPF-CENTNOPMD")) fMapTrigL0L1J[posY][posX] += ampL0;
346  fTRUTotal += ampL0;
347 
348  Int_t l0fired = 0;
349  for (Int_t itime = 0; itime < nTimes; itime++)
350  {
351  if (l0Times[itime] > 7 && l0Times[itime] < 10) l0fired = 1;
352  }
353 
354  if (l0fired)
355  {
356  nL0Patch += nTimes;
357  fhL0Patch->Fill(posX,posY);
358  }
359 
360  //L1 analysis
361  Int_t bit = 0;
362  trg.GetTriggerBits(bit);
363 
364  Int_t ts = 0;
365  trg.GetL1TimeSum(ts);
366  if (ts > 0) fMapTrigL1[posY][posX] = ts;
367  fSTUTotal += ts;
368  // cout << "ts =" <<ts<<endl;
369 
370  //L1
371  Bool_t isEGA1 = ((bit >> fBitEGA ) & 0x1) && (fEventL1G || fEventL1GD ) ;
372  Bool_t isEGA2 = ((bit >> (fBitEGA+1)) & 0x1) && (fEventL1G2 || fEventL1G2D) ;
373  Bool_t isEJE1 = ((bit >> fBitEJE ) & 0x1) && (fEventL1J || fEventL1JD ) ;
374  Bool_t isEJE2 = ((bit >> (fBitEJE+1)) & 0x1) && (fEventL1J2 || fEventL1J2D) ;
375 
376  //if(isEGA1 || isEGA2 || isEJE1 || isEJE2) nL1Patch++;
377  //if(isEJE1 || isEJE2) printf("Jet STU patch %d, time sum %d, posX %d , posY %d\n",nL1Patch,ts,posX, posY);
378 
379  // L1-Gamma
380 
381  if (isEGA1)
382  {
383  fhL1GPatch ->Fill(posX,posY);
384  if (ts > 0) fMapTrigL1G [posY][posX] = ts;
385  }
386 
387  if (isEGA2)
388  {
389  fhL1G2Patch->Fill(posX,posY);
390  if (ts > 0) fMapTrigL1G2[posY][posX] = ts;
391  }
392 
393  // L1-Jet
394  if (isEJE1)
395  {
396  fhL1JPatch ->Fill(posX,posY);
397  if (ts > 0) fMapTrigL1J [posY][posX] = ts;
398 
399  }
400 
401  if (isEJE2)
402  {
403  fhL1J2Patch->Fill(posX,posY);
404  if (ts > 0) fMapTrigL1J2[posY][posX] = ts;
405  }
406 
407  }
408  }
409 
410 // // NOT SURE WHY THIS LINE, COMMENT IF NOT CLUSTER HISTO NOT FILLED FOR LHC13
411 // if (!nL0Patch)
412 // {
413 // fEventL0 = kFALSE;
414 // if (!triggerclasses.Contains("CPBI2")) fEventL1G = fEventL1G2 = fEventL1J = fEventL1J2 = kFALSE; // pp running
415 // }
416 
417  if(fTRUTotal > fMaxTRUSignal && DebugLevel() > 0)
418  AliInfo(Form("Large fTRUTotal %f",fTRUTotal));
419 
420  if(fSTUTotal > fMaxSTUSignal && DebugLevel() > 0)
421  AliInfo(Form("Large fSTUTotal %d",fSTUTotal));
422 }
423 
424 //___________________________________________________
427 //___________________________________________________
428 void AliAnalysisTaskEMCALTriggerQA::ClusterAnalysis()
429 {
430  if(fMCData) return ;
431 
432  // Init OADB
433  if(fAccessOADB) AccessOADB(); // only once
434 
435  //Get Vertex
436  Double_t v[3] = {0,0,0};
437  InputEvent()->GetPrimaryVertex()->GetXYZ(v);
438 
439  //clusters distribution
440  TRefArray* caloClus = new TRefArray();
441  InputEvent()->GetEMCALClusters(caloClus);
442 
443  Int_t nCaloClusters = caloClus->GetEntriesFast();
444 
445  Float_t emax = 0;
446  Float_t etamax = 0;
447  Float_t phimax = 0;
448  Float_t ietamax=-1;
449  Float_t iphimax=-1;
450 
451  Float_t e = 0;
452  Float_t eta = 0;
453  Float_t phi = 0;
454 
455  Int_t nSupMod = -1, nSupModMax = -1, ieta = -1, iphi = -1;
456 
457  //Get vertex for momentum calculation
458  Double_t vertex[] = {0.0,0.0,0.0};
459  //InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
460 
461  Float_t centrality = -1;
462  if(fUseAliCentrality)
463  {
464  if(InputEvent()->GetCentrality()) centrality = InputEvent()->GetCentrality()->GetCentralityPercentile(fCentEstimator);
465  }
466  else
467  {
468  AliMultSelection* multSelection = (AliMultSelection * ) fInputEvent->FindListObject("MultSelection") ;
469  if(multSelection) centrality = multSelection->GetMultiplicityPercentile(fCentEstimator, kTRUE) ;
470  }
471 
472  if(fFillCenHisto)
473  {
474  if( fEventL1G ) fhCentrality[kL1GammaTrig] ->Fill(centrality);
475  if( fEventL1G2 ) fhCentrality[kL1GammaTrig2] ->Fill(centrality);
476  if( fEventL1J ) fhCentrality[kL1JetTrig] ->Fill(centrality);
477  if( fEventL1J2 ) fhCentrality[kL1JetTrig2] ->Fill(centrality);
478  if( fEventL1GD ) fhCentrality[kL1GammaTrigD] ->Fill(centrality);
479  if( fEventL1G2D ) fhCentrality[kL1GammaTrig2D] ->Fill(centrality);
480  if( fEventL1JD ) fhCentrality[kL1JetTrigD] ->Fill(centrality);
481  if( fEventL1J2D ) fhCentrality[kL1JetTrig2D] ->Fill(centrality);
482  if( fEventMB ) fhCentrality[kMBTrig] ->Fill(centrality);
483  if( fEventL0 ) fhCentrality[kL0Trig] ->Fill(centrality);
484  if( fEventCen ) fhCentrality[kCentralTrig] ->Fill(centrality);
485  if( fEventSem ) fhCentrality[kSemiCentralTrig]->Fill(centrality);
486  if( fEventL1G && !fEventL1J) fhCentrality[kL1GammaOnlyTrig] ->Fill(centrality);
487  if( fEventL1J && !fEventL1G) fhCentrality[kL1JetOnlyTrig] ->Fill(centrality);
488  if( fEventL1G2 && !fEventL1G) fhCentrality[kL1Gamma2OnlyGammaTrig]->Fill(centrality);
489  if( fEventL1J2 && !fEventL1J) fhCentrality[kL1Jet2OnlyJetTrig] ->Fill(centrality);
490  }
491 
492  //printf("Centrality %f for estimator %s\n",centrality, fCentEstimator.Data());
493 
494  //if(!fEventMB) printf("MB : %d; L0 : %d; L1-Gam1 : %d; L1-Gam2 : %d; L1-Jet1 : %d; L1-Jet2 : %d; Central : %d; SemiCentral : %d \n",
495  // fEventMB,fEventL0,fEventL1G,fEventL1G2,fEventL1J,fEventL1J2,fEventCen,fEventSem);
496 
497  for(Int_t icalo = 0; icalo < nCaloClusters; icalo++)
498  {
499  AliVCluster *clus = (AliVCluster*) (caloClus->At(icalo));
500 
501  if(!clus->IsEMCAL()) continue;
502 
503  if(!fRecoUtils->IsGoodCluster(clus,fGeometry,InputEvent()->GetEMCALCells(),InputEvent()->GetBunchCrossNumber()))
504  continue;
505 
506  if(clus->GetNCells() < 2) continue ; // Avoid 1 cell clusters, noisy, exotic.
507 
508  clus->GetMomentum(fMomentum, vertex);
509 
510  Bool_t shared = kFALSE;
511  Int_t idAbs = -1, iphi0 = -1, ieta0 = -1;
512  fRecoUtils->GetMaxEnergyCell(fGeometry, InputEvent()->GetEMCALCells(),clus,
513  idAbs,nSupMod,ieta0,iphi0,shared);
514 
515  //Change index to be continuous over SM
516  //
517  // Shift collumns in even SM
518  Int_t shiftEta = AliEMCALGeoParams::fgkEMCALCols;
519 
520  // Shift collumn even more due to smaller acceptance of DCal collumns
521  if ( nSupMod > 11 && nSupMod < 18) shiftEta+=AliEMCALGeoParams::fgkEMCALCols/3;
522 
523  ieta = (nSupMod % 2) ? ieta0 + shiftEta : ieta0;
524  iphi = iphi0 + AliEMCALGeoParams::fgkEMCALRows * int(nSupMod / 2);
525 
526  // Shift row less due to smaller acceptance of SM 10 and 11 to count DCal rows
527  if ( nSupMod > 11 && nSupMod < 20) iphi -= (2*AliEMCALGeoParams::fgkEMCALRows / 3);
528 
529  ieta/=2;
530  iphi/=2;
531 
532  if(ieta > fgkFALTROCols || iphi > fgkFALTRORows )
533  AliWarning(Form("Wrong Position (x,y) = (%d,%d)",ieta,iphi));
534 
535  e = clus->E();
536  eta = fMomentum.Eta();
537  phi = fMomentum.Phi();
538  if( phi < 0 ) phi+=TMath::TwoPi();
539 
540  if(e > emax)
541  {
542  emax = e;
543  etamax = eta;
544  phimax = phi;
545  ietamax = ieta;
546  iphimax = iphi;
547  nSupModMax = nSupMod;
548  }
549 
550  // Fill cluster histograms depending on the event trigger selection
551  if( fEventMB ) FillClusterHistograms(kMBTrig ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
552  if( fEventCen ) FillClusterHistograms(kCentralTrig ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
553  if( fEventSem ) FillClusterHistograms(kSemiCentralTrig,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
554 
555  if( fEventL0 ) FillClusterHistograms(kL0Trig ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
556  if( fEventL1G ) FillClusterHistograms(kL1GammaTrig ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
557  if( fEventL1G2) FillClusterHistograms(kL1GammaTrig2 ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
558  if( fEventL1J ) FillClusterHistograms(kL1JetTrig ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
559  if( fEventL1J2) FillClusterHistograms(kL1JetTrig2 ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
560 
561  if( fEventL0D ) FillClusterHistograms(kL0TrigD ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
562  if( fEventL1GD ) FillClusterHistograms(kL1GammaTrigD ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
563  if( fEventL1G2D) FillClusterHistograms(kL1GammaTrig2D ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
564  if( fEventL1JD ) FillClusterHistograms(kL1JetTrigD ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
565  if( fEventL1J2D) FillClusterHistograms(kL1JetTrig2D ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
566 
567  if( fEventL0 && !fEventL0D ) FillClusterHistograms(kL0TrigPureEMC , kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
568  if( !fEventL0 && fEventL0D ) FillClusterHistograms(kL0TrigPureDMC , kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
569  if( fEventL1G && !fEventL1GD ) FillClusterHistograms(kL1GTrigPureEMC, kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
570  if( !fEventL1G && fEventL1GD ) FillClusterHistograms(kL1GTrigPureDMC, kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
571  if( fEventL1J && !fEventL1JD ) FillClusterHistograms(kL1JTrigPureEMC, kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
572  if( !fEventL1J && fEventL1JD ) FillClusterHistograms(kL1JTrigPureDMC, kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
573 
574  if( fEventL1G2 && !fEventL1G) FillClusterHistograms(kL1Gamma2OnlyGammaTrig,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
575  if( fEventL1J2 && !fEventL1J) FillClusterHistograms(kL1Jet2OnlyJetTrig ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
576 
577  if( fEventL1G2D && !fEventL1GD) FillClusterHistograms(kL1Gamma2OnlyGammaTrigD,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
578  if( fEventL1J2D && !fEventL1JD) FillClusterHistograms(kL1Jet2OnlyJetTrigD ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
579 
580 
581  if( fEventL1G && !fEventL1J )
582  FillClusterHistograms (kL1GammaOnlyTrig,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
583 
584  if( fEventL1J && !fEventL1G )
585  FillClusterHistograms (kL1JetOnlyTrig ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
586 
587  if( fEventL1GD && !fEventL1JD )
588  FillClusterHistograms (kL1GammaOnlyTrig,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
589 
590  if( fEventL1JD && !fEventL1GD )
591  FillClusterHistograms (kL1JetOnlyTrig ,kFALSE,e,eta,phi,ieta,iphi,nSupMod,centrality,fV0A+fV0C);
592 
593  if(!fEventL1G && !fEventL1J && !fEventL0 && !fEventL1GD && !fEventL1JD && !fEventL0D)
594  {
595  if( fEventMB ) fhClusMBPure[0] ->Fill(e);
596  if( fEventCen ) fhClusMBPure[1] ->Fill(e);
597  if( fEventSem ) fhClusMBPure[2] ->Fill(e);
598  }
599 
600  }
601 
602  // Maximum energy cluster per event histograms
603 
604  if( fEventMB ) FillClusterHistograms(kMBTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
605  if( fEventCen ) FillClusterHistograms(kCentralTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
606  if( fEventSem ) FillClusterHistograms(kSemiCentralTrig,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
607 
608  if( fEventL0 ) FillClusterHistograms(kL0Trig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
609  if( fEventL1G ) FillClusterHistograms(kL1GammaTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
610  if( fEventL1G2) FillClusterHistograms(kL1GammaTrig2 ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
611  if( fEventL1J ) FillClusterHistograms(kL1JetTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
612  if( fEventL1J2) FillClusterHistograms(kL1JetTrig2 ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
613 
614  if( fEventL0D ) FillClusterHistograms(kL0TrigD ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
615  if( fEventL1GD ) FillClusterHistograms(kL1GammaTrigD ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
616  if( fEventL1G2D) FillClusterHistograms(kL1GammaTrig2D ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
617  if( fEventL1JD ) FillClusterHistograms(kL1JetTrigD ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
618  if( fEventL1J2D) FillClusterHistograms(kL1JetTrig2D ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
619 
620  if( fEventL0 && !fEventL0D ) FillClusterHistograms(kL0TrigPureEMC , kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
621  if( !fEventL0 && fEventL0D ) FillClusterHistograms(kL0TrigPureDMC , kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
622  if( fEventL1G && !fEventL1GD ) FillClusterHistograms(kL1GTrigPureEMC, kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
623  if( !fEventL1G && fEventL1GD ) FillClusterHistograms(kL1GTrigPureDMC, kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
624  if( fEventL1J && !fEventL1JD ) FillClusterHistograms(kL1JTrigPureEMC, kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
625  if( !fEventL1J && fEventL1JD ) FillClusterHistograms(kL1JTrigPureDMC, kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
626 
627  if( fEventL1G2 && !fEventL1G) FillClusterHistograms(kL1Gamma2OnlyGammaTrig,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
628  if( fEventL1J2 && !fEventL1J) FillClusterHistograms(kL1Jet2OnlyJetTrig ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
629 
630  if( fEventL1G2D && !fEventL1GD) FillClusterHistograms(kL1Gamma2OnlyGammaTrigD,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
631  if( fEventL1J2D && !fEventL1JD) FillClusterHistograms(kL1Jet2OnlyJetTrigD ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
632 
633  if( fEventL1GD && !fEventL1JD )
634  FillClusterHistograms (kL1GammaOnlyTrigD,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
635  if( fEventL1JD && !fEventL1GD )
636  FillClusterHistograms (kL1JetOnlyTrigD ,kTRUE,emax,etamax,phimax,ietamax,iphimax,nSupModMax,centrality,fV0A+fV0C);
637 
638  if(!fEventL1G && !fEventL1J && !fEventL0 && !fEventL1GD && !fEventL1JD && !fEventL0D)
639  {
640  if( fEventMB ) fhClusMaxMBPure[0] ->Fill(emax);
641  if( fEventCen ) fhClusMaxMBPure[1] ->Fill(emax);
642  if( fEventSem ) fhClusMaxMBPure[2] ->Fill(emax);
643  }
644 }
645 
646 //______________________________________________________________________________________________
649 //______________________________________________________________________________________________
650 void AliAnalysisTaskEMCALTriggerQA::FillClusterHistograms(Int_t triggerNumber, Bool_t max,
651  Float_t e, Float_t eta, Float_t phi,
652  Float_t ieta, Float_t iphi, Int_t nSupMod,
653  Float_t centrality, Float_t fV0AC)
654 {
655  if(!max)
656  {
657  fhClus [triggerNumber]->Fill(e);
658  if(fFillCenHisto) fhClusCen[triggerNumber]->Fill(e,centrality);
659  if(fFillV0SigHisto) fhClusV0 [triggerNumber]->Fill(e,fV0AC);
660 
661  if ( nSupMod >= fFirstSM && nSupMod <= fLastSM )
662  {
663  fhClusSM [triggerNumber][nSupMod]->Fill(e);
664  if(fFillCenHisto) fhClusCenSM[triggerNumber][nSupMod]->Fill(e,centrality);
665  if(fFillV0SigHisto) fhClusV0SM [triggerNumber][nSupMod]->Fill(e,fV0AC);
666  }
667 
668  if(!fFillClusAcceptHisto)
669  {
670  // just fill 2
671  if(e > fEtaPhiEnMin) fhClusEtaPhiHigh[triggerNumber]->Fill( eta, phi);
672  else fhClusEtaPhiLow [triggerNumber]->Fill( eta, phi);
673  }
674  else
675  {
676  fhClusEta[triggerNumber]->Fill(e,eta);
677  fhClusPhi[triggerNumber]->Fill(e,phi);
678 
679  if(e > fEtaPhiEnMin)
680  {
681  fhClusEtaPhiHigh [triggerNumber]->Fill( eta, phi);
682  fhClusEtaPhiHighCellMax[triggerNumber]->Fill(ieta,iphi);
683  }
684  else
685  {
686  fhClusEtaPhiLow [triggerNumber]->Fill( eta, phi);
687  fhClusEtaPhiLowCellMax[triggerNumber]->Fill(ieta,iphi);
688  }
689  }
690  }
691  else
692  {
693  fhClusMax [triggerNumber]->Fill(e);
694  if(fFillCenHisto) fhClusCenMax[triggerNumber]->Fill(e,centrality);
695  if(fFillV0SigHisto) fhClusV0Max [triggerNumber]->Fill(e,fV0AC);
696 
697  if(fFillClusAcceptHisto)
698  {
699  fhClusEtaMax[triggerNumber]->Fill(e,eta);
700  fhClusPhiMax[triggerNumber]->Fill(e,phi);
701 
702  if(e > fEtaPhiEnMin)
703  {
704  fhClusEtaPhiHighCluMax [triggerNumber]->Fill( eta, phi);
705  fhClusEtaPhiHighCellMaxCluMax[triggerNumber]->Fill(ieta,iphi);
706  }
707  else
708  {
709  fhClusEtaPhiLowCluMax [triggerNumber]->Fill( eta, phi);
710  fhClusEtaPhiLowCellMaxCluMax[triggerNumber]->Fill(ieta,iphi);
711  }
712  }
713  }
714 }
715 
716 //_____________________________________________________________
718 //_____________________________________________________________
719 void AliAnalysisTaskEMCALTriggerQA::FillCorrelationHistograms()
720 {
721  Double_t ampFOR[60] = {0.}, ampL0[60] = {0.}, ampL1[60] = {0.};
722  for (Int_t i = 0; i < fgkFALTRORows; i++)
723  {
724  for (Int_t j = 0; j < fgkFALTROCols; j++)
725  {
726  //method to get TRU number
727  Int_t idFOR = -1;
728  fGeometry->GetAbsFastORIndexFromPositionInEMCAL(j,i,idFOR);
729  Int_t iTRU = -1;
730  Int_t iADC = -1;
731  fGeometry->GetTRUFromAbsFastORIndex(idFOR,iTRU,iADC);
732 
733  //printf("i %d, j %d, iTRU %d, iADC %d, idFOR %d; cell %f, L0 %f, L1 %f\n",
734  // i,j,iTRU,iADC,idFOR, fMapCell [i][j],fMapTrigL0[i][j],fMapTrigL1[i][j]);
735 
736  if (iTRU >= 0)
737  {
738  ampFOR[iTRU] += fMapCell [i][j];
739  ampL0[iTRU] += fMapTrigL0[i][j];
740  ampL1[iTRU] += fMapTrigL1[i][j];
741  }
742  }
743  }
744 
745  // FEE vs STU and TRU vs STU ratios
746  for (Int_t i = 0; i < 60; i++)
747  {
748  if (ampFOR[i] != 0 && ampL1[i] != 0)
749  {
750  fhFEESTU->Fill(ampL1[i]/ampFOR[i],i);
751  if(ampL1[i]/ampFOR[i] > fMaxSTUFEERatio && DebugLevel() > 0 )
752  AliWarning(Form("Large STU/FEE ratio %f",ampL1[i]/ampFOR[i]));
753  }
754 
755  if (ampL0[i] != 0 && ampL1[i] != 0)
756  {
757  fhTRUSTU->Fill(ampL1[i]/ampL0[i] ,i);
758  if(ampL1[i]/ampL0[i] > fMaxSTUTRURatio && DebugLevel() > 0 )
759  AliWarning(Form("Large STU/TRU ratio %f",ampL1[i]/ampL0[i]));
760  }
761  }
762 }
763 
764 //_____________________________________________________________
766 //_____________________________________________________________
767 void AliAnalysisTaskEMCALTriggerQA::FillEventCounterHistogram()
768 {
769  fhNEvents->Fill(0.5); // All physics events
770 
771  if( fEventMB )
772  {
773  fhNEvents->Fill(1.5);
774  if( !fEventL1G && !fEventL1J && !fEventL1G2 && !fEventL1J2 && !fEventL0 ) fhNEvents->Fill(12.5);
775  }
776  else
777  {
778  if( fEventL0 ) fhNEvents->Fill(13.5);
779  if( fEventL1G ) fhNEvents->Fill(14.5);
780  if( fEventL1J ) fhNEvents->Fill(15.5);
781  }
782 
783  if( fEventCen) fhNEvents->Fill(2.5);
784  if( fEventSem) fhNEvents->Fill(3.5);
785 
786  if( fEventL0 )
787  {
788  fhNEvents->Fill(4.5);
789  }
790 
791  if( fEventL1G )
792  {
793  fhNEvents->Fill(5.5);
794  if(!fEventL1J) fhNEvents->Fill(9.5);
795  if(fEventCen || fEventSem) fhNEvents->Fill(16.5);
796  }
797 
798  if( fEventL1G2 )
799  {
800  fhNEvents->Fill(6.5);
801  if( !fEventL1G ) fhNEvents->Fill(18.5);
802 
803  }
804 
805  if( fEventL1J )
806  {
807  fhNEvents->Fill(7.5);
808  if(!fEventL1G) fhNEvents->Fill(10.5);
809  if(fEventCen || fEventSem) fhNEvents->Fill(17.5);
810  }
811 
812  if( fEventL1J2 )
813  {
814  fhNEvents->Fill(8.5);
815  if( !fEventL1J ) fhNEvents->Fill(19.5);
816  }
817 
818  if(fEventL1J && fEventL1G) fhNEvents->Fill(11.5);
819 
820  if( fEventL0D ) fhNEvents->Fill(20.5);
821  if( fEventL1GD ) fhNEvents->Fill(21.5);
822  if( fEventL1JD ) fhNEvents->Fill(22.5);
823 
824  if( fEventL0 && !fEventL0D ) fhNEvents->Fill(23.5);
825  if( fEventL1G && !fEventL1GD ) fhNEvents->Fill(24.5);
826  if( fEventL1J && !fEventL1JD ) fhNEvents->Fill(25.5);
827 }
828 
829 //______________________________________________________________
831 //______________________________________________________________
832 void AliAnalysisTaskEMCALTriggerQA::FillL1GammaPatchHistograms()
833 {
834  // Study fakes - Make it more understandable!!!
835 
836  Int_t areAllFakes = 2;
837  Int_t numberpatchNotFake = 0;
838  Int_t numberpatchFake = 0;
839 
840  Int_t threshold = 10;// it's not GeV it's ADC !!
841  Bool_t enoughE = kFALSE;
842  Double_t patchMax = 0;
843  Int_t colMax = -1;
844  Int_t rowMax = -1;
845  Int_t shiftCol = -1;
846  Int_t shiftRow = -1;
847 
848  // loop on patches
849  for (Int_t posx = 0; posx < fgkFALTROCols; posx++)
850  {
851  for (Int_t posy = 0; posy < fgkFALTRORows; posy++)
852  {
853  Double_t patchEnergy = 0;
854 
855  if(fMapTrigL1G[posy][posx] > 0)
856  {
857  for(Int_t irow = 0; irow < 2; irow++)
858  {
859  for(Int_t icol = 0; icol < 2; icol++)
860  {
861  // loop on cells
862  shiftCol = posx+icol;
863  shiftRow = posy+irow;
864 
865  // printf("cell[%i,%i]=%f\n",posy+icol,posx+irow, fMapCellL1G[posy+icol][posx+irow]);
866  if(shiftRow < fgkFALTRORows && shiftCol < fgkFALTROCols)
867  {
868  patchEnergy += fMapCellL1G[shiftRow][shiftCol] ;
869 
870  if( fMapCellL1G[shiftRow][shiftCol] > threshold/2 ) enoughE = kTRUE;
871  }
872  }
873  }
874 
875  if (patchEnergy > patchMax)
876  {
877  patchMax = patchEnergy;
878  colMax = posx;
879  rowMax = posy;
880  }
881 
882  if(patchEnergy>threshold || (patchEnergy>threshold-3 && enoughE))
883  {
884  numberpatchNotFake++;
885  fhL1GPatchNotFake ->Fill(posx,posy);
886  fhL1GPatchNotFakeE->Fill(patchEnergy);
887  areAllFakes = 1;
888  }
889  else
890  {
891  numberpatchFake++;
892  areAllFakes = 0;
893  fhL1GPatchFake ->Fill(posx,posy);
894  fhL1GPatchFakeE->Fill(patchEnergy);
895  }
896  }
897  }
898  }
899 
900  fhNPatchNotFake->Fill(areAllFakes,numberpatchNotFake);
901  fhNPatchFake ->Fill(areAllFakes,numberpatchFake);
902 
903  if(areAllFakes == 0)
904  {
905  // loop on patchs
906  for (Int_t col = 0; col < fgkFALTROCols; col++)
907  {
908  for (Int_t row = 0; row < fgkFALTRORows; row++)
909  {
910  if(fMapTrigL1G[row][col] > 0)
911  {
912  // cout <<"checking fMapTrigL1G[row][col]"<<fMapTrigL1G[row][col]<<endl;
913  fhL1GPatchAllFake->Fill(col,row);
914 
915  Double_t patchEnergy=0;
916  for(Int_t irow = 0; irow < 2; irow++)
917  {
918  for(Int_t icol = 0; icol < 2; icol++)
919  {
920  shiftCol = col+icol;
921  shiftRow = row+irow;
922 
923  if(shiftRow < fgkFALTRORows && shiftCol < fgkFALTROCols)
924  patchEnergy += fMapCellL1G[shiftRow][shiftCol] ;
925 
926  }
927  }
928  fhL1GPatchAllFakeE->Fill(patchEnergy);
929  }
930  }
931  }
932  // cout << "row max"<<rowMax<<" colmax"<<colMax<< " fMapTrigL1G[rowMax][colMax]"<< fMapTrigL1G[rowMax][colMax]<<endl;
933 
934  if(fMapTrigL1G[rowMax][colMax] > 0)
935  {
936  // printf("\npatch max [%i,%i] = %f\n",rowMax,colMax,patchMax);
937  fhL1GPatchAllFakeMax ->Fill(colMax,rowMax);
938  fhL1GPatchAllFakeMaxE->Fill(patchMax);
939  }
940  }
941  else
942  {
943  // loop on patches
944  for (Int_t col = 0; col < fgkFALTROCols; col++)
945  {
946  for (Int_t row = 0; row < fgkFALTRORows; row++)
947  {
948  if(fMapTrigL1G[row][col] > 0)
949  {
950  fhL1GPatchNotAllFake->Fill(col,row);
951 
952  Double_t patchEnergy = 0;
953  for(Int_t irow = 0; irow < 2; irow++)
954  {
955  for(Int_t icol = 0; icol < 2; icol++)
956  {
957  shiftCol = col+icol;
958  shiftRow = row+irow;
959 
960  if(shiftRow < fgkFALTRORows && shiftCol < fgkFALTROCols)
961  patchEnergy += fMapCellL1G[shiftRow][shiftCol] ;
962  }
963  }
964 
965  fhL1GPatchNotAllFakeE->Fill(patchEnergy);
966 
967  }
968  }
969  }
970 
971  if(fMapTrigL1G[rowMax][colMax] > 0 )
972  {
973  fhL1GPatchNotAllFakeMax ->Fill(colMax,rowMax);
974  fhL1GPatchNotAllFakeMaxE->Fill(patchMax);
975  }
976  }
977 
978  if( fFillV0SigHisto ) fhGPMaxVV0TT->Fill(fV0Trigger, patchMax);
979  if( fEventL1G ) fhL1GPatchMax ->Fill(colMax,rowMax);
980  if( fEventL1G2 ) fhL1G2PatchMax->Fill(colMax,rowMax);
981 }
982 
983 //____________________________________________________________
985 //____________________________________________________________
986 void AliAnalysisTaskEMCALTriggerQA::FillL1JetPatchHistograms()
987 {
988  Double_t patchMax = 0;
989  Int_t colMax = -1;
990  Int_t rowMax = -1;
991  Int_t col, row = 0;
992 
993  for (Int_t i = 0; i < 9; i++)
994  {
995  for (Int_t j = 0; j < 12; j++)
996  {
997  Int_t patchJ = 0;
998  col = i;
999  row = j;
1000 
1001  for (Int_t k = 0; k < 16; k++)
1002  {
1003  for (Int_t l = 0; l < 16; l++)
1004  {
1005  patchJ += Int_t(fMapTrigL1[4*j + l][4*i + k]);
1006  }
1007  }
1008 
1009  if (patchJ > patchMax)
1010  {
1011  patchMax = patchJ;
1012  colMax = 4*col;
1013  rowMax = 4*row;
1014  }
1015  }
1016  }
1017 
1018  if( fFillV0SigHisto ) fhJPMaxVV0TT->Fill(fV0Trigger, patchMax);
1019  if( fEventL1J ) fhL1JPatchMax ->Fill(colMax,rowMax);
1020  if( fEventL1J2 ) fhL1J2PatchMax->Fill(colMax,rowMax);
1021 }
1022 
1023 //______________________________________________________
1025 //______________________________________________________
1026 void AliAnalysisTaskEMCALTriggerQA::FillMapHistograms()
1027 {
1028  for (Int_t i = 0; i < fgkFALTRORows; i++)
1029  {
1030  for (Int_t j = 0; j < fgkFALTROCols; j++) //check x,y direction for reading FOR ((0,0) = top left);
1031  {
1032  fhFORAmp ->Fill( j, i, fMapCell [i][j]);
1033  fhFORAmpL1G ->Fill( j, i, fMapCellL1G [i][j]);
1034  fhFORAmpL1G2->Fill( j, i, fMapCellL1G2 [i][j]);
1035  fhFORAmpL1J ->Fill( j, i, fMapCellL1J [i][j]);
1036  fhFORAmpL1J2->Fill( j, i, fMapCellL1J2 [i][j]);
1037  fhL0Amp ->Fill( j, i, fMapTrigL0 [i][j]);
1038  fhL0AmpL1G ->Fill( j, i, fMapTrigL0L1G[i][j]);
1039  fhL0AmpL1J ->Fill( j, i, fMapTrigL0L1J[i][j]);
1040  fhL1Amp ->Fill( j, i, fMapTrigL1 [i][j]);
1041 
1042  fhL1FOREnergy->Fill(i+fgkFALTRORows*j, fMapTrigL1 [i][j]);
1043  fhL1GAmp ->Fill( j, i, fMapTrigL1G [i][j]);
1044  fhL1G2Amp ->Fill( j, i, fMapTrigL1G2 [i][j]);
1045  fhL1JAmp ->Fill( j, i, fMapTrigL1J [i][j]);
1046  fhL1J2Amp ->Fill( j, i, fMapTrigL1J2 [i][j]);
1047  fhFORMeanAmp->Fill( j, i, fMapCell [i][j]);
1048  fhL0MeanAmp ->Fill( j, i, fMapTrigL0 [i][j]);
1049  fhL1MeanAmp ->Fill( j, i, fMapTrigL1 [i][j]);
1050  }
1051  }
1052 }
1053 
1054 //____________________________________________________
1056 //____________________________________________________
1057 void AliAnalysisTaskEMCALTriggerQA::FillV0Histograms()
1058 {
1059  AliESDVZERO* eventV0 = dynamic_cast<AliESDVZERO*> (InputEvent()->GetVZEROData());
1060 
1061  if(eventV0)
1062  {
1063  for (Int_t i = 0; i < 32; i++)
1064  {
1065  fV0C += eventV0->GetAdcV0C(i);
1066  fV0A += eventV0->GetAdcV0A(i);
1067  }
1068 
1069  if (fSTUTotal != 0 && fFillV0SigHisto)
1070  {
1071  fhV0STU->Fill(fV0A+fV0C,fSTUTotal);
1072 
1073  if( fV0A+fV0C > fMaxV0Signal && DebugLevel() > 0)
1074  AliWarning(Form("Large fV0A+fV0C %f",fV0A+fV0C));
1075  }
1076 
1077  //printf("V0A %f, V0C %f\n",fV0A,fV0C);
1078 
1079  // Not interesting in case of data analysis, REVISE in future
1080  if(fMCData || !fFillV0SigHisto) return ;
1081 
1082  if( fEventL1G ) fhV0[kL1GammaTrig] ->Fill(fV0A+fV0C);
1083  if( fEventL1G2 ) fhV0[kL1GammaTrig2] ->Fill(fV0A+fV0C);
1084  if( fEventL1J ) fhV0[kL1JetTrig] ->Fill(fV0A+fV0C);
1085  if( fEventL1J2 ) fhV0[kL1JetTrig2] ->Fill(fV0A+fV0C);
1086  if( fEventL1GD ) fhV0[kL1GammaTrigD] ->Fill(fV0A+fV0C);
1087  if( fEventL1G2D ) fhV0[kL1GammaTrig2D] ->Fill(fV0A+fV0C);
1088  if( fEventL1JD ) fhV0[kL1JetTrigD] ->Fill(fV0A+fV0C);
1089  if( fEventL1J2D ) fhV0[kL1JetTrig2D] ->Fill(fV0A+fV0C);
1090  if( fEventMB ) fhV0[kMBTrig] ->Fill(fV0A+fV0C);
1091  if( fEventL0 ) fhV0[kL0Trig] ->Fill(fV0A+fV0C);
1092  if( fEventCen ) fhV0[kCentralTrig] ->Fill(fV0A+fV0C);
1093  if( fEventSem ) fhV0[kSemiCentralTrig]->Fill(fV0A+fV0C);
1094  if( fEventL1G && !fEventL1J) fhV0[kL1GammaOnlyTrig] ->Fill(fV0A+fV0C);
1095  if( fEventL1J && !fEventL1G) fhV0[kL1JetOnlyTrig] ->Fill(fV0A+fV0C);
1096  if( fEventL1G2 && !fEventL1G) fhV0[kL1Gamma2OnlyGammaTrig]->Fill(fV0A+fV0C);
1097  if( fEventL1J2 && !fEventL1J) fhV0[kL1Jet2OnlyJetTrig] ->Fill(fV0A+fV0C);
1098  //if(nL0Patch!=0 || nL1Patch!=0) printf("total TRU %f, total STU %f, V0C+V0A %f; nL0 %d, nL1 %d \n",
1099  // fTRUTotal,fSTUTotal,fV0A+fV0C,nL0Patch,nL1Patch);
1100  }
1101 }
1102 
1103 //________________________________________
1105 //________________________________________
1106 void AliAnalysisTaskEMCALTriggerQA::Init()
1107 {
1108  if(!fRecoUtils)
1109  {
1110  fRecoUtils = new AliEMCALRecoUtils ;
1111  fRecoUtils->SwitchOnBadChannelsRemoval();
1112  }
1113 }
1114 
1115 //_____________________________________________________
1118 //_____________________________________________________
1119 void AliAnalysisTaskEMCALTriggerQA::InitCellPatchMaps()
1120 {
1121  for (Int_t i = 0; i < fgkFALTRORows; i++)
1122  {
1123  for (Int_t j = 0; j < fgkFALTROCols; j++)
1124  {
1125  fMapTrigL0 [i][j] = 0.;
1126  fMapTrigL0L1G[i][j] = 0.;
1127  fMapTrigL0L1J[i][j] = 0.;
1128  fMapTrigL1G [i][j] = 0.;
1129  fMapTrigL1G2 [i][j] = 0.;
1130  fMapTrigL1J [i][j] = 0.;
1131  fMapTrigL1J2 [i][j] = 0.;
1132  fMapTrigL1 [i][j] = 0.;
1133  fMapCell [i][j] = 0.;
1134  fMapCellL1G [i][j] = 0.;
1135  fMapCellL1G2 [i][j] = 0.;
1136  fMapCellL1J [i][j] = 0.;
1137  fMapCellL1J2 [i][j] = 0.;
1138  }
1139  }
1140 }
1141 
1142 //________________________________________________
1146 //________________________________________________
1147 void AliAnalysisTaskEMCALTriggerQA::InitGeometry()
1148 {
1149  if(fGeoSet) return;
1150 
1151  // Init the trigger bit once, correct depending on version
1152  fBitEGA = 4;
1153  fBitEJE = 5;
1154 
1155  TFile* file = AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile();
1156 
1157  const TList *clist = file->GetStreamerInfoCache();
1158 
1159  if(clist)
1160  {
1161  TStreamerInfo *cinfo = (TStreamerInfo*)clist->FindObject("AliESDCaloTrigger");
1162  Int_t verid = 5; // newer ESD header version
1163  if(!cinfo)
1164  {
1165  cinfo = (TStreamerInfo*)clist->FindObject("AliAODCaloTrigger");
1166  verid = 3; // newer AOD header version
1167  }
1168  if(cinfo)
1169  {
1170  Int_t classversionid = cinfo->GetClassVersion();
1171  //printf("********* Header class version %d *********** \n",classversionid);
1172 
1173  if (classversionid >= verid)
1174  {
1175  fBitEGA = 6;
1176  fBitEJE = 8;
1177  }
1178  } else AliInfo("Streamer info for trigger class not available, bit not changed");
1179  } else AliInfo("Streamer list not available!, bit not changed");
1180 
1181  Int_t runnumber = InputEvent()->GetRunNumber() ;
1182 
1183  if (!fGeometry)
1184  {
1185  if(fGeoName=="")
1186  {
1187  fGeometry = AliEMCALGeometry::GetInstanceFromRunNumber(runnumber);
1188  AliInfo(Form("Get EMCAL geometry name to <%s> for run %d",fGeometry->GetName(),runnumber));
1189  }
1190  else
1191  {
1192  fGeometry = AliEMCALGeometry::GetInstance(fGeoName);
1193  AliInfo(Form("Set EMCAL geometry name to <%s>",fGeoName.Data()));
1194  }
1195  }
1196 
1197  fGeoSet = kTRUE;
1198 }
1199 
1200 //_______________________________________________________
1202 //_______________________________________________________
1203 void AliAnalysisTaskEMCALTriggerQA::InitHistogramArrays()
1204 {
1205  for (Int_t i = 0; i < fgkTriggerCombi; i++)
1206  {
1207  fhV0 [i] = 0; fhCentrality[i] = 0;
1208  fhClus [i] = 0; fhClusMax [i] = 0;
1209  fhClusCen[i] = 0; fhClusCenMax[i] = 0;
1210  fhClusV0 [i] = 0; fhClusV0Max [i] = 0;
1211  fhClusEta[i] = 0; fhClusEtaMax[i] = 0;
1212  fhClusPhi[i] = 0; fhClusPhiMax[i] = 0;
1213 
1214  fhClusEtaPhiHigh [i] = 0; fhClusEtaPhiHighCluMax [i] = 0;
1215  fhClusEtaPhiHighCellMax[i] = 0; fhClusEtaPhiHighCellMaxCluMax[i] = 0;
1216  fhClusEtaPhiLow [i] = 0; fhClusEtaPhiLowCluMax [i] = 0;
1217  fhClusEtaPhiLowCellMax [i] = 0; fhClusEtaPhiLowCellMaxCluMax [i] = 0;
1218 
1219  if(i<3){ fhClusMBPure[i] = 0; fhClusMaxMBPure[i] = 0; }
1220 
1221  for(Int_t ism = 0; ism < 20; ism++)
1222  {
1223  fhClusSM [i][ism] = 0;
1224  fhClusCenSM[i][ism] = 0;
1225  fhClusV0SM [i][ism] = 0;
1226  }
1227  }
1228 }
1229 
1230 //_____________________________________________________________________________
1232 //_____________________________________________________________________________
1233 void AliAnalysisTaskEMCALTriggerQA::SetTriggerEventBit( TString triggerclasses)
1234 {
1235  // Init trigger event bit
1236 
1237  fEventMB = kFALSE;
1238  fEventL0 = kFALSE;
1239  fEventL1G = kFALSE;
1240  fEventL1G2 = kFALSE;
1241  fEventL1J = kFALSE;
1242  fEventL1J2 = kFALSE;
1243  fEventL0D = kFALSE;
1244  fEventL1GD = kFALSE;
1245  fEventL1G2D= kFALSE;
1246  fEventL1JD = kFALSE;
1247  fEventL1J2D= kFALSE;
1248  fEventCen = kFALSE;
1249  fEventSem = kFALSE;
1250 
1251  // Minimum bias event trigger?
1252  if((triggerclasses.Contains("CINT7") || triggerclasses.Contains("CPBI2_B1") ) &&
1253  (triggerclasses.Contains("-B-") || triggerclasses.Contains("-I-")) &&
1254  triggerclasses.Contains("-NOPF") ) fEventMB = kTRUE;
1255  //triggerclasses.Contains("-NOPF-ALLNOTRD") ) fEventMB = kTRUE;
1256 
1257  //if(triggerclasses.Contains("CINT7-B-NOPF-CENT")) fEventMB = kTRUE;
1258 
1259  if(fMCData && triggerclasses.Contains("MB")) fEventMB = kTRUE;
1260 
1261  // EMC triggered event? Which type?
1262  if( triggerclasses.Contains("-B-") || triggerclasses.Contains("-S-") || triggerclasses.Contains("-I-") )
1263  {
1264  if( triggerclasses.Contains("CEMC") &&
1265  !triggerclasses.Contains("EGA" ) &&
1266  !triggerclasses.Contains("EJE" ) &&
1267  !triggerclasses.Contains("EG1" ) &&
1268  !triggerclasses.Contains("EJ1" ) &&
1269  !triggerclasses.Contains("EG2" ) &&
1270  !triggerclasses.Contains("EJ2" ) ) fEventL0 = kTRUE;
1271 
1272  if( triggerclasses.Contains("CDMC") &&
1273  !triggerclasses.Contains("DGA" ) &&
1274  !triggerclasses.Contains("DJE" ) &&
1275  !triggerclasses.Contains("DG1" ) &&
1276  !triggerclasses.Contains("DJ1" ) &&
1277  !triggerclasses.Contains("DG2" ) &&
1278  !triggerclasses.Contains("DJ2" ) ) fEventL0D = kTRUE;
1279 
1280 
1281  if( triggerclasses.Contains("EGA" ) || triggerclasses.Contains("EG1" ) ) fEventL1G = kTRUE;
1282  if( triggerclasses.Contains("EG2" ) ) fEventL1G2 = kTRUE;
1283 
1284  if( triggerclasses.Contains("DGA" ) || triggerclasses.Contains("DG1" ) ) fEventL1GD = kTRUE;
1285  if( triggerclasses.Contains("DG2" ) ) fEventL1G2D = kTRUE;
1286 
1287  if( triggerclasses.Contains("EJE" ) || triggerclasses.Contains("EJ1" ) ) fEventL1J = kTRUE;
1288  if( triggerclasses.Contains("EJ2" ) ) fEventL1J2 = kTRUE;
1289 
1290  if( triggerclasses.Contains("DJE" ) || triggerclasses.Contains("DJ1" ) ) fEventL1JD = kTRUE;
1291  if( triggerclasses.Contains("DJ2" ) ) fEventL1J2D = kTRUE;
1292  }
1293 
1294  // Semi/Central PbPb trigger
1295  if (triggerclasses.Contains("CCENT_R2-B-NOPF-ALLNOTRD")) fEventCen = kTRUE;
1296  else if(triggerclasses.Contains("CSEMI_R1-B-NOPF-ALLNOTRD")) fEventSem = kTRUE;
1297 
1298 // printf("MB : %d; L0-E : %d; L0-D : %d; L1-EGam1 : %d; L1-DGam1 : %d; "
1299 // "L1-EGam2 : %d; L1-DGam2 : %d;\n L1-EJet1 : %d; L1-DJet1 : %d; L1-EJet2 : %d;L1-DJet2 : %d; "
1300 // "Central : %d; SemiCentral : %d; \n Trigger Names : %s \n ",
1301 // fEventMB,fEventL0,fEventL0D,fEventL1G,fEventL1GD,fEventL1G2,fEventL1G2D,
1302 // fEventL1J,fEventL1JD,fEventL1J2,fEventL1J2D,
1303 // fEventCen,fEventSem,triggerclasses.Data());
1304 }
1305 
1306 //___________________________________________________________
1308 //___________________________________________________________
1309 void AliAnalysisTaskEMCALTriggerQA::UserCreateOutputObjects()
1310 {
1311  fOutputList = new TList;
1312  fOutputList ->SetOwner(kTRUE);
1313 
1314  fhNEvents = new TH1F("hNEvents","Number of selected events",26,0,26);
1315  fhNEvents ->SetYTitle("N events");
1316  fhNEvents ->GetXaxis()->SetBinLabel(1 ,"All");
1317  fhNEvents ->GetXaxis()->SetBinLabel(2 ,"MB");
1318  fhNEvents ->GetXaxis()->SetBinLabel(3 ,"Central Pb");
1319  fhNEvents ->GetXaxis()->SetBinLabel(4 ,"SemiCentral Pb");
1320  fhNEvents ->GetXaxis()->SetBinLabel(5 ,"L0");
1321  fhNEvents ->GetXaxis()->SetBinLabel(6 ,"L1-G1");
1322  fhNEvents ->GetXaxis()->SetBinLabel(7 ,"L1-G2");
1323  fhNEvents ->GetXaxis()->SetBinLabel(8 ,"L1-J1");
1324  fhNEvents ->GetXaxis()->SetBinLabel(9 ,"L1-J2");
1325  fhNEvents ->GetXaxis()->SetBinLabel(10 ,"L1-G1 & !L1-J1");
1326  fhNEvents ->GetXaxis()->SetBinLabel(11 ,"L1-J1 & !L1-G1");
1327  fhNEvents ->GetXaxis()->SetBinLabel(12 ,"L1-J1 & L1-G1");
1328  fhNEvents ->GetXaxis()->SetBinLabel(13 ,"MB & !L1 & !L0");
1329  fhNEvents ->GetXaxis()->SetBinLabel(14,"L0 & !MB");
1330  fhNEvents ->GetXaxis()->SetBinLabel(15,"L1-G1 & !MB");
1331  fhNEvents ->GetXaxis()->SetBinLabel(16,"L1-J1 & !MB");
1332  fhNEvents ->GetXaxis()->SetBinLabel(17,"L1-G1 & (Cen | Semi)");
1333  fhNEvents ->GetXaxis()->SetBinLabel(18,"L1-J1 & (Cen | Semi)");
1334  fhNEvents ->GetXaxis()->SetBinLabel(19,"L1-G2 & !L1-G1");
1335  fhNEvents ->GetXaxis()->SetBinLabel(20,"L1-J2 & !L1-J1");
1336  fhNEvents ->GetXaxis()->SetBinLabel(21,"L0 DCal");
1337  fhNEvents ->GetXaxis()->SetBinLabel(22,"L1-G1 DCal");
1338  fhNEvents ->GetXaxis()->SetBinLabel(23,"L1-J1 DCal");
1339  fhNEvents ->GetXaxis()->SetBinLabel(24,"L0 !DCal");
1340  fhNEvents ->GetXaxis()->SetBinLabel(25,"L1-G1 !DCal");
1341  fhNEvents ->GetXaxis()->SetBinLabel(26,"L1-J1 !DCal");
1342 
1343  fhFORAmp = new TH2F("hFORAmp", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column",
1344  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1345  fhFORAmp ->SetXTitle("Index #eta (columnns)");
1346  fhFORAmp ->SetYTitle("Index #phi (rows)");
1347  fhFORAmp ->SetZTitle("Amplitude");
1348 
1349  fhFORAmpL1G = new TH2F("hFORAmpL1G1", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1G1 trigger condition",
1350  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1351  fhFORAmpL1G ->SetXTitle("Index #eta (columnns)");
1352  fhFORAmpL1G ->SetYTitle("Index #phi (rows)");
1353  fhFORAmpL1G ->SetZTitle("Amplitude");
1354 
1355  fhFORAmpL1G2 = new TH2F("hFORAmpL1G2", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1G2 trigger condition",
1356  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1357  fhFORAmpL1G2 ->SetXTitle("Index #eta (columnns)");
1358  fhFORAmpL1G2 ->SetYTitle("Index #phi (rows)");
1359  fhFORAmpL1G2 ->SetZTitle("Amplitude");
1360 
1361  fhFORAmpL1J = new TH2F("hFORAmpL1J1", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1J1 trigger condition",
1362  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1363  fhFORAmpL1J ->SetXTitle("Index #eta (columnns)");
1364  fhFORAmpL1J ->SetYTitle("Index #phi (rows)");
1365  fhFORAmpL1J ->SetZTitle("Amplitude");
1366 
1367  fhFORAmpL1J2 = new TH2F("hFORAmpL1J2", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1J2 trigger condition",
1368  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1369  fhFORAmpL1J2 ->SetXTitle("Index #eta (columnns)");
1370  fhFORAmpL1J2 ->SetYTitle("Index #phi (rows)");
1371  fhFORAmpL1J2 ->SetZTitle("Amplitude");
1372 
1373 
1374  fhL0Amp = new TH2F("hL0Amp","FALTRO signal per Row and Column",
1375  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1376  fhL0Amp ->SetXTitle("Index #eta (columnns)");
1377  fhL0Amp ->SetYTitle("Index #phi (rows)");
1378  fhL0Amp ->SetZTitle("Amplitude");
1379 
1380  fhL0AmpL1G = new TH2F("hL0AmpL1G","FALTRO signal per Row and Column, with L1G trigger condition",
1381  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1382  fhL0AmpL1G ->SetXTitle("Index #eta (columnns)");
1383  fhL0AmpL1G ->SetYTitle("Index #phi (rows)");
1384  fhL0AmpL1G ->SetZTitle("Amplitude");
1385 
1386 
1387  fhL0AmpL1J = new TH2F("hL0AmpL1J","FALTRO signal per Row and Column, with L1j trigger condition",
1388  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1389  fhL0AmpL1J ->SetXTitle("Index #eta (columnns)");
1390  fhL0AmpL1J ->SetYTitle("Index #phi (rows)");
1391  fhL0AmpL1J ->SetZTitle("Amplitude");
1392 
1393 
1394  fhL1Amp = new TH2F("hL1Amp","STU signal per Row and Column",
1395  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1396  fhL1Amp ->SetXTitle("Index #eta (columnns)");
1397  fhL1Amp ->SetYTitle("Index #phi (rows)");
1398  fhL1Amp ->SetZTitle("Amplitude");
1399 
1400  fhL1GAmp = new TH2F("hL1G1Amp","STU signal per Row and Column for L1 Gamma1",
1401  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1402  fhL1GAmp ->SetXTitle("Index #eta (columnns)");
1403  fhL1GAmp ->SetYTitle("Index #phi (rows)");
1404  fhL1GAmp ->SetZTitle("Amplitude");
1405 
1406  fhL1G2Amp = new TH2F("hL1G2Amp","STU signal per Row and Column for L1 Gamma2",
1407  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1408  fhL1G2Amp ->SetXTitle("Index #eta (columnns)");
1409  fhL1G2Amp ->SetYTitle("Index #phi (rows)");
1410  fhL1G2Amp ->SetZTitle("Amplitude");
1411 
1412  fhL1JAmp = new TH2F("hL1J1Amp","STU signal per Row and Column for L1 Jet1",
1413  fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
1414  fhL1JAmp ->SetXTitle("Index #eta (columnns)");
1415  fhL1JAmp ->SetYTitle("Index #phi (rows)");
1416  fhL1JAmp ->SetZTitle("Amplitude");
1417 
1418  fhL1J2Amp = new TH2F("hL1J2Amp","STU signal per Row and Column for L1 Jet2",
1419  fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
1420  fhL1J2Amp ->SetXTitle("Index #eta (columnns)");
1421  fhL1J2Amp ->SetYTitle("Index #phi (rows)");
1422  fhL1J2Amp ->SetZTitle("Amplitude");
1423 
1424  fhL1FOREnergy = new TH2F("hL1FOREnergy","FOR index vs FOR energy",
1425  fgkFALTROCols*fgkFALTRORows,0,fgkFALTROCols*fgkFALTRORows,200,0,200);
1426  fhL1FOREnergy ->SetXTitle("Index FOR");
1427  fhL1FOREnergy ->SetYTitle("Energy (ADC)");
1428 
1429  fhL0Patch = new TH2F("hL0Patch","FOR with associated L0 Patch",
1430  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1431  fhL0Patch ->SetXTitle("Index #eta (columnns)");
1432  fhL0Patch ->SetYTitle("Index #phi (rows)");
1433  fhL0Patch ->SetZTitle("counts");
1434 
1435  fhL1GPatch = new TH2F("hL1G1Patch","FOR with associated L1 Gamma Patch1",
1436  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1437  fhL1GPatch ->SetXTitle("Index #eta (columnns)");
1438  fhL1GPatch ->SetYTitle("Index #phi (rows)");
1439  fhL1GPatch ->SetZTitle("counts");
1440 
1441  fhL1G2Patch = new TH2F("hL1G2Patch","FOR with associated L1 Gamma2 Patch",
1442  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1443  fhL1G2Patch ->SetXTitle("Index #eta (columnns)");
1444  fhL1G2Patch ->SetYTitle("Index #phi (rows)");
1445  fhL1G2Patch ->SetZTitle("counts");
1446 
1447  fhL1GPatchNotFake = new TH2F("hL1G1PatchNotFake","FOR with L1 Gamma1 Patch associated to energetic cells",
1448  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1449  fhL1GPatchNotFake ->SetXTitle("Index #eta (columnns)");
1450  fhL1GPatchNotFake ->SetYTitle("Index #phi (rows)");
1451  fhL1GPatchNotFake ->SetZTitle("counts");
1452 
1453  fhL1GPatchFake = new TH2F("hL1G1PatchFake","FOR without L1 Gamma1 Patch associated to energetic cells",
1454  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1455  fhL1GPatchFake ->SetXTitle("Index #eta (columnns)");
1456  fhL1GPatchFake ->SetYTitle("Index #phi (rows)");
1457  fhL1GPatchFake ->SetZTitle("counts");
1458 
1459 
1460  fhL1GPatchNotAllFake = new TH2F("hL1G1PatchNotAllFake","FOR with one L1 Gamma1 Patch associated to an energetic cell",
1461  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1462  fhL1GPatchNotAllFake ->SetXTitle("Index #eta (columnns)");
1463  fhL1GPatchNotAllFake ->SetYTitle("Index #phi (rows)");
1464  fhL1GPatchNotAllFake ->SetZTitle("counts");
1465 
1466  fhL1GPatchAllFake = new TH2F("hL1G1PatchAllFake","FOR without any L1 Gamma1 Patch associated to an energetic cell",
1467  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1468  fhL1GPatchAllFake ->SetXTitle("Index #eta (columnns)");
1469  fhL1GPatchAllFake ->SetYTitle("Index #phi (rows)");
1470  fhL1GPatchAllFake ->SetZTitle("counts");
1471 
1472  fhL1GPatchAllFakeMax = new TH2F("hL1G1PatchAllFakeMax","FOR with L1 Gamma1 Patch Max not associated to an energetic cell",
1473  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1474  fhL1GPatchAllFakeMax ->SetXTitle("Index #eta (columnns)");
1475  fhL1GPatchAllFakeMax ->SetYTitle("Index #phi (rows)");
1476  fhL1GPatchAllFakeMax ->SetZTitle("counts");
1477 
1478  fhL1GPatchNotAllFakeMax = new TH2F("hL1G1PatchNotAllFakeMax","FOR with one L1 Gamma1 Patch Max associated to an energetic cell",
1479  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1480  fhL1GPatchNotAllFakeMax ->SetXTitle("Index #eta (columnns)");
1481  fhL1GPatchNotAllFakeMax ->SetYTitle("Index #phi (rows)");
1482  fhL1GPatchNotAllFakeMax ->SetZTitle("counts");
1483 
1484  fhL1GPatchNotAllFakeMaxE = new TH1F("hL1G1PatchNotAllFakeMaxE","Energy distribution of FOR in events with L1 Gamma1 Patch Max associated to an energetic cell",
1485  fNBinsClusterE,0,fMaxClusterE);
1486  fhL1GPatchNotAllFakeMaxE ->SetXTitle("Energy (GeV)");
1487 
1488 
1489  fhL1GPatchAllFakeMaxE = new TH1F("hL1G1PatchAllFakeMaxE","Energy distribution of FOR in events with L1 Gamma1 Patch Max not associated to an energetic cell",
1490  fNBinsClusterE,0,fMaxClusterE);
1491  fhL1GPatchAllFakeMaxE ->SetXTitle("Energy (GeV)");
1492 
1493  fhL1GPatchNotAllFakeE = new TH1F("hL1G1PatchNotAllFakeE","Energy distribution of FOR in events with L1 Gamma1 Patch not associated to an energetic cell",
1494  fNBinsClusterE,0,fMaxClusterE);
1495  fhL1GPatchNotAllFakeE ->SetXTitle("Energy (GeV)");
1496 
1497  fhL1GPatchAllFakeE = new TH1F("hL1G1PatchAllFakeE","Energy distribution of FOR in events with L1 Gamma1 Patch associated to an energetic cell",
1498  fNBinsClusterE,0,fMaxClusterE);
1499  fhL1GPatchAllFakeE ->SetXTitle("Energy (GeV)");
1500 
1501 
1502  fhL1GPatchFakeE = new TH1F("hL1G1PatchFakeE","Energy distribution of FOR with L1 Gamma1 Patch not associated to an energetic cell",
1503  fNBinsClusterE,0,fMaxClusterE);
1504  fhL1GPatchFakeE ->SetXTitle("Energy (GeV)");
1505 
1506  fhL1GPatchNotFakeE = new TH1F("hL1G1PatchNotFakeE","Energy distribution of FOR with L1 Gamma1 Patch associated to an energetic cell",
1507  fNBinsClusterE,0,fMaxClusterE);
1508  fhL1GPatchNotFakeE ->SetXTitle("Energy (GeV)");
1509 
1510  fhNPatchFake = new TH2F("hNPatchFake","number of fake patchs vs. all patchs are fake",
1511  3,0,3, 2880,0,2880);
1512  fhNPatchFake ->SetYTitle("number of fake patchs");
1513  fhNPatchFake ->SetXTitle("all fake event");
1514  fhNPatchFake ->SetZTitle("counts");
1515 
1516 
1517  fhNPatchNotFake = new TH2F("hNPatchNotFake","number of Not fake patchs vs. all patchs are fake",
1518  3, 0, 3, 200,0,1000);
1519  fhNPatchNotFake ->SetYTitle("number of Not fake patchs");
1520  fhNPatchNotFake ->SetXTitle("all fake event");
1521  fhNPatchNotFake ->SetZTitle("counts");
1522 
1523 
1524  fhL1JPatch = new TH2F("hL1J1Patch","FOR with associated L1 Jet1 Patch",
1525  fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
1526  fhL1JPatch ->SetXTitle("Index #eta (columnns)");
1527  fhL1JPatch ->SetYTitle("Index #phi (rows)");
1528  fhL1JPatch ->SetZTitle("counts");
1529 
1530  fhL1J2Patch = new TH2F("hL1J2Patch","FOR with associated L1 Jet2 Patch",
1531  fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
1532  fhL1J2Patch ->SetXTitle("Index #eta (columnns)");
1533  fhL1J2Patch ->SetYTitle("Index #phi (rows)");
1534  fhL1J2Patch ->SetZTitle("counts");
1535 
1536  // Uncomment when corresponding method is active
1537 // fhFEESTU = new TH2F("hFEESTU","STU / FEE vs channel", fNBinsSTUFEERatio,0,fMaxSTUFEERatio,30,0,30);
1538 // fhFEESTU ->SetXTitle("STU/FEE signal");
1539 // fhFEESTU ->SetYTitle("channel");
1540 // fhFEESTU ->SetZTitle("counts");
1541 //
1542 // fhTRUSTU = new TH2F("hTRUSTU","STU / TRU vs channel", fNBinsSTUTRURatio,0,fMaxSTUTRURatio,30,0,30);
1543 // fhTRUSTU ->SetXTitle("STU/TRU signal");
1544 // fhTRUSTU ->SetYTitle("channel");
1545 // fhTRUSTU ->SetZTitle("counts");
1546 
1547  fhFORMeanAmp = new TProfile2D("hFORMeanAmp", "Mean FastOR(FEE) signal per Row and Column", fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1548  fhFORMeanAmp->SetXTitle("Index #eta");
1549  fhFORMeanAmp->SetYTitle("Index #phi");
1550 
1551  fhL0MeanAmp = new TProfile2D("hL0MeanAmp", "Mean FastOR(TRU) signal per Row and Column", fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1552  fhL0MeanAmp->SetXTitle("Index #eta");
1553  fhL0MeanAmp->SetYTitle("Index #phi");
1554 
1555  fhL1MeanAmp = new TProfile2D("hL1MeanAmp", "Mean FastOR(STU) signal per Row and Column", fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1556  fhL1MeanAmp->SetXTitle("Index #eta");
1557  fhL1MeanAmp->SetYTitle("Index #phi");
1558 
1559  fhL1GPatchMax = new TH2F("hL1G1PatchMax","FOR of max amplitude patch with associated L1 Gamma1 Patch",
1560  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1561  fhL1GPatchMax ->SetXTitle("Index #eta (columnns)");
1562  fhL1GPatchMax ->SetYTitle("Index #phi (rows)");
1563  fhL1GPatchMax ->SetZTitle("counts");
1564 
1565  fhL1G2PatchMax = new TH2F("hL1G2PatchMax","FOR of max amplitude patch with associated L1 Gamma2 Patch",
1566  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1567  fhL1G2PatchMax ->SetXTitle("Index #eta (columnns)");
1568  fhL1G2PatchMax ->SetYTitle("Index #phi (rows)");
1569  fhL1G2PatchMax ->SetZTitle("counts");
1570 
1571  fhL1JPatchMax = new TH2F("hL1J1PatchMax","FOR of max amplitude patch with associated L1 Jet1 Patch",
1572  fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
1573  fhL1JPatchMax ->SetXTitle("Index #eta (columnns)");
1574  fhL1JPatchMax ->SetYTitle("Index #phi (rows)");
1575  fhL1JPatchMax ->SetZTitle("counts");
1576 
1577  fhL1J2PatchMax = new TH2F("hL1J2PatchMax","FOR of max amplitude patch with associated L1 Jet2 Patch",
1578  fgkFALTROCols/4,0,fgkFALTROCols,fgkFALTRORows/4,0,fgkFALTRORows);
1579  fhL1J2PatchMax ->SetXTitle("Index #eta (columnns)");
1580  fhL1J2PatchMax ->SetYTitle("Index #phi (rows)");
1581  fhL1J2PatchMax ->SetZTitle("counts");
1582 
1583  fOutputList->Add(fhNEvents);
1584  fOutputList->Add(fhFORAmp);
1585  fOutputList->Add(fhFORAmpL1G);
1586  fOutputList->Add(fhFORAmpL1G2);
1587  fOutputList->Add(fhFORAmpL1J);
1588  fOutputList->Add(fhFORAmpL1J2);
1589  fOutputList->Add(fhL0Amp);
1590  fOutputList->Add(fhL0AmpL1G);
1591  fOutputList->Add(fhL0AmpL1J);
1592  fOutputList->Add(fhL1Amp);
1593  fOutputList->Add(fhL1GAmp);
1594  fOutputList->Add(fhL1G2Amp);
1595  fOutputList->Add(fhL1JAmp);
1596  fOutputList->Add(fhL1J2Amp);
1597  fOutputList->Add(fhL1FOREnergy);
1598  fOutputList->Add(fhL0Patch);
1599  fOutputList->Add(fhL1GPatch);
1600  fOutputList->Add(fhL1G2Patch);
1601  fOutputList->Add(fhL1GPatchNotFake);
1602  fOutputList->Add(fhL1GPatchFake);
1603  fOutputList->Add(fhL1GPatchAllFake);
1604  fOutputList->Add(fhL1GPatchNotAllFake);
1605  fOutputList->Add(fhL1GPatchNotAllFakeMax);
1606  fOutputList->Add(fhL1GPatchAllFakeMax);
1607  fOutputList->Add(fhL1GPatchNotAllFakeMaxE);
1608  fOutputList->Add(fhL1GPatchAllFakeMaxE);
1609  fOutputList->Add(fhL1GPatchNotAllFakeE);
1610  fOutputList->Add(fhL1GPatchAllFakeE);
1611  fOutputList->Add(fhL1GPatchFakeE);
1612  fOutputList->Add(fhL1GPatchNotFakeE);
1613  fOutputList->Add(fhNPatchFake);
1614  fOutputList->Add(fhNPatchNotFake);
1615 
1616  fOutputList->Add(fhL1JPatch);
1617  fOutputList->Add(fhL1J2Patch);
1618 
1619  // Uncomment when corresponding method is active
1620 // fOutputList->Add(fhFEESTU);
1621 // fOutputList->Add(fhTRUSTU);
1622 
1623  fOutputList->Add(fhFORMeanAmp);
1624  fOutputList->Add(fhL0MeanAmp);
1625  fOutputList->Add(fhL1MeanAmp);
1626 
1627  fOutputList->Add(fhL1GPatchMax);
1628  fOutputList->Add(fhL1G2PatchMax);
1629  fOutputList->Add(fhL1JPatchMax);
1630  fOutputList->Add(fhL1J2PatchMax);
1631 
1632  if(fFillV0SigHisto)
1633  {
1634  fhV0STU = new TH2I("hV0STU","Total signal STU vs V0C+V0S",
1635  fNBinsV0Signal,0,fMaxV0Signal,fNBinsSTUSignal,0,fMaxSTUSignal);
1636  fhV0STU ->SetXTitle("Signal V0C+V0A");
1637  fhV0STU ->SetYTitle("Total signal STU");
1638  fhV0STU ->SetZTitle("counts");
1639 
1640  fhGPMaxVV0TT = new TH2F("hGPMaxVV0TT","Maximum patch of L1-Gamma vs V0 signal in STU",fNBinsV0Signal,0,fMaxV0Signal, 500,0,1000);
1641  fhGPMaxVV0TT ->SetXTitle("V0 from STU");
1642  fhGPMaxVV0TT ->SetYTitle("Patch Max");
1643 
1644  fhJPMaxVV0TT = new TH2F("hJPMaxVV0TT","Maximum patch of L1-Jet vs V0 signal in STU",fNBinsV0Signal,0,fMaxV0Signal, 500,0,1000);
1645  fhJPMaxVV0TT ->SetXTitle("V0 from STU");
1646  fhJPMaxVV0TT ->SetYTitle("Patch Max");
1647 
1648  fOutputList->Add(fhV0STU);
1649  fOutputList->Add(fhGPMaxVV0TT);
1650  fOutputList->Add(fhJPMaxVV0TT);
1651  }
1652 
1653  if(fMCData)
1654  {
1655  PostData(1, fOutputList);
1656  return;
1657  }
1658 
1659  // Cluster histograms, E
1660  TString hName [] = { "MB","L0","L0D",
1661  "L1G1","L1G1D","L1G2","L1G2D",
1662  "L1J1","L1J1D","L1J2","L2J2D",
1663  "L1G1NoL1J1","L1G1NoL1J1D","L1J1NoL1G1","L1J1NoL1G1D",
1664  "L1G2NoL1G1","L1G2NoL1G1D","L1J2NoL1J1","L1J2NoL1J1D",
1665  "L0E","L0D","L1EG1","L1DG1","L1EJ1","L1DJ1",
1666  "Central","SemiCentral" } ;
1667  TString hTitle [] = { "MB trigger","EMC-L0 trigger","DMC L0 trigger",
1668  "EMC-L1 Gamma1 trigger","EMC-L1 Gamma1 trigger", "EMC-L1 Gamma2 trigger","EMC-L1 Gamma2 trigger",
1669  "EMC-L1 Jet1 trigger" ,"DMC-L1 Jet1 trigger" , "DMC-L1 Jet2 trigger" ,"DMC-L1 Jet2 trigger",
1670  "EMC-L1 Gamma1 trigger and not L1 Jet1", "DMC-L1 Gamma1 trigger and not L1 Jet1",
1671  "EMC-L1 Jet1 trigger and not L1 Gamma1", "DMC-L1 Jet1 trigger and not L1 Gamma1",
1672  "EMC-L1 Gamma2 trigger and not L1 Gamma1","DMC-L1 Gamma2 trigger and not L1 Gamma1",
1673  "EMC-L1 Jet2 trigger and not L1 Jet1", "DMC-L1 Jet2 trigger and not L1 Jet1",
1674  "L0 EMC Pure", "L0 DMC Pure", "L1-Gamma1 EMC Pure", "L1-Gamma1 DMC Pure",
1675  "L1-Jet EMC Pure", "L1-Jet DMC Pure"
1676  "Central trigger","SemiCentral trigger" } ;
1677 
1678  for(Int_t i=0; i < 3; i++)
1679  {
1680  Int_t j = i+5;
1681  if(i==0)j=0;
1682 
1683  fhClusMBPure[i] = new TH1F(Form("hClus%sPure",hName[j].Data()),
1684  Form("clusters E distribution for %s, no other EMCAL trigger on",hTitle[j].Data()),
1685  fNBinsClusterE,0,fMaxClusterE);
1686  fhClusMBPure[i] ->SetXTitle("Energy (GeV)");
1687  fOutputList->Add(fhClusMBPure[i]);
1688 
1689  fhClusMaxMBPure[i] = new TH1F(Form("hClusMax%sPure",hName[j].Data()),
1690  Form("maximum energy cluster per event for %s, no other EMCAL trigger on",hTitle[j].Data()),
1691  fNBinsClusterE,0,fMaxClusterE);
1692  fhClusMaxMBPure[i] ->SetXTitle("Energy (GeV)");
1693  fOutputList->Add(fhClusMaxMBPure[i]);
1694  }
1695 
1696  for(Int_t i=0; i < fgkTriggerCombi; i++)
1697  {
1698  if(fFillV0SigHisto)
1699  {
1700  fhV0[i] = new TH1F(Form("hV0%s",hName[i].Data()),
1701  Form("V0 distribution for %s",hTitle[i].Data()),
1702  fNBinsV0Signal,0,fMaxV0Signal);
1703  fhV0[i]->SetXTitle("V0");
1704  fOutputList->Add(fhV0[i]);
1705  }
1706 
1707  fhClus[i] = new TH1F(Form("hClus%s",hName[i].Data()),
1708  Form("clusters E distribution for %s",hTitle[i].Data()),
1709  fNBinsClusterE,0,fMaxClusterE);
1710  fhClus[i] ->SetXTitle("Energy (GeV)");
1711  fOutputList->Add(fhClus[i]);
1712 
1713  fhClusMax[i] = new TH1F(Form("hClusMax%s",hName[i].Data()),
1714  Form("maximum energy cluster per event for %s",hTitle[i].Data()),
1715  fNBinsClusterE,0,fMaxClusterE);
1716  fhClusMax[i]->SetXTitle("Energy (GeV)");
1717  fOutputList->Add(fhClusMax[i]);
1718 
1719  // Cluster histograms, E vs Cen
1720 
1721  if(fFillCenHisto)
1722  {
1723 
1724  fhCentrality[i] = new TH1F(Form("hCentrality%s",hName[i].Data()),
1725  Form("Centrality distribution for %s",hTitle[i].Data()),
1726  100, 0, 100);
1727  fhCentrality[i]->SetXTitle("Centrality (%)");
1728  fOutputList->Add(fhCentrality[i]);
1729 
1730  fhClusCen[i] = new TH2F(Form("hClusCen%s",hName[i].Data()),
1731  Form("clusters E distribution vs centrality for %s",hTitle[i].Data()),
1732  fNBinsClusterE,0,fMaxClusterE,100, 0, 100);
1733  fhClusCen[i] ->SetXTitle("Energy (GeV)");
1734  fhClusCen[i] ->SetYTitle("Centrality (%)");
1735  fOutputList->Add(fhClusCen[i]);
1736 
1737  fhClusCenMax[i] = new TH2F(Form("hClusCenMax%s",hName[i].Data()),
1738  Form("maximum energy cluster per event vs centrality for %s",hTitle[i].Data()),
1739  fNBinsClusterE,0,fMaxClusterE,100, 0, 100);
1740  fhClusCenMax[i]->SetXTitle("Energy (GeV)");
1741  fhClusCenMax[i]->SetYTitle("Centrality (%)");
1742  fOutputList->Add(fhClusCenMax[i]);
1743  }
1744 
1745  // Cluster histograms, E vs V0
1746 
1747  if(fFillV0SigHisto)
1748  {
1749  fhClusV0[i] = new TH2F(Form("hClusV0%s",hName[i].Data()),
1750  Form("clusters E distribution vs V0 for %s",hTitle[i].Data()),
1751  fNBinsClusterE,0,fMaxClusterE,fNBinsV0Signal,0,fMaxV0Signal);
1752  fhClusV0[i] ->SetXTitle("Energy (GeV)");
1753  fhClusV0[i] ->SetYTitle("V0");
1754  fOutputList->Add(fhClusV0[i]);
1755 
1756  fhClusV0Max[i] = new TH2F(Form("hClusV0Max%s",hName[i].Data()),
1757  Form("maximum energy cluster per event vs V0 for %s",hTitle[i].Data()),
1758  fNBinsClusterE,0,fMaxClusterE,fNBinsV0Signal,0,fMaxV0Signal);
1759  fhClusV0Max[i]->SetXTitle("Energy (GeV)");
1760  fhClusV0Max[i]->SetYTitle("V0");
1761  fOutputList->Add(fhClusV0Max[i]);
1762  }
1763 
1764  // SM dependent histograms
1765  for(Int_t ism = fFirstSM; ism <= fLastSM; ism++)
1766  {
1767  fhClusSM[i][ism] = new TH1F(Form("hClus%s_SM%d",hName[i].Data(),ism),
1768  Form("clusters E distribution for %s and SM%d",hTitle[i].Data(), ism),
1769  fNBinsClusterE,0,fMaxClusterE);
1770  fhClusSM[i][ism]->SetXTitle("Energy (GeV)");
1771  fOutputList->Add(fhClusSM[i][ism]);
1772 
1773  if(fFillCenHisto)
1774  {
1775  fhClusCenSM[i][ism] = new TH2F(Form("hClusCen%s_SM%d",hName[i].Data(),ism),
1776  Form("clusters E distribution vs centrality for %s and SM%d",hTitle[i].Data(),ism),
1777  fNBinsClusterE,0,fMaxClusterE,100, 0, 100);
1778  fhClusCenSM[i][ism]->SetXTitle("Energy (GeV)");
1779  fhClusCenSM[i][ism]->SetYTitle("Centrality");
1780  fOutputList->Add(fhClusCenSM[i][ism] );
1781  }
1782 
1783  if(fFillV0SigHisto)
1784  {
1785  fhClusV0SM[i][ism] = new TH2F(Form("hClusV0%s_SM%d",hName[i].Data(),ism),
1786  Form("clusters E distribution vs V0 for %s and SM%d",hTitle[i].Data(),ism),
1787  fNBinsClusterE,0,fMaxClusterE,fNBinsV0Signal,0,fMaxV0Signal);
1788  fhClusV0SM[i][ism]->SetXTitle("Energy (GeV)");
1789  fhClusV0SM[i][ism]->SetYTitle("V0");
1790  fOutputList->Add(fhClusV0SM[i][ism] );
1791  }
1792  }
1793 
1794  // Cluster histograms, Pseudorapidity vs Azimuthal angle
1795 
1796  fhClusEtaPhiHigh[i] = new TH2F(Form("hClusEtaPhiHigh%s",hName[i].Data()),
1797  Form("clusters distribution #eta vs #phi for %s, E > %1.1f GeV",hTitle[i].Data(),fEtaPhiEnMin),
1798  fNBinsClusterEta, -fMaxClusterEta, fMaxClusterEta, fNBinsClusterPhi, fMinClusterPhi, fMaxClusterPhi);
1799  fhClusEtaPhiHigh[i] ->SetXTitle("#eta");
1800  fhClusEtaPhiHigh[i] ->SetYTitle("#phi (rad)");
1801  fOutputList->Add(fhClusEtaPhiHigh[i]);
1802 
1803  fhClusEtaPhiLow[i] = new TH2F(Form("hClusEtaPhiLow%s",hName[i].Data()),
1804  Form("clusters distribution #eta vs #phi for %s, E < %1.1f GeV",hTitle[i].Data(),fEtaPhiEnMin),
1805  fNBinsClusterEta, -fMaxClusterEta, fMaxClusterEta, fNBinsClusterPhi, fMinClusterPhi, fMaxClusterPhi);
1806  fhClusEtaPhiLow[i] ->SetXTitle("#eta");
1807  fhClusEtaPhiLow[i] ->SetYTitle("#phi (rad)");
1808  fOutputList->Add(fhClusEtaPhiLow[i]);
1809 
1810  if(fFillClusAcceptHisto)
1811  {
1812  fhClusEtaPhiHighCluMax[i] = new TH2F(Form("hClusEtaPhiHighCluMax%s",hName[i].Data()),
1813  Form("maximum energy cluster per event #eta vs #phi for %s, E > %1.1f GeV",hTitle[i].Data(),fEtaPhiEnMin),
1814  fNBinsClusterEta, -fMaxClusterEta, fMaxClusterEta, fNBinsClusterPhi, fMinClusterPhi, fMaxClusterPhi);
1815  fhClusEtaPhiHighCluMax[i]->SetXTitle("#eta");
1816  fhClusEtaPhiHighCluMax[i]->SetYTitle("#phi (rad)");
1817  fOutputList->Add(fhClusEtaPhiHighCluMax[i]);
1818 
1819  fhClusEtaPhiLowCluMax[i] = new TH2F(Form("hClusEtaPhiLowCluMax%s",hName[i].Data()),
1820  Form("maximum energy cluster per event #eta vs #phi for %s, E < %1.1f GeV",hTitle[i].Data(),fEtaPhiEnMin),
1821  fNBinsClusterEta, -fMaxClusterEta, fMaxClusterEta, fNBinsClusterPhi, fMinClusterPhi, fMaxClusterPhi);
1822  fhClusEtaPhiLowCluMax[i]->SetXTitle("#eta");
1823  fhClusEtaPhiLowCluMax[i]->SetYTitle("#phi (rad)");
1824  fOutputList->Add(fhClusEtaPhiLowCluMax[i]);
1825 
1826  fhClusEtaPhiHighCellMax[i] = new TH2F(Form("hClusEtaPhiHighCellMax%s",hName[i].Data()),
1827  Form("Cluster hit map in calorimeter (max cell), column vs row for %s, E > %1.1f GeV",hTitle[i].Data(),fEtaPhiEnMin),
1828  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1829  fhClusEtaPhiHighCellMax[i] ->SetXTitle("Index #eta (columnns)");
1830  fhClusEtaPhiHighCellMax[i] ->SetYTitle("Index #phi (rows)");
1831  fOutputList->Add(fhClusEtaPhiHighCellMax[i]);
1832 
1833  fhClusEtaPhiHighCellMaxCluMax[i] = new TH2F(Form("hClusEtaPhiHighCellMaxCluMax%s",hName[i].Data()),
1834  Form("Max E cluster hit map in calorimeter (max cell), column vs row for %s, E > %1.1f GeV",
1835  hTitle[i].Data(),fEtaPhiEnMin),fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1836  fhClusEtaPhiHighCellMaxCluMax[i]->SetXTitle("Index #eta (columnns)");
1837  fhClusEtaPhiHighCellMaxCluMax[i]->SetYTitle("Index #phi (rows)");
1838  fOutputList->Add(fhClusEtaPhiHighCellMaxCluMax[i]);
1839 
1840  fhClusEtaPhiLowCellMax[i] = new TH2F(Form("hClusEtaPhiLowCellMax%s",hName[i].Data()),
1841  Form("Cluster hit map in calorimeter (max cell), column vs row for %s, E < %1.1f GeV",hTitle[i].Data(),fEtaPhiEnMin),
1842  fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1843  fhClusEtaPhiLowCellMax[i] ->SetXTitle("Index #eta (columnns)");
1844  fhClusEtaPhiLowCellMax[i] ->SetYTitle("#phi (rad)");
1845  fOutputList->Add(fhClusEtaPhiLowCellMax[i]);
1846 
1847  fhClusEtaPhiLowCellMaxCluMax[i] = new TH2F(Form("hClusEtaPhiLowCellMaxCluMax%s",hName[i].Data()),
1848  Form("Max E cluster hit map in calorimeter (max cell), column vs row for %s, E < %1.1f GeV",
1849  hTitle[i].Data(),fEtaPhiEnMin),fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
1850  fhClusEtaPhiLowCellMaxCluMax[i]->SetXTitle("Index #eta (columnns)");
1851  fhClusEtaPhiLowCellMaxCluMax[i]->SetYTitle("#phi (rad)");
1852  fOutputList->Add(fhClusEtaPhiLowCellMaxCluMax[i]);
1853 
1854  // Cluster histograms, E vs Pseudorapidity
1855 
1856  fhClusEta[i] = new TH2F(Form("hClusEta%s",hName[i].Data()),
1857  Form("clusters distribution vs #eta for %s",hTitle[i].Data()),
1858  fNBinsClusterE,0,fMaxClusterE,fNBinsClusterEta, -fMaxClusterEta, fMaxClusterEta);
1859  fhClusEta[i] ->SetXTitle("Energy (GeV)");
1860  fhClusEta[i] ->SetYTitle("#eta");
1861  fOutputList->Add(fhClusEta[i]);
1862 
1863  fhClusEtaMax[i] = new TH2F(Form("hClusEtaMax%s",hName[i].Data()),
1864  Form("maximum energy cluster per event vs #eta for %s",hTitle[i].Data()),
1865  fNBinsClusterE,0,fMaxClusterE,fNBinsClusterEta, -fMaxClusterEta, fMaxClusterEta);
1866  fhClusEtaMax[i]->SetXTitle("Energy (GeV)");
1867  fhClusEtaMax[i]->SetYTitle("#eta");
1868  fOutputList->Add(fhClusEtaMax[i]);
1869 
1870  // Cluster histograms, E vs Azimuthal angle
1871 
1872  fhClusPhi[i] = new TH2F(Form("hClusPhi%s",hName[i].Data()),
1873  Form("clusters distribution vs #phi for %s",hTitle[i].Data()),
1874  fNBinsClusterE,0,fMaxClusterE, fNBinsClusterPhi, fMinClusterPhi, fMaxClusterPhi);
1875  fhClusPhi[i] ->SetXTitle("Energy (GeV)");
1876  fhClusPhi[i] ->SetYTitle("#phi (rad)");
1877  fOutputList->Add(fhClusPhi[i]);
1878 
1879  fhClusPhiMax[i] = new TH2F(Form("hClusPhiMax%s",hName[i].Data()),
1880  Form("maximum energy cluster per event vs #phi for %s",hTitle[i].Data()),
1881  fNBinsClusterE,0,fMaxClusterE, fNBinsClusterPhi, fMinClusterPhi, fMaxClusterPhi);
1882  fhClusPhiMax[i]->SetXTitle("Energy (GeV)");
1883  fhClusPhiMax[i]->SetYTitle("#phi (rad)");
1884  fOutputList->Add(fhClusPhiMax[i]);
1885  }
1886  }
1887 
1888  PostData(1, fOutputList);
1889 }
1890 
1891 //______________________________________________________
1892 // Main method executed per event, all the action is happens here.
1893 //______________________________________________________
1894 void AliAnalysisTaskEMCALTriggerQA::UserExec(Option_t *)
1895 {
1896  AliVEvent* event = InputEvent();
1897 
1898  if (!event)
1899  {
1900  AliError("No Event, exit");
1901  return;
1902  }
1903 
1905  // Execute task on physics events with triggers
1906 
1907  //trigger configuration
1908  TString triggerclasses = event->GetFiredTriggerClasses();
1909 
1910  // event type
1911  Int_t eventType = ((AliVHeader*)event->GetHeader())->GetEventType();
1912 
1913  if(!fMCData)
1914  {
1915  // physics events eventType=7, select only those
1916  if(triggerclasses=="" || eventType != 7) return;
1917  }
1918 
1919  //printf("Event Type %d; Trigger classes: %s\n",eventType,triggerclasses.Data());
1920 
1921  // Check what trigger we had
1922  SetTriggerEventBit(triggerclasses);
1923 
1924  if(!fEventMB && !fEventL0 && !fEventL1G && !fEventL1G2 && !fEventL1J && ! fEventL1J2 && !fEventCen && !fEventSem) return;
1925 
1927  // Init geometry, OADB, maps
1928 
1929  InitGeometry(); // only once, must be done before OADB, geo OADB accessed here
1930 
1931  InitCellPatchMaps(); //init to 0 map for cells and patches
1932 
1934  // Do the analysis
1935 
1936  FillEventCounterHistogram();
1937 
1938  FillCellMaps();
1939 
1940  FillTriggerPatchMaps(triggerclasses);
1941 
1942  //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",
1943  // fEventMB,fEventL0,fEventL1G,fEventL1G2,fEventL1J,fEventL1J2,fEventCen,fEventSem,triggerclasses.Data());
1944 
1945  FillMapHistograms();
1946 
1947  FillV0Histograms();
1948 
1949  FillL1GammaPatchHistograms();
1950 
1951  FillL1JetPatchHistograms();
1952 
1953  // FEE vs STU vs TRU
1954  //FillCorrelationHistograms();
1955 
1956  ClusterAnalysis();
1957 
1958  PostData(1, fOutputList);
1959 
1960 }
AliAnalysisTaskEMCALTriggerQA::fEventSem
Bool_t fEventSem
Bit for Semi Central events.
Definition: AliAnalysisTaskEMCALTriggerQA.h:177
AliAnalysisTaskEMCALTriggerQA::fEventL1JD
Bool_t fEventL1JD
Bit for L1 Jet 1 events, DCal.
Definition: AliAnalysisTaskEMCALTriggerQA.h:172
AliAnalysisTaskEMCALTriggerQA::fhL0Amp
TH2F * fhL0Amp
! FALTRO signal per Row and Column for FOR involves L0 patch
Definition: AliAnalysisTaskEMCALTriggerQA.h:189
AliAnalysisTaskEMCALTriggerQA::fhL1Amp
TH2F * fhL1Amp
! STU signal per Row and Column for FOR involves L0 patch
Definition: AliAnalysisTaskEMCALTriggerQA.h:192
AliAnalysisTaskEMCALTriggerQA::FillTriggerPatchMaps
void FillTriggerPatchMaps(TString triggerclasses)
Fill L0, L1 patch arrays.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:307
AliAnalysisTaskEMCALTriggerQA::fhClusCenSM
TH2F * fhClusCenSM[fgkTriggerCombi][20]
! Clusters Centrality vs E distribution for a trigger, per SM
Definition: AliAnalysisTaskEMCALTriggerQA.h:264
AliAnalysisTaskEMCALTriggerQA::fhClusPhi
TH2F * fhClusPhi[fgkTriggerCombi]
! Clusters Phi vs E distribution for a trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:270
AliAnalysisTaskEMCALTriggerQA::UserCreateOutputObjects
void UserCreateOutputObjects()
Init histograms and geometry.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:1309
AliAnalysisTaskEMCALTriggerQA::fhNPatchFake
TH2F * fhNPatchFake
! number of fake patchs per event vs. if all were fakes or not
Definition: AliAnalysisTaskEMCALTriggerQA.h:214
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchMax
TH2F * fhL1GPatchMax
! FOR of max. amplitude patch with L1 Gamma patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:228
AliAnalysisTaskEMCALTriggerQA::fgkFALTROCols
static const int fgkFALTROCols
Total number of fake altro collumns in EMCAL, (ALTRO channels in one SM times 2 SM divided by 2 per F...
Definition: AliAnalysisTaskEMCALTriggerQA.h:314
Double_t
double Double_t
Definition: External.C:58
AliAnalysisTaskEMCALTriggerQA::fhClusMax
TH1F * fhClusMax[fgkTriggerCombi]
! Maximum E Cluster per event distribution for MB trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:255
AliAnalysisTaskEMCALTriggerQA::fhClusV0
TH2F * fhClusV0[fgkTriggerCombi]
! Clusters V0 vs E distribution for a trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:260
AliAnalysisTaskEMCALTriggerQA::fhNPatchNotFake
TH2F * fhNPatchNotFake
! number of non fake patchs per events vs. if all were fakes or not
Definition: AliAnalysisTaskEMCALTriggerQA.h:215
TH2F
Definition: External.C:236
AliAnalysisTaskEMCALTriggerQA::fhClusPhiMax
TH2F * fhClusPhiMax[fgkTriggerCombi]
! Maximum E Cluster vs Phi per event distribution for a trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:271
AliAnalysisTaskEMCALTriggerQA::fhClusCenMax
TH2F * fhClusCenMax[fgkTriggerCombi]
! Maximum E Cluster vs Centrality per event distribution for a trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:258
AliAnalysisTaskEMCALTriggerQA::fhL1JPatch
TH2F * fhL1JPatch
! FOR with L1 Jet patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:217
AliAnalysisTaskEMCALTriggerQA::FillV0Histograms
void FillV0Histograms()
Fill V0 histograms, only for ESDs.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:1057
AliAnalysisTaskEMCALTriggerQA::fhL1J2Patch
TH2F * fhL1J2Patch
! FOR with L1 Jet patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:218
AliAnalysisTaskEMCALTriggerQA::fhFORMeanAmp
TProfile2D * fhFORMeanAmp
! Mean FastOR(FEE) signal per Row and Column
Definition: AliAnalysisTaskEMCALTriggerQA.h:225
AliAnalysisTaskEMCALTriggerQA::AccessOADB
void AccessOADB()
Set the AODB bad channels at least once.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:179
AliAnalysisTaskEMCALTriggerQA::FillL1JetPatchHistograms
void FillL1JetPatchHistograms()
L1 jet trigger patches histograms.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:986
AliAnalysisTaskEMCALTriggerQA::FillCorrelationHistograms
void FillCorrelationHistograms()
FEE-TRU-STU correlation checks.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:719
AliAnalysisTaskEMCALTriggerQA::fgkFALTRORows
static const int fgkFALTRORows
Total number of fake altro rows in EMCAL, temporary, not considers DCal yet (ALTRO channels in one SM...
Definition: AliAnalysisTaskEMCALTriggerQA.h:311
centrality
centrality
Definition: AverageDmesonRaa.C:71
AliAnalysisTaskEMCALTriggerQA::fhClusEtaPhiHighCellMaxCluMax
TH2F * fhClusEtaPhiHighCellMaxCluMax[fgkTriggerCombi]
! Maximum E Cluster, maximum energy cell index Phi vs Eta per event distribution for MB trigger...
Definition: AliAnalysisTaskEMCALTriggerQA.h:277
AliAnalysisTaskEMCALTriggerQA::fhClusEtaPhiHighCellMax
TH2F * fhClusEtaPhiHighCellMax[fgkTriggerCombi]
! Clusters maximum energy cell index eta vs phi distribution for a trigger, energy above fEtaPhiEnMin...
Definition: AliAnalysisTaskEMCALTriggerQA.h:276
AliAnalysisTaskEMCALTriggerQA::fhClusEtaPhiLowCellMax
TH2F * fhClusEtaPhiLowCellMax[fgkTriggerCombi]
! Clusters maximum energy cell index eta vs phi distribution for a trigger, energy below fEtaPhiEnMin...
Definition: AliAnalysisTaskEMCALTriggerQA.h:282
AliAnalysisTaskEMCALTriggerQA::fhL0MeanAmp
TProfile2D * fhL0MeanAmp
! Mean FastOR(TRU) signal per Row and Column
Definition: AliAnalysisTaskEMCALTriggerQA.h:226
AliAnalysisTaskEMCALTriggerQA::fhClusEta
TH2F * fhClusEta[fgkTriggerCombi]
! Clusters eta vs E distribution for a trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:267
AliAnalysisTaskEMCALTriggerQA::FillEventCounterHistogram
void FillEventCounterHistogram()
Fill a TH1 histogram, each bin corresponds to a even trigger type.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:767
AliAnalysisTaskEMCALTriggerQA::fEventL1GD
Bool_t fEventL1GD
Bit for L1 Gamma 1 events, DCal.
Definition: AliAnalysisTaskEMCALTriggerQA.h:168
AliAnalysisTaskEMCALTriggerQA::fhClusEtaPhiHighCluMax
TH2F * fhClusEtaPhiHighCluMax[fgkTriggerCombi]
! Maximum E Cluster, Phi vs Eta per event distribution for a trigger, energy above fEtaPhiEnMin GeV ...
Definition: AliAnalysisTaskEMCALTriggerQA.h:274
AliAnalysisTaskEMCALTriggerQA::fhL0AmpL1G
TH2F * fhL0AmpL1G
! FALTRO signal per Row and Column for FOR involves L0 patch, with L1G trigger event ...
Definition: AliAnalysisTaskEMCALTriggerQA.h:190
AliAnalysisTaskEMCALTriggerQA::fhClusEtaPhiLowCellMaxCluMax
TH2F * fhClusEtaPhiLowCellMaxCluMax[fgkTriggerCombi]
! Maximum E Cluster, maximum energy cell index Phi vs Eta per event distribution for MB trigger...
Definition: AliAnalysisTaskEMCALTriggerQA.h:283
AliAnalysisTaskEMCALTriggerQA::fGeometry
AliEMCALGeometry * fGeometry
Access to EMCAL geometry utils.
Definition: AliAnalysisTaskEMCALTriggerQA.h:135
AliAnalysisTaskEMCALTriggerQA::fhL1JPatchMax
TH2F * fhL1JPatchMax
! FOR of max. amplitude patch with L1 Jet patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:230
AliAnalysisTaskEMCALTriggerQA::fhNEvents
TH1F * fhNEvents
! Number of selected events
Definition: AliAnalysisTaskEMCALTriggerQA.h:183
AliAnalysisTaskEMCALTriggerQA::fRecoUtils
AliEMCALRecoUtils * fRecoUtils
RecoUtils.
Definition: AliAnalysisTaskEMCALTriggerQA.h:132
AliAnalysisTaskEMCALTriggerQA::fMapTrigL1J2
Double_t fMapTrigL1J2[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:329
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchAllFakeE
TH1F * fhL1GPatchAllFakeE
! Energy distrib of FOR forfake events, all patch energy
Definition: AliAnalysisTaskEMCALTriggerQA.h:211
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchNotFakeE
TH1F * fhL1GPatchNotFakeE
! Energy distrib of FOR for non fake events, all patch energy
Definition: AliAnalysisTaskEMCALTriggerQA.h:213
AliAnalysisTaskEMCALTriggerQA::fhL1GAmp
TH2F * fhL1GAmp
! STU signal per Row and Column for FOR position of L1 Gamma patch (top-left)
Definition: AliAnalysisTaskEMCALTriggerQA.h:193
AliAnalysisTaskEMCALTriggerQA::fhL0Patch
TH2F * fhL0Patch
! FOR with L0 patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:199
AliAnalysisTaskEMCALTriggerQA::fhClusSM
TH1F * fhClusSM[fgkTriggerCombi][20]
! Clusters E distribution for a trigger, per SM
Definition: AliAnalysisTaskEMCALTriggerQA.h:263
AliAnalysisTaskEMCALTriggerQA::fMapTrigL0L1G
Double_t fMapTrigL0L1G[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:324
AliAnalysisTaskEMCALTriggerQA::fGeoName
TString fGeoName
Name of geometry used.
Definition: AliAnalysisTaskEMCALTriggerQA.h:136
AliAnalysisTaskEMCALTriggerQA::fhL1JAmp
TH2F * fhL1JAmp
! STU signal per Row and Column for FOR position of L1 Jet patch (top-left)
Definition: AliAnalysisTaskEMCALTriggerQA.h:195
AliAnalysisTaskEMCALTriggerQA::fhFORAmpL1G
TH2F * fhFORAmpL1G
! FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1 Gamma trigger event...
Definition: AliAnalysisTaskEMCALTriggerQA.h:185
AliAnalysisTaskEMCALTriggerQA::fMapTrigL0
Double_t fMapTrigL0[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:322
AliAnalysisTaskEMCALTriggerQA::fhV0
TH1F * fhV0[fgkTriggerCombi]
! V0 distribution for a triggered event
Definition: AliAnalysisTaskEMCALTriggerQA.h:285
AliAnalysisTaskEMCALTriggerQA::fAccessOADB
Bool_t fAccessOADB
Get calibration from OADB for EMCAL.
Definition: AliAnalysisTaskEMCALTriggerQA.h:139
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchAllFakeMax
TH2F * fhL1GPatchAllFakeMax
! FOR without any L1 Gamma patch associated with energy in the related cell, maximal energy patch : f...
Definition: AliAnalysisTaskEMCALTriggerQA.h:207
AliAnalysisTaskEMCALTriggerQA::fhClusMBPure
TH1F * fhClusMBPure[3]
! Clusters E distribution for pure MB trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:249
AliAnalysisTaskEMCALTriggerQA::fhL1G2Patch
TH2F * fhL1G2Patch
! FOR with L1 Gamma patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:201
AliAnalysisTaskEMCALTriggerQA::fTRUTotal
Float_t fTRUTotal
Sum of TRU amplitudes.
Definition: AliAnalysisTaskEMCALTriggerQA.h:148
AliAnalysisTaskEMCALTriggerQA::fMapTrigL1
Double_t fMapTrigL1[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:323
AliAnalysisTaskEMCALTriggerQA::fMapTrigL1G
Double_t fMapTrigL1G[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:326
AliAnalysisTaskEMCALTriggerQA::fhL0AmpL1J
TH2F * fhL0AmpL1J
! FALTRO signal per Row and Column for FOR involves L0 patch, with L1J trigger event ...
Definition: AliAnalysisTaskEMCALTriggerQA.h:191
Int_t
int Int_t
Definition: External.C:63
AliAnalysisTaskEMCALTriggerQA::Init
void Init()
Init analysis parameters not set before.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:1106
AliAnalysisTaskEMCALTriggerQA::fhJPMaxVV0TT
TH2F * fhJPMaxVV0TT
! V0 signal vs maximum jet L1 patch
Definition: AliAnalysisTaskEMCALTriggerQA.h:224
AliAnalysisTaskEMCALTriggerQA::fhClus
TH1F * fhClus[fgkTriggerCombi]
! Clusters E distribution for a trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:254
Float_t
float Float_t
Definition: External.C:68
AliAnalysisTaskEMCALTriggerQA::fhTRUSTU
TH2F * fhTRUSTU
! Correlation TRU vs STU
Definition: AliAnalysisTaskEMCALTriggerQA.h:220
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchAllFakeMaxE
TH1F * fhL1GPatchAllFakeMaxE
! Energy distrib FOR for fake events, patch of maximal energy
Definition: AliAnalysisTaskEMCALTriggerQA.h:209
AliAnalysisTaskEMCALTriggerQA::fCentEstimator
TString fCentEstimator
Centrality estimator string: V0M, TKL, FMD, ZEMvsZDC, ...
Definition: AliAnalysisTaskEMCALTriggerQA.h:160
AliAnalysisTaskEMCALTriggerQA::fEventL1J2D
Bool_t fEventL1J2D
Bit for L1 JEt 2 events, DCal.
Definition: AliAnalysisTaskEMCALTriggerQA.h:174
AliAnalysisTaskEMCALTriggerQA::fhClusEtaPhiLowCluMax
TH2F * fhClusEtaPhiLowCluMax[fgkTriggerCombi]
! Maximum E Cluster, Phi vs Eta per event distribution for MB trigger, energy below fEtaPhiEnMin GeV ...
Definition: AliAnalysisTaskEMCALTriggerQA.h:280
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchNotAllFakeMax
TH2F * fhL1GPatchNotAllFakeMax
! FOR with at least one L1 Gamma patch associated with energy in the related cell, maximal energy patch : not fake events
Definition: AliAnalysisTaskEMCALTriggerQA.h:206
AliAnalysisTaskEMCALTriggerQA::fhFORAmpL1J2
TH2F * fhFORAmpL1J2
! FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1 Jet2 trigger event ...
Definition: AliAnalysisTaskEMCALTriggerQA.h:188
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchAllFake
TH2F * fhL1GPatchAllFake
! FOR without any L1 Gamma patch associated with energy in the related cells: fake patch ...
Definition: AliAnalysisTaskEMCALTriggerQA.h:205
AliAnalysisTaskEMCALTriggerQA::fhClusMaxMBPure
TH1F * fhClusMaxMBPure[3]
! Maximum E Cluster per event distribution for pure MB trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:250
AliAnalysisTaskEMCALTriggerQA::fUseAliCentrality
Bool_t fUseAliCentrality
Use the centrality estimator from AliCentrality or AliMultSelection.
Definition: AliAnalysisTaskEMCALTriggerQA.h:161
AliAnalysisTaskEMCALTriggerQA::fhClusEtaMax
TH2F * fhClusEtaMax[fgkTriggerCombi]
! Maximum E Cluster vs Eta per event distribution for a trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:268
AliAnalysisTaskEMCALTriggerQA::fEventL1J
Bool_t fEventL1J
Bit for L1 Jet 1 events.
Definition: AliAnalysisTaskEMCALTriggerQA.h:171
AliAnalysisTaskEMCALTriggerQA::fhL1J2Amp
TH2F * fhL1J2Amp
! STU signal per Row and Column for FOR position of L1 Jet2 patch (top-left)
Definition: AliAnalysisTaskEMCALTriggerQA.h:196
AliAnalysisTaskEMCALTriggerQA::fhFEESTU
TH2F * fhFEESTU
! Correlation FEE vs STU
Definition: AliAnalysisTaskEMCALTriggerQA.h:219
AliAnalysisTaskEMCALTriggerQA::fFirstSM
Int_t fFirstSM
Fill SM histograms for SM >= fFirstSM.
Definition: AliAnalysisTaskEMCALTriggerQA.h:157
AliAnalysisTaskEMCALTriggerQA::fhL1J2PatchMax
TH2F * fhL1J2PatchMax
! FOR of max. amplitude patch with L1 Jet patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:231
AliAnalysisTaskEMCALTriggerQA::FillL1GammaPatchHistograms
void FillL1GammaPatchHistograms()
L1 Gamma trigger patches histograms.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:832
AliAnalysisTaskEMCALTriggerQA::fhClusEtaPhiHigh
TH2F * fhClusEtaPhiHigh[fgkTriggerCombi]
! Clusters eta vs phi distribution for a trigger, energy above fEtaPhiEnMin GeV
Definition: AliAnalysisTaskEMCALTriggerQA.h:273
AliAnalysisTaskEMCALTriggerQA::FillClusterHistograms
void FillClusterHistograms(Int_t triggerNumber, Bool_t maxCluster, Float_t e, Float_t eta, Float_t phi, Float_t ietamax, Float_t iphimax, Int_t sm, Float_t centrality, Float_t v0AC)
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:650
AliAnalysisTaskEMCALTriggerQA::fEventL1J2
Bool_t fEventL1J2
Bit for L1 JEt 2 events.
Definition: AliAnalysisTaskEMCALTriggerQA.h:173
AliAnalysisTaskEMCALTriggerQA::fhClusV0SM
TH2F * fhClusV0SM[fgkTriggerCombi][20]
! Clusters V0 vs E distribution for a trigger, per SM
Definition: AliAnalysisTaskEMCALTriggerQA.h:265
AliAnalysisTaskEMCALTriggerQA::fMapCellL1G
Double_t fMapCellL1G[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:318
AliAnalysisTaskEMCALTriggerQA::fgkTriggerCombi
static const int fgkTriggerCombi
Total number of trigger combinations defined above.
Definition: AliAnalysisTaskEMCALTriggerQA.h:252
AliAnalysisTaskEMCALTriggerQA::fhClusCen
TH2F * fhClusCen[fgkTriggerCombi]
! Clusters Centrality vs E distribution for a trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:257
AliAnalysisTaskEMCALTriggerQA::fMapTrigL1G2
Double_t fMapTrigL1G2[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:327
Data
Bool_t Data(TH1F *h, Double_t *rangefit, Bool_t writefit, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmafit, Int_t &status)
Definition: charmCutsOptimization.C:371
Short_t
short Short_t
Definition: External.C:23
AliAnalysisTaskEMCALTriggerQA::FillMapHistograms
void FillMapHistograms()
Matrix with signal per channel.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:1026
AliAnalysisTaskEMCALTriggerQA::fhL1G2PatchMax
TH2F * fhL1G2PatchMax
! FOR of max. amplitude patch with L1 Gamma patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:229
AliAnalysisTaskEMCALTriggerQA::fhCentrality
TH1F * fhCentrality[fgkTriggerCombi]
! Centrality distribution for a triggered event
Definition: AliAnalysisTaskEMCALTriggerQA.h:286
AliAnalysisTaskEMCALTriggerQA::fFillV0SigHisto
Bool_t fFillV0SigHisto
V0 signal creation and fill.
Definition: AliAnalysisTaskEMCALTriggerQA.h:153
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchNotAllFakeE
TH1F * fhL1GPatchNotAllFakeE
! Energy distrib of FOR for non fake events, all patch energy
Definition: AliAnalysisTaskEMCALTriggerQA.h:210
AliAnalysisTaskEMCALTriggerQA::fhFORAmp
TH2F * fhFORAmp
! FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column
Definition: AliAnalysisTaskEMCALTriggerQA.h:184
AliAnalysisTaskEMCALTriggerQA::InitHistogramArrays
void InitHistogramArrays()
Histograms array initialization called in constructor.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:1203
AliAnalysisTaskEMCALTriggerQA::fEventL1G2D
Bool_t fEventL1G2D
Bit for L1 Gamma 2 events, DCal.
Definition: AliAnalysisTaskEMCALTriggerQA.h:170
AliAnalysisTaskEMCALTriggerQA::fhL1MeanAmp
TProfile2D * fhL1MeanAmp
! Mean FastOR(STU) signal per Row and Column
Definition: AliAnalysisTaskEMCALTriggerQA.h:227
AliAnalysisTaskEMCALTriggerQA::fFillClusAcceptHisto
Bool_t fFillClusAcceptHisto
Fill eta/phi distributions.
Definition: AliAnalysisTaskEMCALTriggerQA.h:155
AliAnalysisTaskEMCALTriggerQA::fhV0STU
TH2I * fhV0STU
! Total signal STU vs V0C+V0S
Definition: AliAnalysisTaskEMCALTriggerQA.h:221
AliAnalysisTaskEMCALTriggerQA::fEventL0D
Bool_t fEventL0D
Bit for L0 events, DCal.
Definition: AliAnalysisTaskEMCALTriggerQA.h:166
AliAnalysisTaskEMCALTriggerQA::fOADBFilePath
TString fOADBFilePath
Default path $ALICE_PHYSICS/OADB/EMCAL, if needed change.
Definition: AliAnalysisTaskEMCALTriggerQA.h:140
AliAnalysisTaskEMCALTriggerQA::fFillCenHisto
Bool_t fFillCenHisto
Centrality histograms creation and fill.
Definition: AliAnalysisTaskEMCALTriggerQA.h:154
AliAnalysisTaskEMCALTriggerQA::fMomentum
TLorentzVector fMomentum
Cluster kinematics, temporal, avoid recreation per event.
Definition: AliAnalysisTaskEMCALTriggerQA.h:179
ClassImp
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Definition: AliAnalysisTaskCRC.cxx:44
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchNotFake
TH2F * fhL1GPatchNotFake
! FOR with L1 Gamma patch associated but no energy in the related cells
Definition: AliAnalysisTaskEMCALTriggerQA.h:202
file
TFile * file
Definition: DrawAnaCaloTrackQA.C:19
etamax
const Double_t etamax
Definition: AddTaskCFDStar.C:41
AliAnalysisTaskEMCALTriggerQA::fLastSM
Int_t fLastSM
Fill SM histograms for SM <= fLastSM.
Definition: AliAnalysisTaskEMCALTriggerQA.h:158
AliAnalysisTaskEMCALTriggerQA::fEventL1G2
Bool_t fEventL1G2
Bit for L1 Gamma 2 events.
Definition: AliAnalysisTaskEMCALTriggerQA.h:169
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchFake
TH2F * fhL1GPatchFake
! FOR with L1 Gamma patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:203
AliAnalysisTaskEMCALTriggerQA::fMapCellL1J2
Double_t fMapCellL1J2[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:321
AliAnalysisTaskEMCALTriggerQA::fMapCellL1G2
Double_t fMapCellL1G2[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:319
AliAnalysisTaskEMCALTriggerQA.h
Option_t
const char Option_t
Definition: External.C:48
AliAnalysisTaskEMCALTriggerQA::FillCellMaps
void FillCellMaps()
Cells analysis. Fill FEE energy per channel array.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:235
AliAnalysisTaskEMCALTriggerQA::fhClusEtaPhiLow
TH2F * fhClusEtaPhiLow[fgkTriggerCombi]
! Clusters eta vs phi distribution for a trigger, energy below fEtaPhiEnMin GeV
Definition: AliAnalysisTaskEMCALTriggerQA.h:279
AliAnalysisTaskEMCALTriggerQA::fV0Trigger
Float_t fV0Trigger
V0 signal from trigger.
Definition: AliAnalysisTaskEMCALTriggerQA.h:149
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchNotAllFake
TH2F * fhL1GPatchNotAllFake
! FOR with at least 1 L1 Gamma patch associated that has energy in the related celles : not a fake ev...
Definition: AliAnalysisTaskEMCALTriggerQA.h:204
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchNotAllFakeMaxE
TH1F * fhL1GPatchNotAllFakeMaxE
! Energy distrib of FOR for non fake events, patch of maximal energy
Definition: AliAnalysisTaskEMCALTriggerQA.h:208
AliAnalysisTaskEMCALTriggerQA::fhGPMaxVV0TT
TH2F * fhGPMaxVV0TT
! V0 signal vs maximum gamma L1 patch
Definition: AliAnalysisTaskEMCALTriggerQA.h:223
Bool_t
bool Bool_t
Definition: External.C:53
AliAnalysisTaskEMCALTriggerQA::fEtaPhiEnMin
Float_t fEtaPhiEnMin
Min energy for Eta/Phi histograms.
Definition: AliAnalysisTaskEMCALTriggerQA.h:145
AliAnalysisTaskEMCALTriggerQA
Fill histograms with basic QA information for EMCAL offline trigger.
Definition: AliAnalysisTaskEMCALTriggerQA.h:29
AliAnalysisTaskEMCALTriggerQA::fEventCen
Bool_t fEventCen
Bit for Central events.
Definition: AliAnalysisTaskEMCALTriggerQA.h:176
AliAnalysisTaskEMCALTriggerQA::fhClusV0Max
TH2F * fhClusV0Max[fgkTriggerCombi]
! Maximum E Cluster vs Centrality per event distribution for a trigger
Definition: AliAnalysisTaskEMCALTriggerQA.h:261
AliAnalysisTaskEMCALTriggerQA::fhFORAmpL1J
TH2F * fhFORAmpL1J
! FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1 Jet trigger event ...
Definition: AliAnalysisTaskEMCALTriggerQA.h:187
AliAnalysisTaskEMCALTriggerQA::fMapCell
Double_t fMapCell[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:317
AliAnalysisTaskEMCALTriggerQA::fhFORAmpL1G2
TH2F * fhFORAmpL1G2
! FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column, with L1 Gamma2 trigger even...
Definition: AliAnalysisTaskEMCALTriggerQA.h:186
AliAnalysisTaskEMCALTriggerQA::fhL1FOREnergy
TH2F * fhL1FOREnergy
! STU signal per Row and Column for FOR position vs FOR energy
Definition: AliAnalysisTaskEMCALTriggerQA.h:197
AliAnalysisTaskEMCALTriggerQA::fMapTrigL0L1J
Double_t fMapTrigL0L1J[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:325
AliAnalysisTaskEMCALTriggerQA::fOADBSet
Bool_t fOADBSet
AODB parameters already set.
Definition: AliAnalysisTaskEMCALTriggerQA.h:138
AliAnalysisTaskEMCALTriggerQA::fhL1G2Amp
TH2F * fhL1G2Amp
! STU signal per Row and Column for FOR position of L1 Gamma2 patch (top-left)
Definition: AliAnalysisTaskEMCALTriggerQA.h:194
AliAnalysisTaskEMCALTriggerQA::SetTriggerEventBit
void SetTriggerEventBit(TString list)
Check what trigger is the event, set the corresponding bit.
Definition: AliAnalysisTaskEMCALTriggerQA.cxx:1233
AliAnalysisTaskEMCALTriggerQA::fMapCellL1J
Double_t fMapCellL1J[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:320
AliAnalysisTaskEMCALTriggerQA::fhL1GPatchFakeE
TH1F * fhL1GPatchFakeE
! Energy distrib of FOR for fake events, all patch energy
Definition: AliAnalysisTaskEMCALTriggerQA.h:212
AliAnalysisTaskEMCALTriggerQA::fMapTrigL1J
Double_t fMapTrigL1J[fgkFALTRORows][fgkFALTROCols]
Definition: AliAnalysisTaskEMCALTriggerQA.h:328
AliAnalysisTaskEMCALTriggerQA::fEventL1G
Bool_t fEventL1G
Bit for L1 Gamma 1 events.
Definition: AliAnalysisTaskEMCALTriggerQA.h:167
AliAnalysisTaskEMCALTriggerQA::fhL1GPatch
TH2F * fhL1GPatch
! FOR with L1 Gamma patch associated
Definition: AliAnalysisTaskEMCALTriggerQA.h:200