All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
sbndcode/sbndcode/gallery/galleryAnalysis/HitAnalysisAlg.cpp
Go to the documentation of this file.
1 #include "HitAnalysisAlg.h"
2 #include "messagefacility/MessageLogger/MessageLogger.h"
3 
4 #include <cmath>
5 #include <algorithm>
6 
7 namespace HitAnalysis
8 {
9 //----------------------------------------------------------------------------
10 /// Constructor.
11 ///
12 /// Arguments:
13 ///
14 /// pset - Fcl parameters.
15 ///
16 HitAnalysisAlg::HitAnalysisAlg(fhicl::ParameterSet const & pset) :
17  fRootDirectory(0)
18 
19 {
20 
21  reconfigure(pset);
22 
23  // Report.
24  mf::LogInfo("HitAnalysisAlg") << "HitAnalysisAlg configured\n";
25 }
26 
27 //----------------------------------------------------------------------------
28 /// Destructor.
29 HitAnalysisAlg::~HitAnalysisAlg()
30 {}
31 
32 //----------------------------------------------------------------------------
33 /// Reconfigure method.
34 ///
35 /// Arguments:
36 ///
37 /// pset - Fcl parameter set.
38 ///
39 void HitAnalysisAlg::reconfigure(fhicl::ParameterSet const & pset)
40 {
41  fLocalDirName = pset.get<std::string>("LocalDirName", std::string("wow"));
42 }
43 
44 //----------------------------------------------------------------------------
45 /// Begin job method.
46 void HitAnalysisAlg::setup(const geo::GeometryCore& geometry,
47  TDirectory* rootDirectory)
48 {
49  // Get geometry and detector properties
50  fGeometry = &geometry;
51  fRootDirectory = rootDirectory->mkdir(fLocalDirName.c_str());
52 
53  // Make a directory for these histograms
54 // art::TFileDirectory dir = tfs->mkdir(fLocalDirName.c_str());
55 
56  fHitsByWire[0] = std::make_unique<TH1D>("HitsByWire0", ";Wire #", fGeometry->Nwires(0), 0., fGeometry->Nwires(0));
57  fHitsByWire[1] = std::make_unique<TH1D>("HitsByWire1", ";Wire #", fGeometry->Nwires(1), 0., fGeometry->Nwires(1));
58  fHitsByWire[2] = std::make_unique<TH1D>("HitsByWire2", ";Wire #", fGeometry->Nwires(2), 0., fGeometry->Nwires(2));
59 
60  fDriftTimes[0] = std::make_unique<TH1D>("DriftTime0", ";time(ticks)", 3200, 0., 9600.);
61  fDriftTimes[1] = std::make_unique<TH1D>("DriftTime1", ";time(ticks)", 3200, 0., 9600.);
62  fDriftTimes[2] = std::make_unique<TH1D>("DriftTime2", ";time(ticks)", 3200, 0., 9600.);
63 
64  fHitsByTime[0] = std::make_unique<TH1D>("HitsByTime0", ";Tick", 1600, 0., 6400.);
65  fHitsByTime[1] = std::make_unique<TH1D>("HitsByTime1", ";Tick", 1600, 0., 6400.);
66  fHitsByTime[2] = std::make_unique<TH1D>("HitsByTime2", ";Tick", 1600, 0., 6400.);
67 
68  fPulseHeight[0] = std::make_unique<TH1D>("PulseHeight0", "PH (ADC)", 300, 0., 150.);
69  fPulseHeight[1] = std::make_unique<TH1D>("PulseHeight1", "PH (ADC)", 300, 0., 150.);
70  fPulseHeight[2] = std::make_unique<TH1D>("PulseHeight2", "PH (ADC)", 300, 0., 150.);
71  fPulseHeightSingle[0] = std::make_unique<TH1D>("PulseHeightS0", "PH (ADC)", 300, 0., 150.);
72  fPulseHeightSingle[1] = std::make_unique<TH1D>("PulseHeightS1", "PH (ADC)", 300, 0., 150.);
73  fPulseHeightSingle[2] = std::make_unique<TH1D>("PulseHeightS2", "PH (ADC)", 300, 0., 150.);
74  fPulseHeightMulti[0] = std::make_unique<TH1D>("PulseHeightM0", "PH (ADC)", 300, 0., 150.);
75  fPulseHeightMulti[1] = std::make_unique<TH1D>("PulseHeightM1", "PH (ADC)", 300, 0., 150.);
76  fPulseHeightMulti[2] = std::make_unique<TH1D>("PulseHeightM2", "PH (ADC)", 300, 0., 150.);
77  fChi2DOF[0] = std::make_unique<TH1D>("Chi2DOF0", "Chi2DOF", 502, -1., 250.);
78  fChi2DOF[1] = std::make_unique<TH1D>("Chi2DOF1", "Chi2DOF", 502, -1., 250.);
79  fChi2DOF[2] = std::make_unique<TH1D>("Chi2DOF2", "Chi2DOF", 502, -1., 250.);
80  fNumDegFree[0] = std::make_unique<TH1D>("NumDegFree0", "NDF", 100, 0., 100.);
81  fNumDegFree[1] = std::make_unique<TH1D>("NumDegFree1", "NDF", 100, 0., 100.);
82  fNumDegFree[2] = std::make_unique<TH1D>("NumDegFree2", "NDF", 100, 0., 100.);
83  fChi2DOFSingle[0] = std::make_unique<TH1D>("Chi2DOFS0", "Chi2DOF", 502, -1., 250.);
84  fChi2DOFSingle[1] = std::make_unique<TH1D>("Chi2DOFS1", "Chi2DOF", 502, -1., 250.);
85  fChi2DOFSingle[2] = std::make_unique<TH1D>("Chi2DOFS2", "Chi2DOF", 502, -1., 250.);
86  fHitMult[0] = std::make_unique<TH1D>("HitMult0", "# hits", 15, 0., 15.);
87  fHitMult[1] = std::make_unique<TH1D>("HitMult1", "# hits", 15, 0., 15.);
88  fHitMult[2] = std::make_unique<TH1D>("HitMult2", "# hits", 15, 0., 15.);
89  fHitCharge[0] = std::make_unique<TH1D>("HitCharge0", "Charge", 1000, 0., 2000.);
90  fHitCharge[1] = std::make_unique<TH1D>("HitCharge1", "Charge", 1000, 0., 2000.);
91  fHitCharge[2] = std::make_unique<TH1D>("HitCharge2", "Charge", 1000, 0., 2000.);
92  fFitWidth[0] = std::make_unique<TH1D>("FitWidth0", "Width", 100, 0., 10.);
93  fFitWidth[1] = std::make_unique<TH1D>("FitWidth1", "Width", 100, 0., 10.);
94  fFitWidth[2] = std::make_unique<TH1D>("FitWidth2", "Width", 100, 0., 10.);
95  fHitSumADC[0] = std::make_unique<TH1D>("SumADC0", "Sum ADC", 1000, 0., 2000.);
96  fHitSumADC[1] = std::make_unique<TH1D>("SumADC1", "Sum ADC", 1000, 0., 2000.);
97  fHitSumADC[2] = std::make_unique<TH1D>("SumADC2", "Sum ADC", 1000, 0., 2000.);
98 
99  fNDFVsChi2[0] = std::make_unique<TH2D>("NDFVsChi20", ";NDF;Chi2", 50, 0., 50., 101, -1., 100.);
100  fNDFVsChi2[1] = std::make_unique<TH2D>("NDFVsChi21", ";NDF;Chi2", 50, 0., 50., 101, -1., 100.);
101  fNDFVsChi2[2] = std::make_unique<TH2D>("NDFVsChi22", ";NDF;Chi2", 50, 0., 50., 101, -1., 100.);
102 
103  fPulseHVsWidth[0] = std::make_unique<TH2D>("PHVsWidth0", ";PH;Width", 100, 0., 100., 100, 0., 20.);
104  fPulseHVsWidth[1] = std::make_unique<TH2D>("PHVsWidth1", ";PH;Width", 100, 0., 100., 100, 0., 20.);
105  fPulseHVsWidth[2] = std::make_unique<TH2D>("PHVsWidth2", ";PH;Width", 100, 0., 100., 100, 0., 20.);
106 
107  fPulseHVsCharge[0] = std::make_unique<TH2D>("PHVsChrg0", ";PH;Q", 100, 0., 100., 100, 0., 2000.);
108  fPulseHVsCharge[1] = std::make_unique<TH2D>("PHVsChrg1", ";PH;Q", 100, 0., 100., 100, 0., 2000.);
109  fPulseHVsCharge[2] = std::make_unique<TH2D>("PHVsChrg2", ";PH;Q", 100, 0., 100., 100, 0., 2000.);
110 
111  fPulseHVsHitNo[0] = std::make_unique<TProfile>("PHVsNo0", ";Hit #;PH", 1000, 0., 1000., 0., 100.);
112  fPulseHVsHitNo[1] = std::make_unique<TProfile>("PHVsNo1", ";Hit #;PH", 1000, 0., 1000., 0., 100.);
113  fPulseHVsHitNo[2] = std::make_unique<TProfile>("PHVsNo2", ";Hit #;PH", 1000, 0., 1000., 0., 100.);
114 
115  fChargeVsHitNo[0] = std::make_unique<TProfile>("QVsNo0", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
116  fChargeVsHitNo[1] = std::make_unique<TProfile>("QVsNo1", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
117  fChargeVsHitNo[2] = std::make_unique<TProfile>("QVsNo2", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
118 
119  fChargeVsHitNoS[0] = std::make_unique<TProfile>("QVsNoS0", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
120  fChargeVsHitNoS[1] = std::make_unique<TProfile>("QVsNoS1", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
121  fChargeVsHitNoS[2] = std::make_unique<TProfile>("QVsNoS2", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
122 
123  fBadWPulseHeight = std::make_unique<TH1D>("BWPulseHeight", "PH (ADC)", 300, 0., 150.);
124  fBadWPulseHVsWidth = std::make_unique<TH2D>("BWPHVsWidth", ";PH;Width", 100, 0., 100., 100, 0., 10.);
125  fBadWHitsByWire = std::make_unique<TH1D>("BWHitsByWire", ";Wire #", fGeometry->Nwires(2), 0., fGeometry->Nwires(2));
126 
127  fSPHvsIdx[0] = std::make_unique<TH2D>("SPHVsIdx0", ";PH;Idx", 30, 0., 30., 100, 0., 100.);
128  fSPHvsIdx[1] = std::make_unique<TH2D>("SPHVsIdx1", ";PH;Idx", 30, 0., 30., 100, 0., 100.);
129  fSPHvsIdx[2] = std::make_unique<TH2D>("SPHVsIdx2", ";PH;Idx", 30, 0., 30., 100, 0., 100.);
130 
131  fSWidVsIdx[0] = std::make_unique<TH2D>("SWidsIdx0", ";Width;Idx", 30, 0., 30., 100, 0., 10.);
132  fSWidVsIdx[1] = std::make_unique<TH2D>("SWidsIdx1", ";Width;Idx", 30, 0., 30., 100, 0., 10.);
133  fSWidVsIdx[2] = std::make_unique<TH2D>("SWidsIdx2", ";Width;Idx", 30, 0., 30., 100, 0., 10.);
134 
135  f1PPHvsWid[0] = std::make_unique<TH2D>("1PPHVsWid0", ";PH;Width", 100, 0., 100., 100, 0., 20.);
136  f1PPHvsWid[1] = std::make_unique<TH2D>("1PPHVsWid1", ";PH;Width", 100, 0., 100., 100, 0., 20.);
137  f1PPHvsWid[2] = std::make_unique<TH2D>("1PPHVsWid2", ";PH;Width", 100, 0., 100., 100, 0., 20.);
138 
139  fSPPHvsWid[0] = std::make_unique<TH2D>("SPPHVsWid0", ";PH;Width", 100, 0., 100., 100, 0., 20.);
140  fSPPHvsWid[1] = std::make_unique<TH2D>("SPPHVsWid1", ";PH;Width", 100, 0., 100., 100, 0., 20.);
141  fSPPHvsWid[2] = std::make_unique<TH2D>("SPPHVsWid2", ";PH;Width", 100, 0., 100., 100, 0., 20.);
142 
143  fSOPHvsWid[0] = std::make_unique<TH2D>("SOPHVsWid0", ";PH;Width", 100, 0., 100., 100, 0., 20.);
144  fSOPHvsWid[1] = std::make_unique<TH2D>("SOPHVsWid1", ";PH;Width", 100, 0., 100., 100, 0., 20.);
145  fSOPHvsWid[2] = std::make_unique<TH2D>("SOPHVsWid2", ";PH;Width", 100, 0., 100., 100, 0., 20.);
146 
147  fPHRatVsIdx[0] = std::make_unique<TH2D>("PHRatVsIdx0", ";PHRat;Idx", 30, 0., 30., 51, 0., 1.02);
148  fPHRatVsIdx[1] = std::make_unique<TH2D>("PHRatVsIdx1", ";PHRat;Idx", 30, 0., 30., 51, 0., 1.02);
149  fPHRatVsIdx[2] = std::make_unique<TH2D>("PHRatVsIdx2", ";PHRat;Idx", 30, 0., 30., 51, 0., 1.02);
150 
151  // Now attach them to the output file
152  for(int idx = 0; idx < 3; idx++)
153  {
154  fHitsByWire[idx]->SetDirectory(fRootDirectory);
155  fDriftTimes[idx]->SetDirectory(fRootDirectory);
156  fHitsByTime[idx]->SetDirectory(fRootDirectory);
157  fPulseHeight[idx]->SetDirectory(fRootDirectory);
158  fPulseHeightSingle[idx]->SetDirectory(fRootDirectory);
159  fPulseHeightMulti[idx]->SetDirectory(fRootDirectory);
160  fChi2DOF[idx]->SetDirectory(fRootDirectory);
161  fNumDegFree[idx]->SetDirectory(fRootDirectory);
162  fChi2DOFSingle[idx]->SetDirectory(fRootDirectory);
163  fHitMult[idx]->SetDirectory(fRootDirectory);
164  fHitCharge[idx]->SetDirectory(fRootDirectory);
165  fFitWidth[idx]->SetDirectory(fRootDirectory);
166  fHitSumADC[idx]->SetDirectory(fRootDirectory);
167  fNDFVsChi2[idx]->SetDirectory(fRootDirectory);
168  fPulseHVsWidth[idx]->SetDirectory(fRootDirectory);
169  fPulseHVsCharge[idx]->SetDirectory(fRootDirectory);
170  fPulseHVsHitNo[idx]->SetDirectory(fRootDirectory);
171  fChargeVsHitNo[idx]->SetDirectory(fRootDirectory);
172  fChargeVsHitNoS[idx]->SetDirectory(fRootDirectory);
173 
174  fSPHvsIdx[idx]->SetDirectory(fRootDirectory);
175  fSWidVsIdx[idx]->SetDirectory(fRootDirectory);
176  f1PPHvsWid[idx]->SetDirectory(fRootDirectory);
177  fSPPHvsWid[idx]->SetDirectory(fRootDirectory);
178  fSOPHvsWid[idx]->SetDirectory(fRootDirectory);
179  fPHRatVsIdx[idx]->SetDirectory(fRootDirectory);
180  }
181 
182  // get the overall now
183  fBadWPulseHeight->SetDirectory(fRootDirectory);
184  fBadWPulseHVsWidth->SetDirectory(fRootDirectory);
185  fBadWHitsByWire->SetDirectory(fRootDirectory);
186 
187  return;
188 }
189 
190 void HitAnalysisAlg::fillHistograms(const TrackPlaneHitMap& trackPlaneHitMap) const
191 {
192  int longTrackID(0);
193  size_t longTrackLen(0);
194 
195  for(const auto& trackHitVecMapItr : trackPlaneHitMap)
196  {
197  size_t numHits(0);
198 
199  for(const auto& planeHitPair : trackHitVecMapItr.second)
200  {
201  fillHistograms(planeHitPair.second);
202 
203  if (planeHitPair.first == 2 && planeHitPair.second.size() > numHits) numHits = planeHitPair.second.size();
204  }
205 
206  if (numHits > longTrackLen)
207  {
208  longTrackID = trackHitVecMapItr.first;
209  longTrackLen = numHits;
210  }
211  }
212 
213  if (longTrackLen > 0)
214  {
215  for(const auto& planeHitPair : trackPlaneHitMap.find(longTrackID)->second)
216  {
217  int hitNo(0);
218 
219  for(const auto& hit : planeHitPair.second)
220  {
221  if (hit.Multiplicity() < 2) fChargeVsHitNoS[planeHitPair.first]->Fill(float(hitNo)+0.5, std::min(float(1999.),hit.Integral()), 1.);
222  fPulseHVsHitNo[planeHitPair.first]->Fill(float(hitNo)+0.5, std::min(float(99.9),hit.PeakAmplitude()), 1.);
223  fChargeVsHitNo[planeHitPair.first]->Fill(float(hitNo)+0.5, std::min(float(1999.),hit.Integral()), 1.);
224  hitNo++;
225  }
226  }
227  }
228 
229  return;
230 }
231 
232 void HitAnalysisAlg::fillHistograms(const HitVec& hitVec) const
233 {
234  // Keep track of number of hits per plane
235  size_t nHitsPerPlane[] = {0,0,0};
236  size_t negCount(0);
237 
238  std::vector<const recob::Hit*> hitSnippetVec;
239 
240  // Loop the hits and make some plots
241  for(const auto& hit : hitVec)
242  {
243  // Extract interesting hit parameters
244  const geo::WireID& wireID = hit.WireID();
245  float chi2DOF = std::min(hit.GoodnessOfFit(),float(249.8));
246  int numDOF = hit.DegreesOfFreedom();
247  int hitMult = hit.Multiplicity();
248  float peakTime = hit.PeakTime();
249  float charge = hit.Integral();
250  float sumADC = hit.SummedADC();
251  float hitPH = std::min(hit.PeakAmplitude(),float(249.8));
252  float hitSigma = hit.RMS();
253 
254  size_t plane = wireID.Plane;
255  size_t wire = wireID.Wire;
256 
257 // if (plane == 2 && (wire == 18 || wire == 527 || wire == 528)) continue;
258 
259 // if (charge < 0. || sumADC < 0. || hitPH < 0.)
260  if (hitPH < 0.)
261  {
262  negCount++;
263  std::cout << "Hit plane: " << plane << ", wire: " << wire << ", T: " << peakTime << ", PH: " << hitPH << ", charge: " << charge << ", sumADC: " << sumADC << std::endl;
264  }
265 
266  nHitsPerPlane[plane]++;
267 
268  fHitsByWire[plane]->Fill(wire,1.);
269  fHitsByTime[plane]->Fill(peakTime, 1.);
270  fPulseHeight[plane]->Fill(hitPH, 1.);
271  fChi2DOF[plane]->Fill(chi2DOF, 1.);
272  fNumDegFree[plane]->Fill(numDOF, 1.);
273  fHitMult[plane]->Fill(hitMult, 1.);
274  fHitCharge[plane]->Fill(charge, 1.);
275  fFitWidth[plane]->Fill(std::min(float(19.99),hitSigma), 1.);
276  fHitSumADC[plane]->Fill(sumADC, 1.);
277  fNDFVsChi2[plane]->Fill(numDOF, chi2DOF, 1.);
278  fDriftTimes[plane]->Fill(peakTime, 1.);
279 
280  if (hitMult == 1)
281  {
282  fPulseHeightSingle[plane]->Fill(hitPH, 1.);
283  fChi2DOFSingle[plane]->Fill(chi2DOF, 1.);
284  fPulseHVsWidth[plane]->Fill(std::min(float(99.9),hitPH), std::min(float(19.99),hitSigma), 1.);
285  fPulseHVsCharge[plane]->Fill(std::min(float(99.9),hitPH), std::min(float(1999.),charge), 1.);
286 
287  if (plane == 2 && hitPH < 5 && hitSigma < 2.2)
288  {
289  std::cout << "++> plane: " << plane << ", wire: " << wire << ", peakTime: " << peakTime << ", ph: " << hitPH << ", w: " << hitSigma << std::endl;
290 
291  fBadWPulseHeight->Fill(hitPH,1.);
292  fBadWPulseHVsWidth->Fill(std::min(float(99.9),hitPH), std::min(float(19.99),hitSigma), 1.);
293  fBadWHitsByWire->Fill(wire,1.);
294  }
295  }
296  else
297  fPulseHeightMulti[plane]->Fill(hitPH, 1.);
298 
299  // Look at hits on snippets
300  if (!hitSnippetVec.empty() && hitSnippetVec.back()->LocalIndex() >= hit.LocalIndex())
301  {
302  // Only worried about multi hit snippets
303  if (hitSnippetVec.size() > 1)
304  {
305  // Sort in order of largest to smallest pulse height
306  std::sort(hitSnippetVec.begin(),hitSnippetVec.end(),[](const auto* left, const auto* right){return left->PeakAmplitude() > right->PeakAmplitude();});
307 
308  float maxPulseHeight = hitSnippetVec.front()->PeakAmplitude();
309 
310  for(size_t idx = 0; idx < hitSnippetVec.size(); idx++)
311  {
312  float pulseHeight = hitSnippetVec.at(idx)->PeakAmplitude();
313  float pulseWid = hitSnippetVec.at(idx)->RMS();
314  float pulseHeightRatio = pulseHeight / maxPulseHeight;
315 
316  size_t plane = hitSnippetVec.at(idx)->WireID().Plane;
317 
318  fSPHvsIdx[plane]->Fill(idx, std::min(float(99.9),pulseHeight), 1.);
319  fSWidVsIdx[plane]->Fill(idx, std::min(float(19.99),pulseWid), 1.);
320  fPHRatVsIdx[plane]->Fill(idx, pulseHeightRatio, 1.);
321 
322  if (idx == 0) fSPPHvsWid[plane]->Fill(std::min(float(99.9),pulseHeight), std::min(float(19.99),pulseWid), 1.);
323  else fSOPHvsWid[plane]->Fill(std::min(float(99.9),pulseHeight), std::min(float(19.99),pulseWid), 1.);
324  }
325  }
326  else
327  {
328  float pulseHeight = hitSnippetVec.front()->PeakAmplitude();
329  float pulseWid = hitSnippetVec.front()->RMS();
330  size_t plane = hitSnippetVec.front()->WireID().Plane;
331 
332  f1PPHvsWid[plane]->Fill(std::min(float(99.9),pulseHeight), std::min(float(19.99),pulseWid), 1.);
333  }
334 
335  hitSnippetVec.clear();
336  }
337 
338  hitSnippetVec.push_back(&hit);
339  }
340 
341  return;
342 }
343 
344 // Useful for normalizing histograms
345 void HitAnalysisAlg::endJob(int numEvents)
346 {
347  // Normalize wire profiles to be hits/event
348  double normFactor(1./numEvents);
349 
350  for(size_t idx = 0; idx < 3; idx++) fHitsByWire[idx]->Scale(normFactor);
351 
352  // Now write out everything...
353  fRootDirectory->cd();
354 
355  // Start by looping over the planes
356  for(int idx = 0; idx < 3; idx++)
357  {
358  fHitsByWire[idx]->Write();
359  fDriftTimes[idx]->Write();
360  fHitsByTime[idx]->Write();
361  fPulseHeight[idx]->Write();
362  fPulseHeightSingle[idx]->Write();
363  fPulseHeightMulti[idx]->Write();
364  fChi2DOF[idx]->Write();
365  fNumDegFree[idx]->Write();
366  fChi2DOFSingle[idx]->Write();
367  fHitMult[idx]->Write();
368  fHitCharge[idx]->Write();
369  fFitWidth[idx]->Write();
370  fHitSumADC[idx]->Write();
371  fNDFVsChi2[idx]->Write();
372  fPulseHVsWidth[idx]->Write();
373  fPulseHVsCharge[idx]->Write();
374  fPulseHVsHitNo[idx]->Write();
375  fChargeVsHitNo[idx]->Write();
376  fChargeVsHitNoS[idx]->Write();
377 
378  fSPHvsIdx[idx]->Write();
379  fSWidVsIdx[idx]->Write();
380  f1PPHvsWid[idx]->Write();
381  fSPPHvsWid[idx]->Write();
382  fSOPHvsWid[idx]->Write();
383  fPHRatVsIdx[idx]->Write();
384  }
385 
386  // get the overall now
387  fBadWPulseHeight->Write();
388  fBadWPulseHVsWidth->Write();
389  fBadWHitsByWire->Write();
390 
391  return;
392 }
393 
394 }
geometry
const geo::GeometryCore * geometry
Definition: NuVertexChargeTree_module.cc:373
right
walls no right
Definition: selectors.fcl:105
geo::WireID::Wire
WireID_t Wire
Index of the wire within its plane.
Definition: geo_types.h:580
hit
process_name hit
Definition: cheaterreco.fcl:51
actions::Scale
Scale(size_t pos, T factor) -> Scale< T >
HitAnalysis::HitAnalysisAlg::fGeometry
const geo::GeometryCore * fGeometry
pointer to Geometry service
Definition: icarusalg/icarusalg/gallery/galleryAnalysis/C++/HitAnalysisAlg.h:94
geo::GeometryCore::Nwires
unsigned int Nwires(unsigned int p, unsigned int tpc=0, unsigned int cstat=0) const
Returns the total number of wires in the specified plane.
Definition: GeometryCore.h:3345
left
walls no left
Definition: selectors.fcl:105
geo::PlaneID::Plane
PlaneID_t Plane
Index of the plane within its TPC.
Definition: geo_types.h:493
geo::GeometryCore
Description of geometry of one entire detector.
Definition: GeometryCore.h:1476
HitAnalysis::HitAnalysisAlg::setup
void setup(const geo::GeometryCore &, TDirectory *)
Begin job method.
Definition: icarusalg/icarusalg/gallery/galleryAnalysis/C++/HitAnalysisAlg.cpp:46
cout
BEGIN_PROLOG could also be cout
Definition: messageservice.fcl:10
Generated by   doxygen 1.8.5