First implementation of EMCAL trigger QA from Nicola Arbor
[u/mrichter/AliRoot.git] / PWG4 / UserTasks / EmcalTasks / AliAnalysisTaskEMCALTriggerQA.cxx
CommitLineData
bce9493b 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//------------------------------------------------------------------------//
17// Fill histograms with basic QA information for EMCAL offline trigger //
18// Author: Nicolas Arbor (LPSC-Grenoble) //
19// Gustavo Conesa Balbastre (LPSC-Grenoble) //
20// //
21//------------------------------------------------------------------------//
22
23
24#include <TList.h>
25#include <TH1F.h>
26#include <TH2F.h>
27#include <TF1.h>
28
29#include "AliLog.h"
30#include "AliVCluster.h"
31#include "AliVCaloCells.h"
32#include "AliVEvent.h"
33#include "AliESDEvent.h"
34#include "AliESDVZERO.h"
35#include "AliESDCaloTrigger.h"
36#include "AliEMCALGeometry.h"
37
38#include "AliAnalysisTaskEMCALTriggerQA.h"
39
40ClassImp(AliAnalysisTaskEMCALTriggerQA)
41
42//_________________________________________________________________________
43AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA() :
44AliAnalysisTaskSE(),
45fOutputList(0),
46fGeometry(0), fGeoName("EMCAL_COMPLETEV1"),
47fhNEvents(0),
48fhFORPos(0),
49fhL0Pos(0),
50fhL1Pos(0),
51fhL0Patch(0),
52fhL1GPatch(0),
53fhL1JPatch(0),
54fhV0STU(0),
55fhFullTRUSTU(0),
56fhSTUChecks(0),
57fNBinsSTUSignal(1000),fMaxSTUSignal(100000),
58fNBinsTRUSignal(1000),fMaxTRUSignal(100000),
59fNBinsV0Signal (1000),fMaxV0Signal (10000)
60
61{
62 // Constructor
63 for (int i = 0; i < 30; i++)
64 {
65 fhFEESTU[i] = 0;
66 fhTRUSTU[i] = 0;
67 }
68
69}
70
71//________________________________________________________________________
72AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA(const char *name) :
73AliAnalysisTaskSE(name),
74fOutputList(0),
75fGeometry(0), fGeoName("EMCAL_COMPLETEV1"),
76fhNEvents(0),
77fhFORPos(0),
78fhL0Pos(0),
79fhL1Pos(0),
80fhL0Patch(0),
81fhL1GPatch(0),
82fhL1JPatch(0),
83fhV0STU(0),
84fhFullTRUSTU(0),
85fhSTUChecks(0),
86fNBinsSTUSignal(1000),fMaxSTUSignal(100000),
87fNBinsTRUSignal(1000),fMaxTRUSignal(100000),
88fNBinsV0Signal (1000),fMaxV0Signal (10000)
89
90{
91 // Constructor
92 for (int i = 0; i < 30; i++)
93 {
94 fhFEESTU[i] = 0;
95 fhTRUSTU[i] = 0;
96 }
97
98 DefineOutput(1, TList::Class());
99
100}
101
102
103//________________________________________________________________________
104void AliAnalysisTaskEMCALTriggerQA::UserCreateOutputObjects()
105{
106 // Init histograms and geometry
107
108 fGeometry = AliEMCALGeometry::GetInstance(fGeoName);
109
110 fOutputList = new TList;
111 fOutputList->SetOwner(kTRUE);
112
113 fhNEvents = new TH1F("hNEvents","Number of selected events",1,0,1);
114 fhNEvents->SetYTitle("N events");
115
116 fhFORPos = new TH2F("hFORPos", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
117 fhFORPos->SetXTitle("Index #eta (collumns)");
118 fhFORPos->SetYTitle("Index #phi (rows)");
119
120 fhL0Pos = new TH2F("hL0Pos","FALTRO signal per Row and Column",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
121 fhL0Pos->SetXTitle("Index #eta (collumns)");
122 fhL0Pos->SetYTitle("Index #phi (rows)");
123
124 fhL1Pos = new TH2F("hL1Pos","STU signal per Row and Column",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
125 fhL1Pos->SetXTitle("Index #eta (collumns)");
126 fhL1Pos->SetYTitle("Index #phi (rows)");
127
128 fhL0Patch = new TH2F("fhL0Patch","FOR with associated L0 Patch",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
129 fhL0Patch->SetXTitle("Index #eta (collumns)");
130 fhL0Patch->SetYTitle("Index #phi (rows)");
131
132 fhL1GPatch = new TH2F("fhL1GPatch","FOR with associated L1 Gamma Patch",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
133 fhL1GPatch->SetXTitle("Index #eta (collumns)");
134 fhL1GPatch->SetYTitle("Index #phi (rows)");
135
136 fhL1JPatch = new TH2F("fhL1JPatch","FOR with associated L1 Jet Patch",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
137 fhL1JPatch->SetXTitle("Index #eta (collumns)");
138 fhL1JPatch->SetYTitle("Index #phi (rows)");
139
140 fhFullTRUSTU = new TH2I("hFullTRUSTU","Total signal STU vs TRU",fNBinsTRUSignal,0,fMaxTRUSignal,fNBinsSTUSignal,0,fMaxSTUSignal);
141 fhFullTRUSTU->SetXTitle("Total signal TRU");
142 fhFullTRUSTU->SetYTitle("Total signal STU");
143
144 fhV0STU = new TH2I("hV0STU","Total signal STU vs V0C+V0S",fNBinsV0Signal,0,fMaxV0Signal,fNBinsSTUSignal,0,fMaxSTUSignal);
145 fhV0STU->SetXTitle("Signal V0C+V0A");
146 fhV0STU->SetYTitle("Total signal STU");
147
148 fhSTUChecks = new TH2I("hSTUChecks","Check FEE/STU link",2,0,2,15,0,15);
149 fhSTUChecks->SetXTitle("Index #eta");
150 fhSTUChecks->SetYTitle("Index #phi");
151
152 for (int i = 0; i < 30; i++)
153 {
154 fhFEESTU[i] = new TH1F(Form("hFEESTU%d",i),Form("STU / FEE, channel %d",i),1000,0,100);
155 fhFEESTU[i]->SetXTitle("STU/FEE signal");
156
157 fhTRUSTU[i] = new TH1F(Form("hTRUSTU%d",i),Form("STU / TRU, channel %d",i),1000,0,100);
158 fhTRUSTU[i]->SetXTitle("STU/TRU signal");
159 }
160
161 fOutputList->Add(fhNEvents);
162 fOutputList->Add(fhV0STU);
163 fOutputList->Add(fhFORPos);
164 fOutputList->Add(fhL0Pos);
165 fOutputList->Add(fhL1Pos);
166 fOutputList->Add(fhL0Patch);
167 fOutputList->Add(fhL1GPatch);
168 fOutputList->Add(fhL1JPatch);
169 fOutputList->Add(fhFullTRUSTU);
170 fOutputList->Add(fhSTUChecks);
171
172
173 for (int i = 0; i < 30; i++)
174 {
175 fOutputList->Add(fhFEESTU[i]);
176 fOutputList->Add(fhTRUSTU[i]);
177 }
178
179 PostData(1, fOutputList);
180
181}
182//________________________________________________________________________
183void AliAnalysisTaskEMCALTriggerQA::UserExec(Option_t *)
184{
185 // Main loop
186 // Called for each event
187
188 AliVEvent* event = InputEvent();
189
190 //Remove next lines when AODs ready
191 AliESDEvent *esdEvent = dynamic_cast<AliESDEvent*>(event);
192
193 if (!esdEvent)
194 {
195 AliError("Work only with ESDs, not available, exit");
196 return;
197 }
198
199 fhNEvents->Fill(0);
200
201
202 //map for cells and patches
203
204 Double_t emcalCell [fgkFALTRORows][fgkFALTROCols], emcalTrigL0 [fgkFALTRORows][fgkFALTROCols], emcalTrigL1[fgkFALTRORows][fgkFALTROCols];
205 Double_t emcalPatchL0[fgkFALTRORows][fgkFALTROCols], emcalPatchL1G[fgkFALTRORows][fgkFALTROCols], emcalPatchL1J[fgkFALTRORows][fgkFALTROCols];
206
207 for (Int_t i = 0; i < fgkFALTRORows; i++)
208 {
209 for (Int_t j = 0; j < fgkFALTROCols; j++)
210 {
211 emcalTrigL0[i][j] = 0.;
212 emcalTrigL1[i][j] = 0.;
213 emcalCell[i][j] = 0.;
214 emcalPatchL0[i][j] = 0.;
215 emcalPatchL1G[i][j] = 0.;
216 emcalPatchL1J[i][j] = 0.;
217 }
218 }
219
220 // ---------------------------------
221 // Cells analysis
222 // Fill FEE energy per channel array
223 // ---------------------------------
224
225 Int_t posX = -1, posY = -1;
226 Int_t nSupMod = -1, ieta = -1, iphi = -1, nModule = -1, nIphi = -1, nIeta = -1;
227 Short_t absId = -1;
228 Int_t nCells = 0;
229
230 AliVCaloCells& cells= *(event->GetEMCALCells());
231
232 if (cells.IsEMCAL())
233 {
234 for (Int_t icell = 0; icell < cells.GetNumberOfCells(); icell++)
235 {
236 nCells ++;
237
238 Double_t amp =0., time = 0.;
239
240 cells.GetCell(icell, absId, amp, time);
241
242 fGeometry->GetCellIndex(absId, nSupMod, nModule, nIphi, nIeta);
243 fGeometry->GetCellPhiEtaIndexInSModule(nSupMod, nModule, nIphi, nIeta, iphi, ieta);
244
245 posX = (nSupMod % 2) ? ieta + AliEMCALGeoParams::fgkEMCALCols : ieta;
246 posY = iphi + AliEMCALGeoParams::fgkEMCALRows * int(nSupMod / 2);
247 if(int(posX/2) > fgkFALTROCols) printf("Wrong X, posX %d\n",posX);
248 if(int(posY/2) > fgkFALTRORows) printf("Wrong Y, posY %d\n",posX);
249
250 emcalCell[int(posY/2)][int(posX/2)] += amp;
251 }
252 }
253
254 // -----------------------------------
255 //Trigger analysis, fill L0, L1 arrays
256 // -----------------------------------
257
258 AliESDCaloTrigger& trg= * (esdEvent->GetCaloTrigger("EMCAL"));
259
260 Int_t nL0Patch = 0 ;
261 Int_t nL1Patch = 0 ;
262 Double_t totSTU = 0.;
263 Double_t totTRU = 0.;
264
265 trg.Reset();
266 while (trg.Next())
267 {
268 trg.GetPosition(posX,posY);
269
270
271 if (posX > -1 && posY > -1)
272 {
273 //L0 analysis
274 Int_t nTimes = 0;
275 trg.GetNL0Times(nTimes);
276 if (nTimes)
277 {
278 nL0Patch += nTimes;
279 Float_t ampL0 = 0.;
280 trg.GetAmplitude(ampL0);
281 emcalTrigL0[posY][posX] = ampL0;
282 emcalPatchL0[posY][posX] = 1.;
283 totTRU += ampL0;
284 fhL0Patch->Fill(posX-1,posY-1);//-1 is used to compare in good way patch L0 and patch L1
285 }
286
287 //L1 analysis
288 Int_t bit = 0;
289 trg.GetTriggerBits(bit);
290
291 //L1-Gamma
292 if (bit >> 4 & 0x1)
293 {
294 nL1Patch ++;
295 emcalPatchL1G[posY][posX] = 1.;
296 fhL1GPatch->Fill(posX,posY);
297
298 Int_t ts = 0;
299 trg.GetL1TimeSum(ts);
300 emcalTrigL1[posY][posX] += ts;
301 totSTU += ts;
302 }
303
304 //L1-Jet
305 if (bit >> 5 & 0x1)
306 {
307 nL1Patch ++;
308 emcalPatchL1J[posY][posX] = 1.;
309 fhL1JPatch->Fill(posX,posY);
310
311 Int_t ts = 0;
312 trg.GetL1TimeSum(ts);
313 emcalTrigL1[posY][posX] += ts;
314 totSTU += ts;
315 }
316
317 }
318 }
319
320 if(totTRU > fMaxTRUSignal)printf("large totTRU %f\n",totTRU);
321 if(totSTU > fMaxSTUSignal)printf("large totSTU %f\n",totSTU);
322
323 if (totTRU != 0) fhFullTRUSTU->Fill(totTRU,totSTU);
324
325 //V0 analysis
326 AliESDVZERO* eventV0 = esdEvent->GetVZEROData();
327
328 Float_t v0C = 0, v0A = 0;
329
330 if (eventV0)
331 {
332 for (Int_t i = 0; i < 32; i++)
333 {
334 v0C += eventV0->GetAdcV0C(i);
335 v0A += eventV0->GetAdcV0A(i);
336 }
337 }
338
339 if (totSTU != 0) {
340 fhV0STU->Fill(v0A+v0C,totSTU);
341 if( v0A+v0C > fMaxV0Signal) printf("large v0A+v0C %f\n",v0A+v0C);
342 }
343
344 //Matrix with signal per channel
345 for (Int_t i = 0; i < fgkFALTRORows-1; i++)
346 {
347 for (Int_t j = 0; j < fgkFALTROCols-1; j++) //check x,y direction for reading FOR ((0,0) = top left);
348 {
349 fhFORPos->Fill(fgkFALTROCols-j, i, emcalCell [i][j]);
350 fhL0Pos ->Fill(fgkFALTROCols-j, i, emcalTrigL0[i][j]);
351 fhL1Pos ->Fill(fgkFALTROCols-j, i, emcalTrigL1[i][j]);
352 }
353 }
354
355 //TRU checks
356 Double_t ampFOR[30] = {0.}, ampL0[30] = {0.}, ampL1[30] = {0.};
357 for (Int_t i = 0; i < fgkFALTRORows-1; i++)
358 {
359 for (Int_t j = 0; j < fgkFALTROCols-1; j++) //A-side
360 {
361
362 //method to get TRU number
363 Int_t FORid = -1;
364 fGeometry->GetAbsFastORIndexFromPositionInEMCAL(j,i,FORid);
365 Int_t iTRU = -1;
366 Int_t iADC = -1;
367 fGeometry->GetTRUFromAbsFastORIndex(FORid,iTRU,iADC);
368
369 if (iTRU >= 0)
370 {
371 ampFOR[iTRU] += emcalCell [i][j];
372 ampL0[iTRU] += emcalTrigL0[i][j];
373 ampL1[iTRU] += emcalTrigL1[i][j];
374 }
375 }
376 }
377
378
379 // Double_t ampFOR[30] = {0.}, ampL0[30] = {0.}, ampL1[30] = {0.};
380 // for (Int_t i = 0; i < fgkFALTRORows-1; i++)
381 // {
382 // for (Int_t j = 0; j < fgkFALTROCols-1; j++) //A-side
383 // {
384 // if (i < 3)
385 // {
386 // if(j-23 <= 0) //A-side
387 // {
388 // ampFOR[0] += emcalCell [i][j];
389 // ampL0[0] += emcalTrigL0[i][j];
390 // ampL1[0] += emcalTrigL1[i][j];
391 // }
392 // else //C-side
393 // {
394 // ampFOR[15] += emcalCell [i][j];
395 // ampL0[15] += emcalTrigL0[i][j];
396 // ampL1[15] += emcalTrigL1[i][j];
397 // }
398
399 // }
400 // else if (i > 3 && i < 8)
401 // {
402 // if(j-23 <= 0) //A-side
403 // {
404 // ampFOR[1] += emcalCell [i][j];
405 // ampL0[1] += emcalTrigL0[i][j];
406 // ampL1[1] += emcalTrigL1[i][j];
407 // }
408 // else //C-side
409 // {
410 // ampFOR[16] += emcalCell [i][j];
411 // ampL0[16] += emcalTrigL0[i][j];
412 // ampL1[16] += emcalTrigL1[i][j];
413 // }
414 // }
415 // else if (i > 8 && i < 12)
416 // {
417 // if(j-23 <= 0) //A-side
418 // {
419 // ampFOR[2] += emcalCell [i][j];
420 // ampL0[2] += emcalTrigL0[i][j];
421 // ampL1[2] += emcalTrigL1[i][j];
422 // }
423 // else //C-side
424 // {
425 // ampFOR[17] += emcalCell [i][j];
426 // ampL0[17] += emcalTrigL0[i][j];
427 // ampL1[17] += emcalTrigL1[i][j];
428 // }
429 // }
430 // else if (i > 12 && i < 16)
431 // {
432 // if(j-23 <= 0) //A-side
433 // {
434 // ampFOR[3] += emcalCell [i][j];
435 // ampL0[3] += emcalTrigL0[i][j];
436 // ampL1[3] += emcalTrigL1[i][j];
437 // }
438 // else //C-side
439 // {
440 // ampFOR[18] += emcalCell [i][j];
441 // ampL0[18] += emcalTrigL0[i][j];
442 // ampL1[18] += emcalTrigL1[i][j];
443 // }
444
445 // }
446 // else if (i > 16 && i < 20)
447 // {
448 // if(j-23 <= 0) //A-side
449 // {
450 // ampFOR[4] += emcalCell [i][j];
451 // ampL0[4] += emcalTrigL0[i][j];
452 // ampL1[4] += emcalTrigL1[i][j];
453 // }
454 // else //C-side
455 // {
456 // ampFOR[19] += emcalCell [i][j];
457 // ampL0[19] += emcalTrigL0[i][j];
458 // ampL1[19] += emcalTrigL1[i][j];
459 // }
460 // }
461 // else if (i > 20 && i < 24)
462 // {
463 // if(j-23 <= 0) //A-side
464 // {
465 // ampFOR[5] += emcalCell [i][j];
466 // ampL0[5] += emcalTrigL0[i][j];
467 // ampL1[5] += emcalTrigL1[i][j];
468 // }
469 // else //C-side
470 // {
471 // ampFOR[20] += emcalCell [i][j];
472 // ampL0[20] += emcalTrigL0[i][j];
473 // ampL1[20] += emcalTrigL1[i][j];
474 // }
475 // }
476 // else if (i > 24 && i < 28)
477 // {
478 // if(j-23 <= 0) //A-side
479 // {
480 // ampFOR[6] += emcalCell [i][j];
481 // ampL0[6] += emcalTrigL0[i][j];
482 // ampL1[6] += emcalTrigL1[i][j];
483 // }
484 // else //C-side
485 // {
486 // ampFOR[21] += emcalCell [i][j];
487 // ampL0[21] += emcalTrigL0[i][j];
488 // ampL1[21] += emcalTrigL1[i][j];
489 // }
490 // }
491 // else if (i > 28 && i < 32)
492 // {
493 // if(j-23 <= 0) //A-side
494 // {
495 // ampFOR[7] += emcalCell [i][j];
496 // ampL0[7] += emcalTrigL0[i][j];
497 // ampL1[7] += emcalTrigL1[i][j];
498 // }
499 // else //C-side
500 // {
501 // ampFOR[22] += emcalCell [i][j];
502 // ampL0[22] += emcalTrigL0[i][j];
503 // ampL1[22] += emcalTrigL1[i][j];
504 // }
505 // }
506 // else if (i > 32 && i < 36)
507 // {
508 // if(j-23 <= 0) //A-side
509 // {
510 // ampFOR[8] += emcalCell [i][j];
511 // ampL0[8] += emcalTrigL0[i][j];
512 // ampL1[8] += emcalTrigL1[i][j];
513 // }
514 // else //C-side
515 // {
516 // ampFOR[23] += emcalCell [i][j];
517 // ampL0[23] += emcalTrigL0[i][j];
518 // ampL1[23] += emcalTrigL1[i][j];
519 // }
520
521 // }
522 // else if (i > 36 && i < 40)
523 // {
524 // if(j-23 <= 0) //A-side
525 // {
526 // ampFOR[9] += emcalCell [i][j];
527 // ampL0[9] += emcalTrigL0[i][j];
528 // ampL1[9] += emcalTrigL1[i][j];
529 // }
530 // else //C-side
531 // {
532 // ampFOR[24] += emcalCell [i][j];
533 // ampL0[24] += emcalTrigL0[i][j];
534 // ampL1[24] += emcalTrigL1[i][j];
535 // }
536 // }
537 // else if (i > 40 && i < 44)
538 // {
539 // if(j-23 <= 0) //A-side
540 // {
541 // ampFOR[10] += emcalCell [i][j];
542 // ampL0[10] += emcalTrigL0[i][j];
543 // ampL1[10] += emcalTrigL1[i][j];
544 // }
545 // else //C-side
546 // {
547 // ampFOR[25] += emcalCell [i][j];
548 // ampL0[25] += emcalTrigL0[i][j];
549 // ampL1[25] += emcalTrigL1[i][j];
550 // }
551 // }
552 // else if (i > 44 && i < 48)
553 // {
554 // if(j-23 <= 0) //A-side
555 // {
556 // ampFOR[11] += emcalCell [i][j];
557 // ampL0[11] += emcalTrigL0[i][j];
558 // ampL1[11] += emcalTrigL1[i][j];
559 // }
560 // else //C-side
561 // {
562 // ampFOR[26] += emcalCell [i][j];
563 // ampL0[26] += emcalTrigL0[i][j];
564 // ampL1[26] += emcalTrigL1[i][j];
565 // }
566 // }
567 // else if (i > 48 && i < 52)
568 // {
569 // if(j-23 <= 0) //A-side
570 // {
571 // ampFOR[12] += emcalCell [i][j];
572 // ampL0[12] += emcalTrigL0[i][j];
573 // ampL1[12] += emcalTrigL1[i][j];
574 // }
575 // else //C-side
576 // {
577 // ampFOR[27] += emcalCell [i][j];
578 // ampL0[27] += emcalTrigL0[i][j];
579 // ampL1[27] += emcalTrigL1[i][j];
580 // }
581 // }
582 // else if (i > 52 && i < 56)
583 // {
584 // if(j-23 <= 0) //A-side
585 // {
586 // ampFOR[13] += emcalCell [i][j];
587 // ampL0[13] += emcalTrigL0[i][j];
588 // ampL1[13] += emcalTrigL1[i][j];
589 // }
590 // else //C-side
591 // {
592 // ampFOR[28] += emcalCell [i][j];
593 // ampL0[28] += emcalTrigL0[i][j];
594 // ampL1[28] += emcalTrigL1[i][j];
595 // }
596 // }
597 // else if (i > 56 && i < 60)
598 // {
599 // if(j-23 <= 0) //A-side
600 // {
601 // ampFOR[14] += emcalCell [i][j];
602 // ampL0[14] += emcalTrigL0[i][j];
603 // ampL1[14] += emcalTrigL1[i][j];
604 // }
605 // else //C-side
606 // {
607 // ampFOR[29] += emcalCell [i][j];
608 // ampL0[29] += emcalTrigL0[i][j];
609 // ampL1[29] += emcalTrigL1[i][j];
610 // }
611 // }
612
613 // }
614 // }
615
616 for (Int_t i = 0; i < 30; i++)
617 {
618 if (ampFOR[i] != 0 && ampL1[i] != 0) fhFEESTU[i]->Fill(ampL1[i]/ampFOR[i]);
619 if (ampL0[i] != 0 && ampL1[i] != 0) fhTRUSTU[i]->Fill(ampL1[i]/ampL0[i]);
620 }
621
622 // Int_t TRUCheck[30] = {1};
623 // Int_t STUCheck[30] = {1};
624 // for (Int_t i = 0; i < 30; i++)
625 // {
626 // if (fhTRUSTU[i]->GetEntries()>0) if(fhTRUSTU[i]->Integral(10,20)/fhTRUSTU[i]->GetEntries() < 0.9) STUCheck[i] = 0;
627 // if (fhTRUSTU[i]->GetEntries()==0) STUCheck[i] = 0;
628 // }
629
630 // for (Int_t i = 0; i < 30; i++)
631 // {
632 // if (i<15) fhSTUChecks->Fill(0.,i,STUCheck[i]);
633 // else fhSTUChecks->Fill(1.,i,STUCheck[i]);
634 // }
635
636 PostData(1, fOutputList);
637
638}
639