HitMaps.cxx
Go to the documentation of this file.
1 #include <iostream>
2 #include <cmath>
3 #include "TH1F.h"
4 #include "TH2F.h"
5 #include "DAQChannelMap/HardwareDisplay.h"
13 
14 
15 using namespace om;
16 class RawEventSummary;
17 class DataBlockSummary;
18 class MicroSliceSummary;
19 
20 //static const unsigned int kADC_ERROR = 0xFFFFFFFF;
21 
24  fHwMap(new daqchannelmap::HardwareDisplay)
25 {
27 
28  for(unsigned int i = 0; i < PixelsDCM_size; ++i) {
29  for(unsigned int j = 0; j < PixelsDCM_size; ++j) {
30  fPixelsRateDCM[i][j] = 0;
31  fLowADCPixelsRateDCM[i][j] = 0;
32  fMipADCPixelsRateDCM[i][j] = 0;
34  fPixelsDCM[i][j] = 0;
35  fLowADCPixelsDCM[i][j] = 0;
36  fMipADCPixelsDCM[i][j] = 0;
37  fHighADCPixelsDCM[i][j] = 0;
38  fMinADCPixelsDCM[i][j] = 0;
39  fMaxADCPixelsDCM[i][j] = 0;
40  fTotADCPixelsDCM[i][j] = 0;
41  } // end for j
42  } // end for i
43 
45 
46  fHitMapEvtCount = h.GetTH1F("HitMapEvtCount");
47  fRecordedTime = h.GetTH1F("RecordedTime");
48  fDCMHitRateMap = h.GetTH2F("DCMHitRateMap");
49  fDCMHitRateSpectrum = h.GetTH1F("DCMHitRateSpectrum");
50  fDCMHitRateMapLowADC = h.GetTH2F("DCMHitRateMapLowADC");
51  fDCMHitRateMapMipADC = h.GetTH2F("DCMHitRateMapMipADC");
52  fDCMHitRateMapHighADC = h.GetTH2F("DCMHitRateMapHighADC");
53  fFEBHitRateMap = h.GetTH2F("FEBHitRateMap");
54  fFEBHitRateSpectrum = h.GetTH1F("FEBHitRateSpectrum");
55  fFEBHitRateMapLowADC = h.GetTH2F("FEBHitRateMapLowADC");
56  fFEBHitRateMapMipADC = h.GetTH2F("FEBHitRateMapMipADC");
57  fFEBHitRateMapHighADC = h.GetTH2F("FEBHitRateMapHighADC");
58 
59  fPixelHitMap = h.GetTH2F("PixelHitMap");
60  fPixelHitMapLowADC = h.GetTH2F("PixelHitMapLowADC");
61  fPixelHitMapMipADC = h.GetTH2F("PixelHitMapMipADC");
62  fPixelHitMapHighADC = h.GetTH2F("PixelHitMapHighADC");
63  fPixelHitRateMap = h.GetTH2F("PixelHitRateMap");
64  fPixelHitRateMapLowADC = h.GetTH2F("PixelHitRateMapLowADC");
65  fPixelHitRateMapMipADC = h.GetTH2F("PixelHitRateMapMipADC");
66  fPixelHitRateMapHighADC = h.GetTH2F("PixelHitRateMapHighADC");
67  fPixelHitRateSpectrum = h.GetTH1F("PixelHitRateSpectrum");
68 
69  fDCMHitMap = h.GetTH2F("DCMHitMap");
70  fDCMHitMapLowADC = h.GetTH2F("DCMHitMapLowADC");
71  fDCMHitMapMipADC = h.GetTH2F("DCMHitMapMipADC");
72  fDCMHitMapHighADC = h.GetTH2F("DCMHitMapHighADC");
73  fFEBHitMap = h.GetTH2F("FEBHitMap");
74  fFEBHitMapLowADC = h.GetTH2F("FEBHitMapLowADC");
75  fFEBHitMapMipADC = h.GetTH2F("FEBHitMapMipADC");
76  fFEBHitMapHighADC = h.GetTH2F("FEBHitMapHighADC");
77  fPlaneCellHitMapXviewAllHits = h.GetTH2F("PlaneCellHitMapXviewAllHits");
78  fPlaneCellHitMapYviewAllHits = h.GetTH2F("PlaneCellHitMapYviewAllHits");
79  fPlaneCellHitRateMapXviewAllHits = h.GetTH2F("PlaneCellHitRateMapXviewAllHits");
80  fPlaneCellHitRateMapYviewAllHits = h.GetTH2F("PlaneCellHitRateMapYviewAllHits");
81 
82  if(Settings::Instance().fDet == kNDOS) {
83  fPlaneCellHitMapXviewCalib = h.GetTH2F("PlaneCellHitMapXviewCalib");
84  fPlaneCellHitMapYviewCalib = h.GetTH2F("PlaneCellHitMapYviewCalib");
85  fPlaneCellHitMapXviewNuMI = h.GetTH2F("PlaneCellHitMapXviewNuMI");
86  fPlaneCellHitMapYviewNuMI = h.GetTH2F("PlaneCellHitMapYviewNuMI");
87  fPlaneCellHitMapXviewBNB = h.GetTH2F("PlaneCellHitMapXviewBNB");
88  fPlaneCellHitMapYviewBNB = h.GetTH2F("PlaneCellHitMapYviewBNB");
89  }
90  if(Settings::Instance().fDet == kNEARDET) {
91  fPlaneCellHitMapXviewCalib = h.GetTH2F("PlaneCellHitMapXviewCalib");
92  fPlaneCellHitMapYviewCalib = h.GetTH2F("PlaneCellHitMapYviewCalib");
93  fPlaneCellHitMapXviewNuMI = h.GetTH2F("PlaneCellHitMapXviewNuMI");
94  fPlaneCellHitMapYviewNuMI = h.GetTH2F("PlaneCellHitMapYviewNuMI");
95  }
96 
97  fTotADCFEBHitMap = h.GetTH2F("TotADCFEBHitMap");
98 
99  fFEBShutOff = h.GetTH2F("FEBShutOff");
100  fFEBShutOffBookKeeping1 = h.GetTH2F("FEBShutOffBookKeeping1");
101  fFEBShutOffBookKeeping2 = h.GetTH2F("FEBShutOffBookKeeping2");
102 }
103 
104 //......................................................................
105 
107  if (fHwMap) {delete fHwMap; fHwMap = 0;}
108 }
109 
110 //......................................................................
111 
113  const DataBlockSummary& dbs,
114  const MicroSliceSummary& mss,
115  const NanoSliceSummary& nss)
116 {
118 
119  //
120  // fill hit map event counter //
121  static unsigned int lastRun=0, lastEvent=0;
122  static const double secPerRange = 5E-7; // fRange is in units of 500nsec
123  unsigned int dropout_interval=0;
124  if(Settings::Instance().fDet == kNEARDET) dropout_interval = 1000;
125  else dropout_interval = 100;
126 
127  if(lastRun!=r.fRun || lastEvent!=r.fEvent) {
128  double nEvents = fHitMapEvtCount->Integral();
129  double recordedSec = (fRecordedTime->Integral())*secPerRange;
130 
131  if((int)nEvents%100 == 0 && recordedSec != 0.0){
132 
133  // Compute rate plots.
148  fDCMHitRateMap ->Scale(1.0/recordedSec);
149  fDCMHitRateMapLowADC ->Scale(1.0/recordedSec);
150  fDCMHitRateMapMipADC ->Scale(1.0/recordedSec);
151  fDCMHitRateMapHighADC ->Scale(1.0/recordedSec);
152  fFEBHitRateMap ->Scale(1.0/recordedSec);
153  fPixelHitRateMap ->Scale(1.0/recordedSec);
154  fPixelHitRateMapLowADC ->Scale(1.0/recordedSec);
155  fPixelHitRateMapMipADC ->Scale(1.0/recordedSec);
156  fPixelHitRateMapHighADC ->Scale(1.0/recordedSec);
157  fFEBHitRateMapLowADC ->Scale(1.0/recordedSec);
158  fFEBHitRateMapMipADC ->Scale(1.0/recordedSec);
159  fFEBHitRateMapHighADC ->Scale(1.0/recordedSec);
160  fPlaneCellHitRateMapXviewAllHits->Scale(1.0/recordedSec);
161  fPlaneCellHitRateMapYviewAllHits->Scale(1.0/recordedSec);
162 
163  // Compute rate spectra.
164  fPixelHitRateSpectrum->Reset();
165  fFEBHitRateSpectrum ->Reset();
166  fDCMHitRateSpectrum ->Reset();
167  for(int i = 1; i <= fPixelHitRateMap->GetNbinsX(); ++i) {
168  for(int j = 1; j <= fPixelHitRateMap->GetNbinsY(); ++j) {
169  double rate = fPixelHitRateMap->GetBinContent(fPixelHitRateMap->GetBin(i,j));
170  if(rate > 0.0)
171  rate = log10(rate);
172  else
173  rate = -100.0;
174  fPixelHitRateSpectrum->Fill(rate);
175  }
176  }
177  for(int i = 1; i <= fFEBHitRateMap->GetNbinsX(); ++i) {
178  for(int j = 1; j <= fFEBHitRateMap->GetNbinsY(); ++j) {
179  double rate = fFEBHitRateMap->GetBinContent(fFEBHitRateMap->GetBin(i,j));
180  if(rate > 0.0)
181  rate = log10(rate);
182  else
183  rate = -100.0;
184  fFEBHitRateSpectrum->Fill(rate);
185  }
186  }
187  for(int i = 1; i <= fDCMHitRateMap->GetNbinsX(); ++i) {
188  for(int j = 1; j <= fDCMHitRateMap->GetNbinsY(); ++j) {
189  double rate = fDCMHitRateMap->GetBinContent(fDCMHitRateMap->GetBin(i,j));
190  if(rate > 0.0)
191  rate = log10(rate);
192  else
193  rate = -100.0;
194  fDCMHitRateSpectrum->Fill(rate);
195  }
196  }
197 
198  for(unsigned int i = 0; i < PixelsDCM_size; ++i) {
199  for(unsigned int j = 0; j < PixelsDCM_size; ++j) {
200  if(fPixelsDCM[i][j]!=0){
201  if(fPixelsRateDCM[i][j]==0){
202  char histoname[30];
203  sprintf(histoname, "PixelsRateDCM_%.2u_%.2u", i, j);
204  fPixelsRateDCM[i][j] = h.GetTH2F(histoname);
205  }
207  fPixelsRateDCM[i][j]->Scale(1/recordedSec);
208  }
209  if(fLowADCPixelsDCM[i][j]!=0){
210  if(fLowADCPixelsRateDCM[i][j]==0){
211  char histoname[30];
212  sprintf(histoname, "LowADCPixelsRateDCM_%.2u_%.2u", i, j);
213  fLowADCPixelsRateDCM[i][j] = h.GetTH2F(histoname);
214  }
216  fLowADCPixelsRateDCM[i][j]->Scale(1/recordedSec);
217  }
218  if(fMipADCPixelsDCM[i][j]!=0){
219  if(fMipADCPixelsRateDCM[i][j]==0){
220  char histoname[30];
221  sprintf(histoname, "MipADCPixelsRateDCM_%.2u_%.2u", i, j);
222  fMipADCPixelsRateDCM[i][j] = h.GetTH2F(histoname);
223  }
225  fMipADCPixelsRateDCM[i][j]->Scale(1/recordedSec);
226  }
227  if(fHighADCPixelsDCM[i][j]!=0){
228  if(fHighADCPixelsRateDCM[i][j]==0){
229  char histoname[30];
230  sprintf(histoname, "HighADCPixelsRateDCM_%.2u_%.2u", i, j);
231  fHighADCPixelsRateDCM[i][j] = h.GetTH2F(histoname);
232  }
234  fHighADCPixelsRateDCM[i][j]->Scale(1/recordedSec);
235  }
236  } // end for j
237  } // end for i
238  //
239  }
240 
241  //
242  // Do the periodic check to see if there have been and FEB
243  // shutoffs.
244  //
245  if((int)nEvents%dropout_interval == 0 && recordedSec != 0.0){
246  this->EvalFEBShutOff();
247  }
248 
249  fHitMapEvtCount->Fill(0);
250  double range = (double)r.fRange;
251 
252  // Adjust the range due to the fact that we always get any micro blocks
253  // that touch the edge of the trigger range.
254  range = 100.0*floor(range/100.0)+100.0;
255 
256  fRecordedTime->Fill(0.0,range);
257 
258  }
259 
260  lastRun = r.fRun;
261  lastEvent = r.fEvent;
262 
263  //
264  // fill hit maps for entire detector
265  //
266  fDCMHitMap-> Fill(nss.fHdwX, nss.fHdwY);
267  fFEBHitMap-> Fill(nss.fHdwX, nss.fHdwY);
268  fFEBShutOffBookKeeping1->Fill(nss.fHdwX, nss.fHdwY);
269  fPixelHitMap-> Fill(nss.fHdwX, nss.fHdwY);
270 
271  if (nss.fView == daqchannelmap::X_VIEW) {
272  //
273  // The plane/cell maps are made to match the hardware views.
274  // So X and Z are reversed but Y is not.
275  //
276  double P = (-1.0)*(nss.fPlane);
277  double C = (-1.0)*(nss.fCell);
278  fPlaneCellHitMapXviewAllHits->Fill(P,C);
279  if(Settings::Instance().fDet == kNDOS) {
280  if(r.fTrigger == 0) fPlaneCellHitMapXviewNuMI ->Fill(P,C);
281  if(r.fTrigger == 1) fPlaneCellHitMapXviewBNB ->Fill(P,C);
282  if(r.fTrigger == 2) fPlaneCellHitMapXviewCalib->Fill(P,C);
283  }
284  if(Settings::Instance().fDet == kNEARDET) {
285  if(r.fTrigger == 0) fPlaneCellHitMapXviewNuMI ->Fill(P,C);
286  if(r.fTrigger == 2) fPlaneCellHitMapXviewCalib->Fill(P,C);
287  }
288  }
289 
290  if(nss.fView == daqchannelmap::Y_VIEW) {
291  //
292  // The plane/cell maps are made to match the hardware views.
293  // So X and Z are reversed but Y is not.
294  //
295  double P = (-1.0)*(nss.fPlane);
296  double C = ( 1.0)*(nss.fCell);
297  fPlaneCellHitMapYviewAllHits->Fill(P,C);
298  if(Settings::Instance().fDet == kNDOS) {
299  if(r.fTrigger == 0) fPlaneCellHitMapYviewNuMI ->Fill(P,C);
300  if(r.fTrigger == 1) fPlaneCellHitMapYviewBNB ->Fill(P,C);
301  if(r.fTrigger == 2) fPlaneCellHitMapYviewCalib->Fill(P,C);
302  }
303  if(Settings::Instance().fDet == kNEARDET) {
304  if(r.fTrigger == 0) fPlaneCellHitMapYviewNuMI ->Fill(P,C);
305  if(r.fTrigger == 2) fPlaneCellHitMapYviewCalib->Fill(P,C);
306  }
307  }
308 
309  unsigned int lowADC = 175;
310  unsigned int highADC = 3200;
311 
312  if(nss.fADC < lowADC) {
313  fDCMHitMapLowADC ->Fill(nss.fHdwX, nss.fHdwY);
314  fFEBHitMapLowADC ->Fill(nss.fHdwX, nss.fHdwY);
315  fPixelHitMapLowADC ->Fill(nss.fHdwX, nss.fHdwY);
316  }
317  if(nss.fADC > highADC) {
318  fDCMHitMapHighADC->Fill(nss.fHdwX, nss.fHdwY);
319  fFEBHitMapHighADC->Fill(nss.fHdwX, nss.fHdwY);
320  fPixelHitMapHighADC->Fill(nss.fHdwX, nss.fHdwY);
321  }
322  if(nss.fADC >= lowADC && nss.fADC <= highADC) {
323  fDCMHitMapMipADC->Fill(nss.fHdwX, nss.fHdwY);
324  fFEBHitMapMipADC->Fill(nss.fHdwX, nss.fHdwY);
325  fPixelHitMapMipADC->Fill(nss.fHdwX, nss.fHdwY);
326  }
327 
328  //
329  // fill hit maps for individual DCMs
330  //
331  if(fPixelsDCM[mss.fDiblock][mss.fDCM] == 0) {
332  char histoname[64];
333  sprintf(histoname, "PixelsDCM_%.2u_%.2u", mss.fDiblock, mss.fDCM);
334  fPixelsDCM[mss.fDiblock][mss.fDCM] = h.GetTH2F(histoname);
335  }
336 
337  unsigned int x1, x2, y1, y2;
338  fHwMap->FEBXY(nss.fFEB, &x1, &y1);
339  fHwMap->PixXY(nss.fPix, &x2, &y2);
340  fPixelsDCM[mss.fDiblock][mss.fDCM]->Fill(x1+x2, y1+y2);
341 
342  // this could later be put with the above ifs to consolidate
343  if(nss.fADC < lowADC) {
344  if(fLowADCPixelsDCM[mss.fDiblock][mss.fDCM] == 0) {
345  char histoname[64];
346  sprintf(histoname, "LowADCPixelsDCM_%.2u_%.2u", mss.fDiblock, mss.fDCM);
347  fLowADCPixelsDCM[mss.fDiblock][mss.fDCM] = h.GetTH2F(histoname);
348  }
349 
350  unsigned int x3, x4, y3, y4;
351  fHwMap->FEBXY(nss.fFEB, &x3, &y3);
352  fHwMap->PixXY(nss.fPix, &x4, &y4);
353  fLowADCPixelsDCM[mss.fDiblock][mss.fDCM]->Fill(x3+x4, y3+y4);
354  }
355 
356  if(nss.fADC > highADC) {
357  if(fHighADCPixelsDCM[mss.fDiblock][mss.fDCM] == 0) {
358  char histoname[64];
359  sprintf(histoname, "HighADCPixelsDCM_%.2u_%.2u", mss.fDiblock, mss.fDCM);
360  fHighADCPixelsDCM[mss.fDiblock][mss.fDCM] = h.GetTH2F(histoname);
361  }
362 
363  unsigned int x3, x4, y3, y4;
364  fHwMap->FEBXY(nss.fFEB, &x3, &y3);
365  fHwMap->PixXY(nss.fPix, &x4, &y4);
366  fHighADCPixelsDCM[mss.fDiblock][mss.fDCM]->Fill(x3+x4, y3+y4);
367  }
368 
369  if(nss.fADC >= lowADC && nss.fADC <= highADC) {
370  if(fMipADCPixelsDCM[mss.fDiblock][mss.fDCM] == 0) {
371  char histoname[64];
372  sprintf(histoname, "MipADCPixelsDCM_%.2u_%.2u", mss.fDiblock, mss.fDCM);
373  fMipADCPixelsDCM[mss.fDiblock][mss.fDCM] = h.GetTH2F(histoname);
374  }
375 
376  unsigned int x3, x4, y3, y4;
377  fHwMap->FEBXY(nss.fFEB, &x3, &y3);
378  fHwMap->PixXY(nss.fPix, &x4, &y4);
379  fMipADCPixelsDCM[mss.fDiblock][mss.fDCM]->Fill(x3+x4, y3+y4);
380  }
381 
382  //
383  // Fill the Min ADC plots
384  //
385  if(fMinADCPixelsDCM[mss.fDiblock][mss.fDCM] == 0) {
386  char histoname[64];
387  sprintf(histoname, "MinADCPixelsDCM_%.2u_%.2u", mss.fDiblock, mss.fDCM);
388  fMinADCPixelsDCM[mss.fDiblock][mss.fDCM] = h.GetTH2F(histoname);
389  }
390 
391  unsigned int bin = fMinADCPixelsDCM[mss.fDiblock][mss.fDCM]->FindBin(x1+x2,y1+y2);
392  unsigned int content = fMinADCPixelsDCM[mss.fDiblock][mss.fDCM]->GetBinContent(bin);
393 
394  if(content == 0 || nss.fADC < content)
395  fMinADCPixelsDCM[mss.fDiblock][mss.fDCM]->SetBinContent(bin,nss.fADC);
396 
397  //
398  // Fill the Max ADC plots
399  //
400  if(fMaxADCPixelsDCM[mss.fDiblock][mss.fDCM] == 0) {
401  char histoname[64];
402  sprintf(histoname, "MaxADCPixelsDCM_%.2u_%.2u", mss.fDiblock, mss.fDCM);
403  fMaxADCPixelsDCM[mss.fDiblock][mss.fDCM] = h.GetTH2F(histoname);
404  }
405 
406  bin = fMaxADCPixelsDCM[mss.fDiblock][mss.fDCM]->FindBin(x1+x2,y1+y2);
407  content = fMaxADCPixelsDCM[mss.fDiblock][mss.fDCM]->GetBinContent(bin);
408 
409  if(nss.fADC > content)
410  fMaxADCPixelsDCM[mss.fDiblock][mss.fDCM]->SetBinContent(bin,nss.fADC);
411 
412  //
413  // Fill the Total ADC plots
414  //
415  if(fTotADCPixelsDCM[mss.fDiblock][mss.fDCM] == 0) {
416  char histoname[64];
417  sprintf(histoname, "TotADCPixelsDCM_%.2u_%.2u", mss.fDiblock, mss.fDCM);
418  fTotADCPixelsDCM[mss.fDiblock][mss.fDCM] = h.GetTH2F(histoname);
419  }
420 
421  fTotADCPixelsDCM[mss.fDiblock][mss.fDCM]->Fill(x1+x2,y1+y2,nss.fADC);
422  fTotADCFEBHitMap->Fill(nss.fHdwX,nss.fHdwY,nss.fADC);
423 }
424 
425 //......................................................................
426 
428 {
429  int i, j;
430  double now, then;
431  for (i=1; i<=fFEBShutOffBookKeeping1->GetNbinsX(); ++i) {
432  for (j=1; j<=fFEBShutOffBookKeeping1->GetNbinsY(); ++j) {
433  now = fFEBShutOffBookKeeping1->GetBinContent(i,j);
434  if (now<1.0) {
435  then = fFEBShutOffBookKeeping2->GetBinContent(i,j);
436  if (then>0.0) {
437  int ib = fFEBShutOff->GetBin(i,j);
438  double c = fFEBShutOff->GetBinContent(ib);
439  fFEBShutOff->SetBinContent(ib,c+1.0);
440  }
441  }
442  }
443  }
446  fFEBShutOffBookKeeping1->Reset();
447 }
448 
449 //......................................................................
450 
451 void HitMaps::CopyHistContent(TH2F*& histFrom,
452  TH2F*& histTo)
453 {
454  // Copy histogram content only
455  // *Assumes same binning for both histograms
456  //
457  int NbinsX = histFrom->GetNbinsX();
458  int NbinsY = histFrom->GetNbinsY();
459  for(int i=0;i<NbinsX+2;i++){
460  for(int j=0;j<NbinsY+2;j++){
461  double content = histFrom->GetBinContent(i, j);
462  histTo->SetBinContent(i,j, content);
463  }
464  }
465 }
466 
467 ////////////////////////////////////////////////////////////////////////
TH2F * fPixelHitRateMapLowADC
Definition: HitMaps.h:52
TH2F * fPlaneCellHitMapXviewAllHits
Definition: HitMaps.h:65
TH2F * fPlaneCellHitMapYviewBNB
Definition: HitMaps.h:74
unsigned int fDCM
DCM ID.
TH2F * fDCMHitRateMap
Definition: HitMaps.h:35
TH2F * fFEBHitRateMapMipADC
Definition: HitMaps.h:44
TH2F * fPixelHitMapMipADC
Definition: HitMaps.h:49
Float_t y1[n_points_granero]
Definition: compare.C:5
unsigned int fHdwX
location of channel in "hardware display" space
unsigned int fDiblock
Diblock ID.
TH1F * GetTH1F(const char *nm)
Definition: HistoSet.cxx:68
TH2F * fPixelHitMapLowADC
Definition: HitMaps.h:48
Float_t x1[n_points_granero]
Definition: compare.C:5
TH2F * fDCMHitRateMapLowADC
Definition: HitMaps.h:37
TH2F * fPixelHitRateMapHighADC
Definition: HitMaps.h:54
static const unsigned int PixelsDCM_size
TH2F * fFEBShutOffBookKeeping2
Definition: HitMaps.h:93
TH2F * fFEBShutOffBookKeeping1
Definition: HitMaps.h:92
TH2F * fDCMHitRateMapHighADC
Definition: HitMaps.h:39
TH2F * fPlaneCellHitMapXviewBNB
Definition: HitMaps.h:73
unsigned int fPix
Pixel number on FEB.
TH1F * fHitMapEvtCount
Definition: HitMaps.h:33
void CopyHistContent(TH2F *&histFrom, TH2F *&histTo)
Definition: HitMaps.cxx:451
All the interesting event-level data.
TH2F * fDCMHitMap
Definition: HitMaps.h:57
unsigned int fEvent
Event nunber.
TH2F * fFEBHitMapMipADC
Definition: HitMaps.h:63
Identifier for the Y measuring view of the detector (side)
unsigned int fRange
Trigger length in units of 500 nsec.
#define P(a, b, c, d, e, x)
TH2F * fTotADCPixelsDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:88
const double C
TH2F * fDCMHitMapLowADC
Definition: HitMaps.h:58
TH2F * fPixelHitMap
Definition: HitMaps.h:47
TH2F * fTotADCFEBHitMap
Definition: HitMaps.h:89
virtual void GetNanoSliceSummary(const RawEventSummary &r, const DataBlockSummary &dbs, const MicroSliceSummary &mss, const NanoSliceSummary &nss)
Interface to the nanoslice summary.
Definition: HitMaps.cxx:112
TH2F * fLowADCPixelsRateDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:77
TH2F * fFEBHitMapLowADC
Definition: HitMaps.h:62
TH2F * fDCMHitMapMipADC
Definition: HitMaps.h:59
TH2F * fDCMHitMapHighADC
Definition: HitMaps.h:60
Float_t E
Definition: plot.C:20
TH2F * fFEBShutOff
Definition: HitMaps.h:91
TH2F * fPixelHitRateMapMipADC
Definition: HitMaps.h:53
correl_yv Fill(-(dy[iP-1][iC-1]), hyv->GetBinContent(iP, iC))
TH2F * GetTH2F(const char *nm)
Definition: HistoSet.cxx:89
TH2F * fHighADCPixelsDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:84
TH2F * fPlaneCellHitMapXviewCalib
Definition: HitMaps.h:69
unsigned int fRun
Run number.
Identifier for the X measuring view of the detector (top)
TH2F * fFEBHitMapHighADC
Definition: HitMaps.h:64
TH2F * fPlaneCellHitMapYviewAllHits
Definition: HitMaps.h:66
TH2F * fPixelsDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:81
const double j
Definition: BetheBloch.cxx:29
daqchannelmap::HardwareDisplay * fHwMap
Definition: HitMaps.h:31
unsigned int fCell
cell number of hit
TH1F * fFEBHitRateSpectrum
Definition: HitMaps.h:42
float bin[41]
Definition: plottest35.C:14
A simple object that conatins all the global settings.
TH2F * fFEBHitMap
Definition: HitMaps.h:61
TH2F * fPlaneCellHitMapYviewCalib
Definition: HitMaps.h:70
TH2F * fPixelHitRateMap
Definition: HitMaps.h:51
TH2F * fPixelsRateDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:76
TH2F * fHighADCPixelsRateDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:79
void FEBXY(unsigned int feb, unsigned int *ix, unsigned int *iy)
unsigned int fADC
Charge of hit in TDC units.
TH2F * fPlaneCellHitRateMapYviewAllHits
Definition: HitMaps.h:68
daqchannelmap::DetView_TYPE fView
in which view was the hit
TH1F * fPixelHitRateSpectrum
Definition: HitMaps.h:55
TH2F * fFEBHitRateMap
Definition: HitMaps.h:41
TH2F * fPlaneCellHitMapYviewNuMI
Definition: HitMaps.h:72
TH1F * fDCMHitRateSpectrum
Definition: HitMaps.h:36
T log10(T number)
Definition: d0nt_math.hpp:120
TH2F * fPlaneCellHitMapXviewNuMI
Definition: HitMaps.h:71
TH2F * fPixelHitMapHighADC
Definition: HitMaps.h:50
TH2F * fMipADCPixelsDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:83
unsigned int fPlane
plane number of hit
unsigned int fTrigger
Trigger type.
fvar< T > floor(const fvar< T > &x)
Definition: floor.hpp:11
unsigned int fHdwY
location of channel in "hardware display" space
TRandom3 r(0)
TH2F * fFEBHitRateMapLowADC
Definition: HitMaps.h:43
unsigned int fFEB
FEB number of nanoslice (aka "hit")
TH2F * fPlaneCellHitRateMapXviewAllHits
Definition: HitMaps.h:67
static HistoSet & Instance()
Definition: HistoSet.cxx:24
TH2F * fMipADCPixelsRateDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:78
void EvalFEBShutOff()
Definition: HitMaps.cxx:427
TH2F * fMaxADCPixelsDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:87
TH2F * fMinADCPixelsDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:86
TH1F * fRecordedTime
Definition: HitMaps.h:34
Hold the collection of histograms created by the producer.
All the interesting event-level data.
static Settings & Instance()
Definition: Settings.cxx:12
Online Monitoring package header.
TH2F * fFEBHitRateMapHighADC
Definition: HitMaps.h:45
void PixXY(unsigned int pix, unsigned int *ix, unsigned int *iy)
TH2F * fLowADCPixelsDCM[PixelsDCM_size][PixelsDCM_size]
Definition: HitMaps.h:82
TH2F * fDCMHitRateMapMipADC
Definition: HitMaps.h:38
All the interesting event-level data.