S4DParamCalc_module.cc
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////
2 // \file S4DParamCalc.cxx
3 // \brief Module calculate the best input parameters for Slicer4D.
4 // \version $Id: S4DParamCalc_module.cc,v 1.4 2013-05-06 10:30:00 mbaird42 Exp $
5 // \authors mbaird42@fnal.gov
6 ////////////////////////////////////////////////////////////////////////
7 
8 // C/C++ includes
9 #include <cmath>
10 #include <iostream>
11 #include <vector>
12 #include <algorithm>
13 
14 // ROOT includes
15 #include "TH1F.h"
16 
17 // Framework includes
26 #include "fhiclcpp/ParameterSet.h"
28 
29 // NOvASoft includes
30 #include "Calibrator/Calibrator.h"
31 #include "Geometry/Geometry.h"
33 #include "RecoBase/CellHit.h"
34 #include "RecoBase/Cluster.h"
35 #include "Slicer/PointManager.h"
36 
37 
38 
39 // S4DParamCalc header
40 namespace slicer {
41  class S4DParamCalc : public art::EDAnalyzer {
42  public:
43  explicit S4DParamCalc(fhicl::ParameterSet const& pset);
44  ~S4DParamCalc();
45 
46  void analyze(const art::Event& evt);
47  void reconfigure(const fhicl::ParameterSet& pset);
48  void beginJob();
49 
50  private:
54 
55  // input parameters to Point Manager
56  double fEpsilon; ///< Minimum causal separation value
57  unsigned int fMinPts; ///< minimum number of casual neighbors for a hit to be in a cluster
58 
59  // input parameters for calculating the causal separation value
60  bool fUseLowPEPen; ///< Add a causal distance penalty for PE (low PE is INCREASES the distance)
61  double fPEPen; ///< PE value for which the low PE penalty will be 1.
62  double fDistPen; ///< Distance (in cm) for which the distance penalty will be 1 (roughly one strong interaction length.)
63  double fOpVPlPen; ///< Allowed plane gap for hits in opposite views for which the distance penalty will be 1.
64 
65  // helper class for calculating neighbor distances
67 
68  // Histograms
69  TH1F *fPEnoise;
70  TH1F *fPEphys;
71 
72  TH1F *fDeltaT0;
73  TH1F *fDeltaT1;
74  TH1F *fDeltaX0;
75  TH1F *fDeltaX1;
76  TH1F *fDeltaY0;
77  TH1F *fDeltaY1;
78  TH1F *fDeltaZ0;
79  TH1F *fDeltaZ1;
80  TH1F *fDeltaP0;
81  TH1F *fDeltaP1;
82 
83  TH1F *fAveTClose;
84  TH1F *fAveDClose;
85  TH1F *fAvePClose;
86 
87  TH1F *fTClose3;
88  TH1F *fDClose3;
89  TH1F *fPClose3;
90 
91  TH1F *fTClose4;
92  TH1F *fDClose4;
93  TH1F *fPClose4;
94 
95  TH1F *fTClose5;
96  TH1F *fDClose5;
97  TH1F *fPClose5;
98 
99  TH1F *fTres;
100  TH1F *fTresNoise;
101  };
102 }
103 
104 
105 
106 namespace slicer
107 {
108  //.......................................................................
110  : EDAnalyzer(pset)
111  {
112  this->reconfigure(pset);
114  }
115 
116  //......................................................................
118  { }
119 
120  //......................................................................
122  {
123  fCellHitLabel = pset.get< std::string >("CellHitLabel");
124  fSlicerLabel = pset.get< std::string >("SlicerLabel");
125  fMakeKDistPlots = pset.get< bool >("MakeKDistPlots");
126  fEpsilon = pset.get< double >("Epsilon");
127  fMinPts = pset.get< unsigned int >("MinPts");
128  fUseLowPEPen = pset.get< bool >("UseLowPEPen");
129  fPEPen = pset.get< double >("PEPen");
130  fDistPen = pset.get< double >("DistPen");
131  fOpVPlPen = pset.get< double >("OppViewPlanePen");
132  }
133 
134  //......................................................................
136  {
138 
139  // book the histograms
140  fPEnoise = tfs->make<TH1F>("fPEnoise",
141  "PE for hits in the noise cluster",
142  200,0.0,2000.0);
143  fPEphys = tfs->make<TH1F>("fPEphys",
144  "PE for all hits in the non-noise clusters",
145  200,0.0,2000.0);
146  fDeltaT0 = tfs->make<TH1F>("fDeltaT0",
147  "Delta T for all hits;delta T [ns];count",
148  1100000,-550000.0,550000.0);
149  fDeltaT1 = tfs->make<TH1F>("fDeltaT1",
150  "Delta T for all hits within 10 planes;delta T [ns];count",
151  1100000,-550000.0,550000.0);
152  fDeltaX0 = tfs->make<TH1F>("fDeltaX0",
153  "Delta X for all hits in the X-view;delta X [cm];count",
154  400,-1600,1600); // 8 cm bins
155  fDeltaX1 = tfs->make<TH1F>("fDeltaX1",
156  "Delta X for all hits in the X-view within 1 usec;delta X [cm];count",
157  400,-1600,1600); // 8 cm bins
158  fDeltaY0 = tfs->make<TH1F>("fDeltaY0",
159  "Delta Y for all hits in the Y-view;delta Y [cm];count",
160  400,-1600,1600); // 8 cm bins
161  fDeltaY1 = tfs->make<TH1F>("fDeltaY1",
162  "Delta Y for all hits in the Y-view within 1 usec;delta Y [cm];count",
163  400,-1600,1600); // 8 cm bins
164  fDeltaZ0 = tfs->make<TH1F>("fDeltaZ0",
165  "Delta Z for all hits in the same view;delta Z [cm];count",
166  1000,-6000,6000); // 12 cm bins
167  fDeltaZ1 = tfs->make<TH1F>("fDeltaZ1",
168  "Delta Z for all hits in the same view within 1 usec;delta Z [cm];count",
169  1000,-6000,6000); // 12 cm bins
170  fDeltaP0 = tfs->make<TH1F>("fDeltaP0",
171  "Delta Plane for all hits in opposite views;delta Plane;count",
172  1000,-1000,1000); // 2 plane bins
173  fDeltaP1 = tfs->make<TH1F>("fDeltaP1",
174  "Delta Plane for all hits in opposite views within 1 usec;delta Plane;count",
175  1000,-1000,1000); // 2 plane bins
176 
177  fAveTClose = tfs->make<TH1F>("fAveTClose",
178  "Average delta-time for 4 closest neighbors in the slice;time [ns];count",
179  1000,0.0,1000.0);
180  fAveDClose = tfs->make<TH1F>("fAveDClose",
181  "Average distance for 4 closest neighbors in the same view and in the same slice;dist [cm];count",
182  160,0.0,1600.0);
183  fAvePClose = tfs->make<TH1F>("fAvePClose",
184  "Average delta plane for 4 closest neighbors in opposite views and in the same slice;# of planes;count",
185  100,0.0,200.0);
186  fTClose3 = tfs->make<TH1F>("fTClose3",
187  "Delta-time for 3rd closest neighbor in the slice;time [ns];count",
188  1000,0.0,1000.0);
189  fDClose3 = tfs->make<TH1F>("fDClose3",
190  "Distance to 3rd closest neighbor in the same view and in the same slice;dist [cm];count",
191  160,0.0,1600.0);
192  fPClose3 = tfs->make<TH1F>("fPClose3",
193  "Delta plane for 3rd closest neighbor in opposite view and in the same slice;# of planes;count",
194  100,0.0,200.0);
195  fTClose4 = tfs->make<TH1F>("fTClose4",
196  "Delta-time for 4th closest neighbor in the slice;time [ns];count",
197  1000,0.0,1000.0);
198  fDClose4 = tfs->make<TH1F>("fDClose4",
199  "Distance to 4th closest neighbor in the same view and in the same slice;dist [cm];count",
200  160,0.0,1600.0);
201  fPClose4 = tfs->make<TH1F>("fPClose4",
202  "Delta plane for 4th closest neighbor in opposite view and in the same slice;# of planes;count",
203  100,0.0,200.0);
204  fTClose5 = tfs->make<TH1F>("fTClose5",
205  "Delta-time for 5th closest neighbor in the slice;time [ns];count",
206  1000,0.0,1000.0);
207  fDClose5 = tfs->make<TH1F>("fDClose5",
208  "Distance to 5th closest neighbor in the same view and in the same slice;dist [cm];count",
209  160,0.0,1600.0);
210  fPClose5 = tfs->make<TH1F>("fPClose5",
211  "Delta plane for 5th closest neighbor in opposite view and in the same slice;# of planes;count",
212  100,0.0,200.0);
213 
214  fTres = tfs->make<TH1F>("fTres",
215  "Computed timing resolution for hits in non-noise slices;time [ns];count",
216  500,0.0,500.0);
217  fTresNoise = tfs->make<TH1F>("fTresNoise",
218  "Computed timing resolution for hits in the noise slice;time [ns];count",
219  500,0.0,500.0);
220 
221  }
222 
223  //......................................................................
225  {
226  // std::cout << "\n\n====================\nBegin processing for event: "
227  // << evt.id() << "\n";
228 
229  // declare geometry service handle
232 
233  // get the CellHits
235  evt.getByLabel(fCellHitLabel, hitcol);
236 
237  std::vector<art::Ptr<rb::CellHit > > hitlist;
238  for(unsigned int i = 0; i < hitcol->size(); ++i){
239  art::Ptr<rb::CellHit> hit(hitcol, i);
240  hitlist.push_back(hit);
241  }
242 
243  // get the Slices
245  evt.getByLabel(fSlicerLabel, slices);
246 
247  // Set the PointManager for this event. (Use false for skipping the
248  // delta T calculation since we want the correct distances for all of
249  // the noise hits.)
250  fPtMan.Reset(hitcol->size(), false);
251 
252  // General Plan:
253  //
254  // loop over all slices, get all hits in the slice
255  // loop over all hits
256  // - add hit to PtMan
257  // - add PE to noise or phys histo
258 
259  // std::cout << "\nMaking PE plots...";
260 
261  for(unsigned int sli = 0; sli < slices->size(); ++sli) {
262  if((*slices)[sli].IsNoise()) {
263  for(unsigned int hiti = 0; hiti < (*slices)[sli].NCell(); ++hiti) {
264  const rb::CellHit* hit = (*slices)[sli].Cell(hiti).get();
265  fPtMan.AddHit(hit->TNS(), cal->GetTimeRes(*hit),
266  hit->Plane(), hit->Cell(),
267  hit->PE(), hit->View());
268  fPEnoise->Fill(hit->PE());
269  fTresNoise->Fill(cal->GetTimeRes(*hit));
270  }
271  }
272  else {
273  for(unsigned int hiti = 0; hiti < (*slices)[sli].NCell(); ++hiti) {
274  const rb::CellHit* hit = (*slices)[sli].Cell(hiti).get();
275  fPtMan.AddHit(hit->TNS(), cal->GetTimeRes(*hit),
276  hit->Plane(), hit->Cell(),
277  hit->PE(), hit->View());
278  fPEphys->Fill(hit->PE());
279  fTres->Fill(cal->GetTimeRes(*hit));
280  }
281  }
282  }
283 
284 
285 
286  // std::cout << "\t(done)\nMaking timing/spatial resolution plots...";
287 
288  //
289  // Make plots form pairs of hits in the same non-noise slice
290  //
291 
292  // define number of neighbors to keep track of
293  unsigned int Nn = 5;
294 
295  for(unsigned int sli = 0; sli < slices->size(); ++sli) {
296  if((*slices)[sli].IsNoise()) continue;
297 
298  std::vector< std::vector< double > > D;
299  std::vector< std::vector< double > > P;
300  std::vector< std::vector< double > > T;
301  for(unsigned int i = 0; i < (*slices)[sli].NCell(); ++i) {
302  std::vector< double > temp;
303  for(unsigned int j = 0; j < Nn; ++j) temp.push_back(1.0e6);
304  D.push_back(temp);
305  P.push_back(temp);
306  T.push_back(temp);
307  }
308 
309  for(unsigned int hi = 0; hi < (*slices)[sli].NCell(); ++hi) {
310  const rb::CellHit* hiti = (*slices)[sli].Cell(hi).get();
311  for(unsigned int hj = 0; hj < (*slices)[sli].NCell(); ++hj) {
312  if(hi == hj) continue;
313  const rb::CellHit* hitj = (*slices)[sli].Cell(hj).get();
314 
315  // compute delta Time
316  T[hi].push_back(fabs(hiti->TNS()-hitj->TNS()));
317  std::sort(T[hi].begin(),T[hi].end());
318  T[hi].resize(Nn);
319 
320  // if same view, compute 2D Distance
321  if(hiti->View() == hitj->View()) {
322 
323  // get xyz info about i-th hit
324  unsigned int iplane = hiti->Plane();
325  unsigned int icell = hiti->Cell();
326  const geo::PlaneGeo* ip = geom->Plane(iplane);
327  const geo::CellGeo* ic = ip-> Cell (icell);
328  double ixyz[3];
329  ic->GetCenter(ixyz);
330  double iz = ixyz[2];
331  double ixy = 0.0;
332  if (ip->View()==geo::kX) ixy = ixyz[0];
333  if (ip->View()==geo::kY) ixy = ixyz[1];
334 
335  // get xyz info about j-th hit
336  unsigned int jplane = hitj->Plane();
337  unsigned int jcell = hitj->Cell();
338  const geo::PlaneGeo* jp = geom->Plane(jplane);
339  const geo::CellGeo* jc = jp-> Cell (jcell);
340  double jxyz[3];
341  jc->GetCenter(jxyz);
342  double jz = jxyz[2];
343  double jxy = 0.0;
344  if (jp->View()==geo::kX) jxy = jxyz[0];
345  if (jp->View()==geo::kY) jxy = jxyz[1];
346 
347  double dist = sqrt((iz-jz)*(iz-jz) + (ixy-jxy)*(ixy-jxy));
348  D[hi].push_back(dist);
349  std::sort(D[hi].begin(),D[hi].end());
350  D[hi].resize(Nn);
351 
352  }
353 
354  // if opposite view, compute delta Plane
355  if(hiti->View() != hitj->View()) {
356  P[hi].push_back(abs((int)hiti->Plane()-(int)hitj->Plane()));
357  std::sort(P[hi].begin(),P[hi].end());
358  P[hi].resize(Nn);
359  }
360 
361  } // end loop over hits (hj)
362 
363  double Tave = 0.0;
364  int Tn = 0;
365  std::vector<double> Ttemp = T[hi];
366  double Dave = 0.0;
367  int Dn = 0;
368  std::vector<double> Dtemp = D[hi];
369  double Pave = 0.0;
370  int Pn = 0;
371  std::vector<double> Ptemp = P[hi];
372  for(unsigned int a = 0; a < Nn; ++a) {
373  if(Ttemp[a] < 1.0e6) {
374  Tave += Ttemp[a];
375  Tn++;
376  }
377  if(Dtemp[a] < 1.0e6) {
378  Dave += Dtemp[a];
379  Dn++;
380  }
381  if(Ptemp[a] < 1.0e6) {
382  Pave += Ptemp[a];
383  Pn++;
384  }
385  } // end loop over a
386  if(Tn > 0) Tave = Tave/(double)Tn;
387  else Tave = -1.0;
388  if(Dn > 0) Dave = Dave/(double)Dn;
389  else Dave = -1.0;
390  if(Pn > 0) Pave = Pave/(double)Pn;
391  else Pave = -1.0;
392 
393  fAveTClose->Fill(Tave);
394  fAveDClose->Fill(Dave);
395  fAvePClose->Fill(Pave);
396 
397  fTClose3->Fill(Ttemp[2]);
398  fDClose3->Fill(Dtemp[2]);
399  fPClose3->Fill(Ptemp[2]);
400 
401  fTClose4->Fill(Ttemp[3]);
402  fDClose4->Fill(Dtemp[3]);
403  fPClose4->Fill(Ptemp[3]);
404 
405  fTClose5->Fill(Ttemp[4]);
406  fDClose5->Fill(Dtemp[4]);
407  fPClose5->Fill(Ptemp[4]);
408 
409  } // end loop over hits (hi)
410  } // end loop over (slices sli)
411 
412 
413  //
414  // Make plots from ALL pairs of hits
415  //
416 
417  // use i+1 < fNhits to protect against the case where fNhits = 0
418  for(unsigned int i = 0; i+1 < hitlist.size(); ++i) {
419 
420  // get xyz info about i-th hit
421  unsigned int iplane = hitlist[i]->Plane();
422  unsigned int icell = hitlist[i]->Cell();
423  const geo::PlaneGeo* ip = geom->Plane(iplane);
424  const geo::CellGeo* ic = ip-> Cell (icell);
425  double ixyz[3];
426  ic->GetCenter(ixyz);
427  double iz = ixyz[2];
428  double ixy = 0.0;
429  if (ip->View()==geo::kX) ixy = ixyz[0];
430  if (ip->View()==geo::kY) ixy = ixyz[1];
431 
432  for(unsigned int j = i+1; j < hitlist.size(); ++j) {
433 
434  // get xyz info about j-th hit
435  unsigned int jplane = hitlist[j]->Plane();
436  unsigned int jcell = hitlist[j]->Cell();
437  const geo::PlaneGeo* jp = geom->Plane(jplane);
438  const geo::CellGeo* jc = jp-> Cell (jcell);
439  double jxyz[3];
440  jc->GetCenter(jxyz);
441  double jz = jxyz[2];
442  double jxy = 0.0;
443  if (jp->View()==geo::kX) jxy = jxyz[0];
444  if (jp->View()==geo::kY) jxy = jxyz[1];
445 
446  //
447  // Make delta-TXYZ plots...
448  //
449  double dt = hitlist[i]->TNS()-hitlist[j]->TNS();
450  int dp = (int)hitlist[i]->Plane()-(int)hitlist[j]->Plane();
451 
452  fDeltaT0->Fill(dt);
453  if(abs(dp) <= 10) fDeltaT1->Fill(dt);
454 
455  // same view X
456  if(ip->View() == geo::kX && jp->View() == geo::kX) {
457  fDeltaX0->Fill(ixy-jxy);
458  fDeltaZ0->Fill(iz-jz);
459  if(fabs(dt) <= 1000.0) {
460  fDeltaX1->Fill(ixy-jxy);
461  fDeltaZ1->Fill(iz-jz);
462  }
463  }
464 
465  // same view Y
466  if(ip->View() == geo::kY && jp->View() == geo::kY) {
467  fDeltaY0->Fill(ixy-jxy);
468  fDeltaZ0->Fill(iz-jz);
469  if(fabs(dt) <= 1000.0) {
470  fDeltaY1->Fill(ixy-jxy);
471  fDeltaZ1->Fill(iz-jz);
472  }
473  }
474 
475  // opposite views
476  if(ip->View() != jp->View()) {
477  fDeltaP0->Fill(dp);
478  if(fabs(dt) <= 1000.0) {
479  fDeltaP1->Fill(dp);
480  }
481  }
482 
483  }
484  }
485 
486 
487  // std::cout << "\t(done)\n";
488 
489  if(fMakeKDistPlots) {
490 
491  // std::cout << "Preparing k-Dist information...";
492 
493  // have PtMan initialize what it needs to do the k-dist calculations
494  // loop over all hits
495  // - get the k-dist values for k = 2 to 7 and fill std::vectors of doubles
496  // - sort each vector and fill the histo
497  // - MAKE SURE THESE HISTOS ARE WRITTEN AND RESET PER EVENT!!!!!
498 
499  TH1F *f2dist = new TH1F("f2dist","2-dist for all hits",20001,-0.5,20000.5);
500  TH1F *f3dist = new TH1F("f3dist","3-dist for all hits",20001,-0.5,20000.5);
501  TH1F *f4dist = new TH1F("f4dist","4-dist for all hits",20001,-0.5,20000.5);
502  TH1F *f5dist = new TH1F("f5dist","5-dist for all hits",20001,-0.5,20000.5);
503 
505 
506  // std::cout << "\t(done)\n";
507 
508  for(unsigned int k = 2; k <= 5; ++k) {
509  // std::cout << "Filling kDist plots for k = " << k << "...";
510  double kdist[hitcol->size()];
511  for(unsigned int i = 0; i < hitcol->size(); ++i) {
512  kdist[i] = fPtMan.kDist(k,i);
513  } // end for i
514 
515  // sort kdist
516  bool done = false;
517  while(!done) {
518  done = true;
519  for(unsigned int j = 1; j < hitcol->size(); ++j) {
520  if(kdist[j-1] < kdist[j]) {
521  double temp = kdist[j];
522  kdist[j] = kdist[j-1];
523  kdist[j-1] = temp;
524  done = false;
525  } // end if
526  } // end for j
527  } // end while !done
528 
529  if(k == 2) {
530  for(unsigned int i = 0; i < hitcol->size(); ++i) {
531  f2dist->Fill(i,kdist[i]);
532  } // end for i
533  }
534  if(k == 3) {
535  for(unsigned int i = 0; i < hitcol->size(); ++i) {
536  f3dist->Fill(i,kdist[i]);
537  } // end for i
538  }
539  if(k == 4) {
540  for(unsigned int i = 0; i < hitcol->size(); ++i) {
541  f4dist->Fill(i,kdist[i]);
542  } // end for i
543  }
544  if(k == 5) {
545  for(unsigned int i = 0; i < hitcol->size(); ++i) {
546  f5dist->Fill(i,kdist[i]);
547  } // end for i
548  }
549  // std::cout << "\t(done)\n";
550  } // end for k
551 
553  tfs->make<TH1F>(*f2dist);
554  tfs->make<TH1F>(*f3dist);
555  tfs->make<TH1F>(*f4dist);
556  tfs->make<TH1F>(*f5dist);
557 
558  // std::cout << "\n\n====================\nFinished processing.\n\n";
559 
560  if(f2dist) { delete f2dist; f2dist = 0; }
561  if(f3dist) { delete f3dist; f3dist = 0; }
562  if(f4dist) { delete f4dist; f4dist = 0; }
563  if(f5dist) { delete f5dist; f5dist = 0; }
564 
565  } // end if{fMakeKDistPlots)
566 
567  // std::cout << "\n\n";
568 
569  return;
570  }
571 
572 } // end namespace slicer
573 ////////////////////////////////////////////////////////////////////////
574 
575 
576 
578 
579 namespace slicer
580 {
582 }
float TNS() const
Definition: CellHit.h:46
double fOpVPlPen
Allowed plane gap for hits in opposite views for which the distance penalty will be 1...
bool fUseLowPEPen
Add a causal distance penalty for PE (low PE is INCREASES the distance)
void analyze(const art::Event &evt)
double GetTimeRes(rb::CellHit const &cellhit)
void GetCenter(double *xyz, double localz=0.0) const
Definition: CellGeo.cxx:159
void Initalize(double eps, double pepen, double distpen, double opvplpen, bool usepepen)
fvar< T > fabs(const fvar< T > &x)
Definition: fabs.hpp:15
unsigned short Plane() const
Definition: CellHit.h:39
geo::View_t View() const
Definition: CellHit.h:41
T sqrt(T number)
Definition: d0nt_math.hpp:156
void Reset(unsigned int n, bool skip=true)
Vertical planes which measure X.
Definition: PlaneGeo.h:28
void PreparekDistInfo(unsigned int kmax)
void abs(TH1 *hist)
TString ip
Definition: loadincs.C:5
double fDistPen
Distance (in cm) for which the distance penalty will be 1 (roughly one strong interaction length...
const PlaneGeo * Plane(unsigned int i) const
unsigned int fMinPts
minimum number of casual neighbors for a hit to be in a cluster
DEFINE_ART_MODULE(TestTMapFile)
Horizontal planes which measure Y.
Definition: PlaneGeo.h:29
double dist
Definition: runWimpSim.h:113
#define P(a, b, c, d, e, x)
unsigned short Cell() const
Definition: CellHit.h:40
Definition: Cand.cxx:23
View_t View() const
Which coordinate does this plane measure.
Definition: PlaneGeo.h:53
TSpline3 hi("hi", xhi, yhi, 18,"0")
const double a
T get(std::string const &key) const
Definition: ParameterSet.h:231
Geometry information for a single readout plane.
Definition: PlaneGeo.h:36
float PE() const
Definition: CellHit.h:42
double fEpsilon
Minimum causal separation value.
const double j
Definition: BetheBloch.cxx:29
EDAnalyzer(Table< Config > const &config)
Definition: EDAnalyzer.h:100
void AddHit(double t, double tres, unsigned int p, unsigned int c, double pe, geo::View_t v)
::xsd::cxx::tree::string< char, simple_type > string
Definition: Database.h:154
A rawdata::RawDigit with channel information decoded.
Definition: CellHit.h:27
T * make(ARGS...args) const
S4DParamCalc(fhicl::ParameterSet const &pset)
void reconfigure(const fhicl::ParameterSet &pset)
double fPEPen
PE value for which the low PE penalty will be 1.
bool getByLabel(std::string const &label, std::string const &productInstanceName, Handle< PROD > &result) const
Definition: DataViewImpl.h:344
Definition: event.h:1
Helper class for Slicer4D.
Definition: PointManager.h:17
void geom(int which=0)
Definition: geom.C:163
Class to help Slicer4D manage the collection of hits.
double T
Definition: Xdiff_gwt.C:5
Encapsulate the cell geometry.
Definition: CellGeo.h:25
double kDist(unsigned int k, unsigned int pt)
Encapsulate the geometry of one entire detector (near, far, ndos)