HitsAna_module.cc
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////
2 // Class: HitsAna
3 // Module Type: analyzer
4 // File: HitsAna_module.cc
5 //
6 // Generated at Thu Apr 10 02:56:14 2014 by Matthew Tamsett using artmod
7 // from cetpkgsupport v1_04_02.
8 ////////////////////////////////////////////////////////////////////////
9 
17 #include "fhiclcpp/ParameterSet.h"
18 
24 
25 #include "RawData/RawTrigger.h"
26 
28 #include "TH1.h"
29 #include "TH2.h"
30 #include "TVector3.h"
31 
32 // using unsigned long long rather than uint64_t to ensure consistent behavior on OSX and LINUX
33 
34 //---------------------------------------------------------------------
35 namespace novaddt {
36  class HitsAna;
37 }
38 //---------------------------------------------------------------------
40  public:
41  explicit HitsAna(fhicl::ParameterSet const & p);
42  virtual ~HitsAna();
43  void analyze(art::Event const & e) override;
44  void endJob() override;
45  std::vector<novaddt::HitList> HitFormatConsolidation(art::Event const & event);
46  void AnalyzeHitLists(std::vector<novaddt::HitList> hit_lists, unsigned long long event_time);
47  void FillHitDensitiesInTDCWindow(std::vector<int> TDC_vals, int minTDC, int maxTDC, int window_size, int overlap, TH1F* histogram);
48  private:
49  // Declare member data here.
50  // FHiCL parameters
51  std::string _hitsModuleLabel; ///< label of module making the Hits
52  std::string _hitsInstanceLabel; ///< instance label making the Hits
53  std::string _hitsFormat; ///< The format to expect the hits in, can be one of HitList, Grouped, Vector
54  std::string _rawDigitLabel; ///< label of where to find Raw Digits
55  bool _verbose; ///< Verbose output
56  // counters
57  unsigned int _nEvents = 0;
58  unsigned int _nSlices = 0;
59  unsigned int _nHits = 0;
60  // Plots
61  TH1F* hCutFlow;
62  TH1F* hNSlices;
64  TH1F* hAllNHits;
65  TH1F* hAllNHitsXZ;
66  TH1F* hAllNHitsYZ;
67  TH1F* hNHits;
68  TH1F* hNHits_wide;
69  TH1F* hNHitsXZ;
70  TH1F* hNHitsYZ;
71  TH1F* hX;
72  TH1F* hY;
73  TH1F* hYZ;
74  TH1F* hXZ;
75  TH1F* hdX;
76  TH1F* hdY;
77  TH1F* hdZ;
78  TH1F* hdXUnit;
79  TH1F* hdYUnit;
80  TH1F* hdZUnit;
81  TH1F* hXMin;
82  TH1F* hXMax;
83  TH1F* hYMin;
84  TH1F* hYMax;
85  TH1F* hZMin;
86  TH1F* hZMax;
87  TH1F* hADC;
88  TH1F* hSumADC;
89  TH1F* hMeanADC;
90  TH1F* hTDC;
91  TH1F* hTDC_wide;
92  TH1F* hdTDC;
93  TH1F* hMeanTDC;
95  TH1F* hHit_max_dZ;
96  TH1F* hHit_max_dX;
97  TH1F* hHit_max_dY;
98  TH1F* hHit_dTDC;
99  TH1F* hHit_dZ;
100  TH1F* hHit_dX;
101  TH1F* hHit_dY;
107 };
108 //---------------------------------------------------------------------
110  EDAnalyzer(p)
111  , _hitsModuleLabel (p.get<std::string >("HitsModuleLabel" ))
112  , _hitsInstanceLabel (p.get<std::string >("HitsInstanceLabel"))
113  , _hitsFormat (p.get<std::string >("HitsFormat"))
114  , _rawDigitLabel (p.get< std::string >("RawDigitLabel"))
115  , _verbose (p.get< bool >("Verbose"))
116 {
117  std::cout << "--- novaddt::HitsAna instantiate " << std::endl;
118  std::cout << "\t HitsModuleLabel: " << _hitsModuleLabel << std::endl;
119  std::cout << "\t HitsInstanceLabel: " << _hitsInstanceLabel << std::endl;
120  std::cout << "\t HitsFormat: " << _hitsFormat << std::endl;
121  std::cout << "\t RawDigitLabel: " << _rawDigitLabel << std::endl;
122  std::cout << "\t Verbose: " << _verbose << std::endl;
123 
124  assert( (_hitsFormat == "HitList") ||
125  (_hitsFormat == "Grouped") ||
126  (_hitsFormat == "Vector")
127  );
128 
130  hCutFlow = tfs->make<TH1F>("CutFlow", ";Cut number;Entries", 21,-.5,20.5);
131  hNSlices = tfs->make<TH1F>("NSlices", ";Number of slices;Entries", 301,-.5,300.5);
132  hNSlices_wide = tfs->make<TH1F>("NSlices_wide", ";Number of slices;Entries", 201,-.5,3000.5);
133  hAllNHits = tfs->make<TH1F>("AllNHits", ";Number of hits per event;Entries", 100,0.,200000.);
134  hAllNHitsXZ = tfs->make<TH1F>("AllNHitsXZ", ";Number of hits XZ per event;Entries", 100,0.,100000);
135  hAllNHitsYZ = tfs->make<TH1F>("AllNHitsYZ", ";Number of hits YZ per event;Entries", 100,0.,100000);
136  hNHits = tfs->make<TH1F>("NHits", ";Number of hits;Entries", 500,-0.5,499.5);
137  hNHits_wide = tfs->make<TH1F>("NHits_wide", ";Number of hits;Entries", 100,0.,1000.);
138  hNHitsXZ = tfs->make<TH1F>("NHitsXZ", ";Number of hits XZ;Entries", 500,-0.5,499.5);
139  hNHitsYZ = tfs->make<TH1F>("NHitsYZ", ";Number of hits YZ;Entries", 500,-0.5,499.5);
140  hX = tfs->make<TH1F>("X", ";X [Cell];Entries", 401,-0.5,400.5);
141  hY = tfs->make<TH1F>("Y", ";Y [Cell];Entries", 401,-0.5,400.5);
142  hXZ = tfs->make<TH1F>("XZ", ";X planes Z;Entries", 102,-2.5,201.5);
143  hYZ = tfs->make<TH1F>("YZ", ";Y planes Z;Entries", 102,-2.5,201.5);
144  hdX = tfs->make<TH1F>("dX", ";dX;Entries", 401,-0.5,401.);
145  hdY = tfs->make<TH1F>("dY", ";dY;Entries", 401,-0.5,401.);
146  hdZ = tfs->make<TH1F>("dZ", ";dZ;Entries", 226,-2.5,449.5);
147  hdXUnit = tfs->make<TH1F>("dXUnit", ";dX unit vector;Entries", 101,-0.01,1.01);
148  hdYUnit = tfs->make<TH1F>("dYUnit", ";dY unit vector;Entries", 101,-0.01,1.01);
149  hdZUnit = tfs->make<TH1F>("dZUnit", ";dZ unit vector;Entries", 101,-0.01,1.01);
150  hXMin = tfs->make<TH1F>("XMin",";Slice box x-min;Entries", 403,-2.5,400.5);
151  hXMax = tfs->make<TH1F>("XMax",";Slice box x-max;Entries", 403,-2.5,400.5);
152  hYMin = tfs->make<TH1F>("YMin",";Slice box y-min;Entries", 403,-2.5,400.5);
153  hYMax = tfs->make<TH1F>("YMax",";Slice box y-max;Entries", 403,-2.5,400.5);
154  hZMin = tfs->make<TH1F>("ZMin",";Slice box z-min;Entries", 226,-2.5,449.5);
155  hZMax = tfs->make<TH1F>("ZMax",";Slice box z-max;Entries", 226,-2.5,449.5);
156  hADC = tfs->make<TH1F>("ADC", ";ADC;Entries", 256,0.5,4096.5);
157  hSumADC = tfs->make<TH1F>("SumADC", ";Sum ADC;Entries", 100,0.,50000.);
158  hMeanADC = tfs->make<TH1F>("MeanADC", ";Mean ADC;Entries", 256,0.5,4096.5);
159  hTDC = tfs->make<TH1F>("TDC", ";TDC of each hit in slice;Entries", 1120,-3220. ,326400.);
160  hTDC_wide = tfs->make<TH1F>("TDC_wide", ";TDC of each hit in slice;Entries", 100, -10000.,400000.);
161  hdTDC = tfs->make<TH1F>("dTDC", ";dTDC of hits in slice;Entries", 129,-0.5,1024.5);
162  hMeanTDC = tfs->make<TH1F>("MeanTDC", ";Mean TDC of hits in slice;Entries", 1120,-3220.,326400);
163  hHit_max_dTDC = tfs->make<TH1F>("Hit_max_dTDC", ";Maximum dTDC between hits in slice;Entries", 200,-0.5,199.5);
164  hHit_max_dX = tfs->make<TH1F>("Hit_max_dX", ";Maximum dX between hits in slice;Entries", 100,-0.5,99.5);
165  hHit_max_dY = tfs->make<TH1F>("Hit_max_dY", ";Maximum dY between hits in slice;Entries", 100,-0.5,99.5);
166  hHit_max_dZ = tfs->make<TH1F>("Hit_max_dZ", ";Maximum dZ between hits in slice;Entries", 100,-0.5,99.5);
167  hHit_dTDC = tfs->make<TH1F>("Hit_dTDC", ";dTDC between hits in slice;Entries", 200,-0.5,199.5);
168  hHit_dX = tfs->make<TH1F>("Hit_dX", ";dX between hits in slice;Entries", 100,-0.5,99.5);
169  hHit_dY = tfs->make<TH1F>("Hit_dY", ";dY between hits in slice;Entries", 100,-0.5,99.5);
170  hHit_dZ = tfs->make<TH1F>("Hit_dZ", ";dZ between hits in slice;Entries", 100,-0.5,99.5);
171  hHitDensity_per_50TDC = tfs->make<TH1F>("HitDensity_per_50TDC", ";Number of hits per 50 TDC;Entries", 100,-0.5,499.5);
172  hHitDensity_per_70TDC = tfs->make<TH1F>("HitDensity_per_70TDC", ";Number of hits per 70 TDC;Entries", 100,-0.5,499.5);
173  hHitDensity_per_100TDC = tfs->make<TH1F>("HitDensity_per_100TDC", ";Number of hits per 100 TDC;Entries", 100,-0.5,499.5);
174 
175  hNHitsZ_vs_X = tfs->make<TH2F>("NHitsZ_vs_X",";Z [plane];X [Cell];Entries", 226,-2.5,449.5,403,-2.5,400.5);
176  hNHitsZ_vs_Y = tfs->make<TH2F>("NHitsZ_vs_Y",";Z [plane];Y [Cell];Entries", 226,-2.5,449.5,403,-2.5,400.5);
177 }
178 //---------------------------------------------------------------------
180 {
181  // Clean up dynamic memory and other resources here.
182 }
183 //---------------------------------------------------------------------
185 {
186  // Implementation of required member function here.
187  if (_verbose) std::cout << "--- novaddt::HitsAna analyze. Event: "
188  << event.id().event()
189  << std::endl;
190  _nEvents++;
191 
192  // Translate whichever format we get our hits list in into a vector of HitLists
193  std::vector<novaddt::HitList> hit_lists = HitFormatConsolidation(event);
194 
195  // Get the event time from the raw trigger
197  event.getByLabel(_rawDigitLabel, RawTriggers);
198  unsigned long long event_time = RawTriggers->at(0).fTriggerTimingMarker_TimeStart;
199 
200  // Now analyse our standard format
201  AnalyzeHitLists(hit_lists, event_time);
202 }
203 //---------------------------------------------------------------------
204 void novaddt::HitsAna::AnalyzeHitLists(std::vector<novaddt::HitList> hit_lists, unsigned long long event_time)
205 {
206  if (_verbose){
207  std::cout << "\tAnalysing hit lists\n";
208  std::cout << "\tconsolidated data into " << hit_lists.size()
209  << " hit lists\n";
210  //unsigned int _nHitList = 0;
211  //for (auto hit_list : hit_lists){
212  //std::cout << "\t\thit list[" << _nHitList
213  //<< "] size: " << hit_list.size()
214  //<< std::endl;
215  //_nHitList++;
216  //} // end of loop on hit lists
217  } // end of verbose
218 
219  // Fill histograms
220  int AllNHits = 0;
221  int AllNHitsXZ = 0;
222  int AllNHitsYZ = 0;
223  for (auto hit_list : hit_lists){
224  _nSlices++;
225  int NHitsXZ = 0;
226  int NHitsYZ = 0;
227  int minX = 0;
228  int minY = 0;
229  int minZ = 0;
230  int maxX = 0;
231  int maxY = 0;
232  int maxZ = 0;
233  int sumADC = 0;
234  int minTDC = 0;
235  int maxTDC = 0;
236  int sumTDC = 0;
237  bool first = true;
238  bool firstX = true;
239  bool firstY = true;
240  std::vector<novaddt::DAQHit> x_hits;
241  std::vector<novaddt::DAQHit> y_hits;
242  std::vector<int> TDC_vals;
243  for (auto hit : hit_list){
244  _nHits++;
245  AllNHits++;
246  // fill hit level histograms
247  hADC->Fill(hit.ADC().val);
248  sumADC = sumADC + hit.ADC().val;
249 
250  int TDC_diff = 0;
251  if (hit.TDC().val<event_time){
252  TDC_diff = -1*(event_time - hit.TDC().val);
253  } else {
254  TDC_diff = (hit.TDC().val - event_time);
255  }
256  TDC_vals.push_back(TDC_diff);
257  hTDC->Fill(TDC_diff);
258  hTDC_wide->Fill(TDC_diff);
259  sumTDC = sumTDC + TDC_diff;
260 
261  if (first){
262  minZ = hit.Plane().val;
263  maxZ = hit.Plane().val;
264  minTDC = TDC_diff;
265  first = false;
266  }
267  if (TDC_diff < minTDC) minTDC = TDC_diff;
268  if (TDC_diff > maxTDC) maxTDC = TDC_diff;
269  if (hit.Plane().val < minZ) minZ = hit.Plane().val;
270  if (hit.Plane().val > maxZ) maxZ = hit.Plane().val;
271 
272  if( hit.View().val == daqchannelmap::X_VIEW ){
273  x_hits.push_back(hit);
274  NHitsXZ++;
275  AllNHitsXZ++;
276  hX->Fill(hit.Cell().val);
277  hXZ->Fill(hit.Plane().val);
278  hNHitsZ_vs_X->Fill(hit.Plane().val, hit.Cell().val);
279  if (firstX){
280  minX = hit.Cell().val;
281  maxX = hit.Cell().val;
282  firstX = false;
283  }
284  if (hit.Cell().val < minX) minX = hit.Cell().val;
285  if (hit.Cell().val > maxX) maxX = hit.Cell().val;
286  } else {
287  y_hits.push_back(hit);
288  NHitsYZ++;
289  AllNHitsYZ++;
290  hY->Fill(hit.Cell().val);
291  hYZ->Fill(hit.Plane().val);
292  hNHitsZ_vs_Y->Fill(hit.Plane().val, hit.Cell().val);
293  if (firstY){
294  minY = hit.Cell().val;
295  maxY = hit.Cell().val;
296  firstY = false;
297  }
298  if (hit.Cell().val < minY) minY = hit.Cell().val;
299  if (hit.Cell().val > maxY) maxY = hit.Cell().val;
300  }
301  } // end of loop on hits
302  // fill slice level histograms
303  hNHits->Fill(hit_list.size());
304  hNHits_wide->Fill(hit_list.size());
305  assert(int(x_hits.size())==NHitsXZ);
306  assert(int(y_hits.size())==NHitsYZ);
307  hNHitsXZ->Fill(NHitsXZ);
308  hNHitsYZ->Fill(NHitsYZ);
309  int dX = maxX - minX;
310  int dY = maxY - minZ;
311  int dZ = maxZ - minZ;
312  hdX->Fill(dX);
313  hdY->Fill(dY);
314  hdZ->Fill(dZ);
315  TVector3 vect(dX,dY,dZ);
316  TVector3 unit = vect.Unit();
317  hdXUnit->Fill(unit.X());
318  hdYUnit->Fill(unit.Y());
319  hdZUnit->Fill(unit.Z());
320  hXMin->Fill(minX);
321  hXMax->Fill(maxX);
322  hYMin->Fill(minY);
323  hYMax->Fill(maxY);
324  hZMin->Fill(minZ);
325  hZMax->Fill(maxZ);
326  hSumADC->Fill(sumADC);
327  hMeanADC->Fill( ((double)sumADC) / ((double)hit_list.size()) );
328  int dTDC = maxTDC - minTDC;
329  hdTDC->Fill(dTDC);
330  hMeanTDC->Fill( ((double)sumTDC) / ((double)hit_list.size()) );
331  // Fill density variables, these often rely on sorting
332  // sort by TDC
333  int max_dTDC = 0;
334  sort(hit_list.begin(), hit_list.end(), CompareDAQHit<TDC>());
335  for (unsigned int i_hit = 0; i_hit < hit_list.size(); ++i_hit){
336  if (i_hit ==0) continue;
337  int this_dTDC = hit_list[i_hit].TDC().val - hit_list[i_hit-1].TDC().val;
338  if (this_dTDC > max_dTDC) max_dTDC = this_dTDC;
339  hHit_dTDC->Fill(this_dTDC);
340  }
341  hHit_max_dTDC->Fill(max_dTDC);
342  // TDC hit density
343  // this is time consuming, so skip it if we don't need it
344  sort(TDC_vals.begin(), TDC_vals.end());
345  FillHitDensitiesInTDCWindow(TDC_vals, minTDC, maxTDC, 50, 10, hHitDensity_per_50TDC);
346  //FillHitDensitiesInTDCWindow(TDC_vals, minTDC, maxTDC, 70, 10, hHitDensity_per_70TDC);
347  //FillHitDensitiesInTDCWindow(TDC_vals, minTDC, maxTDC, 100, 10, hHitDensity_per_100TDC);
348  // sort by Plane
349  int max_dZ = 0;
350  sort(hit_list.begin(), hit_list.end(), CompareDAQHit<Plane>());
351  for (unsigned int i_hit = 0; i_hit < hit_list.size(); ++i_hit){
352  if (i_hit ==0) continue;
353  int this_dZ = hit_list[i_hit].Plane().val - hit_list[i_hit-1].Plane().val;
354  if (this_dZ > max_dZ) max_dZ = this_dZ;
355  hHit_dZ->Fill(this_dZ);
356  }
357  hHit_max_dZ->Fill(max_dZ);
358  // sort by X Cell
359  int max_dX = 0;
360  sort(x_hits.begin(), x_hits.end(), CompareDAQHit<Cell>());
361  for (unsigned int i_hit = 0; i_hit < x_hits.size(); ++i_hit){
362  if (i_hit ==0) continue;
363  int this_dX = x_hits[i_hit].Cell().val - x_hits[i_hit-1].Cell().val;
364  if (this_dX > max_dX) max_dX = this_dX;
365  hHit_dX->Fill(this_dX);
366  }
367  hHit_max_dX->Fill(max_dX);
368  // sort by Y Cell
369  int max_dY = 0;
370  sort(y_hits.begin(), y_hits.end(), CompareDAQHit<Cell>());
371  for (unsigned int i_hit = 0; i_hit < y_hits.size(); ++i_hit){
372  if (i_hit ==0) continue;
373  int this_dY = y_hits[i_hit].Cell().val - y_hits[i_hit-1].Cell().val;
374  if (this_dY > max_dY) max_dY = this_dY;
375  hHit_dY->Fill(this_dY);
376  }
377  hHit_max_dY->Fill(max_dY);
378  } // end of loop on hit lists
379 
380  // fill event level histograms
381  hNSlices->Fill(hit_lists.size());
382  hNSlices_wide->Fill(hit_lists.size());
383  hAllNHits->Fill(AllNHits);
384  hAllNHitsXZ->Fill(AllNHitsXZ);
385  hAllNHitsYZ->Fill(AllNHitsYZ);
386 }
387 //---------------------------------------------------------------------
388 std::vector<novaddt::HitList> novaddt::HitsAna::HitFormatConsolidation(art::Event const & event)
389 {
390  std::vector<novaddt::HitList> hit_lists;
391 
392  if (_hitsFormat == "HitList"){
393  if (_verbose) std::cout << "\tgetting single hit list" << std::endl;
395  event.getByLabel(_hitsModuleLabel, _hitsInstanceLabel, hits);
396  if (_verbose) std::cout << "\tgot " << hits->size() << " hits\n";
397  // copy these out
398  HitList frag(hits->begin(), hits->end());
399  hit_lists.emplace_back(frag);
400  } else if (_hitsFormat == "Grouped"){
401  if (_verbose) std::cout << "\tgetting grouped hit list" << std::endl;
403  event.getByLabel(_hitsModuleLabel, _hitsInstanceLabel, ghits);
404  if (_verbose) std::cout << "\tgot " << ghits->n_groups() << " groups\n";
405  // copy these out
406  for(unsigned int i=0; i<ghits->n_groups(); ++i){
407  HitList frag = ghits->get(i);
408  hit_lists.emplace_back(frag);
409  } // end of loop over groups
410  } else {
411  if (_verbose) std::cout << "\tgetting vector of hit lists" << std::endl;
412  art::Handle<std::vector<HitList> > hit_lists_handle;
413  event.getByLabel(_hitsModuleLabel, _hitsInstanceLabel, hit_lists_handle);
414  if (_verbose) std::cout << "\tgot " << hit_lists_handle->size() << " hit lists\n";
415  // copy these out
416  for (unsigned int i=0; i<hit_lists_handle->size(); ++i){
417  HitList frag(hit_lists_handle->at(i).begin(), hit_lists_handle->at(i).end());
418  hit_lists.emplace_back(frag);
419  } // end of loop over hit lists
420  } // end of hit format consolidation
421 
422  return hit_lists;
423 }
424 //---------------------------------------------------------------------
425 void novaddt::HitsAna::FillHitDensitiesInTDCWindow(std::vector<int> TDC_vals, int minTDC, int maxTDC, int window_size, int overlap, TH1F* histogram)
426 {
427  assert(window_size > overlap);
428 
429  int running_TDC = minTDC;
430  int window_slide = window_size - overlap;
431 
432  while (running_TDC<maxTDC){
433  int this_N_hits = 0;
434  for(auto TDC: TDC_vals){
435  if (TDC < running_TDC) continue;
436  if (TDC > (running_TDC + window_size)) break;
437  this_N_hits++;
438  }
439  histogram->Fill(this_N_hits);
440  running_TDC = running_TDC + window_slide;
441  } // end of while
442 
443  return;
444 }
445 //---------------------------------------------------------------------
447 {
448  std::cout << "--- novaddt::HitsAna endJob " << std::endl;
449  std::cout << "\tNumber of events seen: " << _nEvents << std::endl;
450  std::cout << "\tNumber of slices seen: " << _nSlices << std::endl;
451  std::cout << "\tNumber of hits seen: " << _nHits << std::endl;
452  hCutFlow->SetBinContent(1, _nEvents);
453  hCutFlow->SetBinContent(2, _nSlices);
454  hCutFlow->SetBinContent(3, _nHits);
455 
456 }
457 //---------------------------------------------------------------------
void FillHitDensitiesInTDCWindow(std::vector< int > TDC_vals, int minTDC, int maxTDC, int window_size, int overlap, TH1F *histogram)
std::vector< novaddt::HitList > HitFormatConsolidation(art::Event const &event)
double minY
Definition: plot_hist.C:9
std::vector< DAQHit > HitList
Definition: HitList.h:15
const char * p
Definition: xmltok.h:285
void AnalyzeHitLists(std::vector< novaddt::HitList > hit_lists, unsigned long long event_time)
unsigned int _nEvents
std::string _hitsFormat
The format to expect the hits in, can be one of HitList, Grouped, Vector.
double maxY
Definition: plot_hist.C:10
DEFINE_ART_MODULE(TestTMapFile)
void endJob() override
std::string _rawDigitLabel
label of where to find Raw Digits
void hits()
Definition: readHits.C:15
HitsAna(fhicl::ParameterSet const &p)
TH1F * hHitDensity_per_50TDC
unsigned int _nHits
Identifier for the X measuring view of the detector (top)
EDAnalyzer(Table< Config > const &config)
Definition: EDAnalyzer.h:100
OStream cout
Definition: OStream.cxx:6
unsigned int _nSlices
TH1F * hHitDensity_per_100TDC
T * make(ARGS...args) const
std::string _hitsInstanceLabel
instance label making the Hits
Definition: structs.h:12
void analyze(art::Event const &e) override
bool _verbose
Verbose output.
assert(nhit_max >=nhit_nbins)
Float_t e
Definition: plot.C:35
std::string _hitsModuleLabel
label of module making the Hits
TH1F * hHitDensity_per_70TDC
enum BeamMode string