DimuonSliceAna_module.cc
Go to the documentation of this file.
1 ///
2 /// \file DimuonSliceAna_module.cc
3 /// \brief Run the break-point fitter
4 /// \author messier@indiana.edu
5 /// \version $Id:$
6 ///
7 #include <algorithm>
8 //
9 #include "TH1F.h"
10 #include "TTree.h"
11 //
16 //
17 #include "Geometry/Geometry.h"
19 #include "RecoBase/CellHit.h"
20 #include "RecoBase/Vertex.h"
21 #include "RecoBase/Cluster.h"
22 #include "RecoBase/FilterList.h"
23 //
24 #include "Utilities/AssociationUtil.h"
25 //
26 #include "Tridents/Pass1Nt.h"
27 
28 namespace trident { class DimuonSliceAna; }
29 
31 {
32 public:
34 
35 public:
36  // Member data
37  int fVerbosity; ///< 0-100, how much text output to generate
38  unsigned int fNevtIN; ///< Total number of events seen
39  unsigned int fNevtPASS; ///< Total number of events passed
40  unsigned int fNTOTAL; ///< Total number of slices seen
41  unsigned int fNNHIT; ///< Number passing NHIT
42  unsigned int fNVETO; ///< Number passing through to VETO
43  unsigned int fNVTX; ///< Number passing through to VTX
44  unsigned int fNSHAPE; ///< Number passing thorugh to SHAPE
45  Pass1Nt* fNt; ///< Summary ntuple
46  TTree* fNtTree; ///< Tree for ntuple
47 
48 public:
49  //......................................................................
50 
52  {
53  fVerbosity = p.get<int>("Verbosity");
54  }
55 
56  //......................................................................
57 
59  fSliceToken(consumes<std::vector<rb::Cluster>>(p.get<std::string>("SlicerLabel"))),
60  fNt(0)
61  {
62  this->produces< std::vector<rb::Vertex> >();
63  this->produces< art::Assns<rb::Vertex, rb::Cluster> > ();
64  this->produces< std::vector<Pass1Nt> > ();
65  this->produces< rb::FilterList<rb::Cluster> >();
66  this->reconfigure(p);
67  }
68 
69  //......................................................................
70 
71  virtual ~DimuonSliceAna()
72  {
73  if (fNt) { delete fNt; fNt = 0; }
74  }
75 
76  //......................................................................
77 
79  {
80  bool np = (fNt->np>=20 && fNt->np<=200);
81  bool nhit = (fNt->nhitx+fNt->nhity)>=30;
82  bool anhit = (fabs(fNt->nhitx-fNt->nhity)/(float)(fNt->nhitx+fNt->nhity))<=0.5;
83  bool n2p = (fNt->n2p>=8);
84  bool n3p = (fNt->n3p<=40);
85  fNt->NHIT = (np & nhit & anhit & n2p & n3p);
86 
87  bool np5 = (fNt->np5<=1);
88  bool nwall = (((fNt->nc5t>1) +
89  (fNt->nc5b>1) +
90  (fNt->nc5l>1) +
91  (fNt->nc5r>1))<=2);
92  fNt->VETO = (np5 & nwall);
93 
94  bool x = (fabs(fNt->x)<=160);
95  bool y = (fabs(fNt->y)<=160);
96  bool z = (fNt->z>=50 && fNt->z<=1000);
97  fNt->VTX = (x & y & z);
98 
99  bool hperp = ((float)(fNt->nhitx+fNt->nhity)/(float)fNt->np<=2.5);
100  bool ncnp = (sqrt(fNt->ncx*fNt->ncx+fNt->ncy*fNt->ncy)/(float)fNt->np<=1.2);
101  bool n10 = (fNt->n10<=25);
102  bool pks = (log10(fNt->pks)>=-4.5);
103  fNt->SHAPE = (hperp & ncnp & n10 & pks);
104 
105  fNt->SLICE = (fNt->NHIT & fNt->VETO & fNt->VTX & fNt->SHAPE);
106  }
107 
108  //....................................................................
109 
110  void beginJob()
111  {
112  fNevtIN = 0;
113  fNevtPASS = 0;
114  fNTOTAL = 0;
115  fNNHIT = 0;
116  fNVETO = 0;
117  fNVTX = 0;
118  fNSHAPE = 0;
120  fNt = new Pass1Nt;
121  fNtTree = f->make<TTree>("p1","dimuon pass 1");
122  fNtTree->Branch("fPass1Nt", "trident::Pass1Nt", &fNt, 1600, 99);
123  }
124 
125  //....................................................................
126 
127  void endJob()
128  {
129  std::cout << "*-- DimuonSliceFilter Result --" << std::endl;
130  std::cout << "| Passed " << fNevtPASS << " of " << fNevtIN
131  << " (" << 100.0*fNevtPASS/(float)fNevtIN << "%)"
132  << std::endl;
133  std::cout << "| Slice summary" << std::endl;
134  std::cout << "| Ntotal = " << fNTOTAL << std::endl;
135  std::cout << "| Nnhit = " << fNNHIT << " |\t"
136  << 100.0*fNNHIT/ (float)fNTOTAL << "% |\t"
137  << 100.0*fNNHIT/ (float)fNTOTAL << "%" << std::endl;
138  std::cout << "| Nveto = " << fNVETO << " |\t"
139  << 100.0*fNVETO/ (float)fNTOTAL << "% |\t"
140  << 100.0*fNVETO/ (float)fNNHIT << "%" << std::endl;
141  std::cout << "| Nvtx = " << fNVTX << " |\t"
142  << 100.0*fNVTX/ (float)fNTOTAL << "% |\t"
143  << 100.0*fNVTX/ (float)fNVETO << "%" << std::endl;
144  std::cout << "| Nshape = " << fNSHAPE << " |\t"
145  << 100.0*fNSHAPE/(float)fNTOTAL << "% |\t"
146  << 100.0*fNSHAPE/(float)fNVTX << "%" << std::endl;
147  std::cout << "*.. DimuonSliceFilter Result .." << std::endl;
148  }
149 
150  //......................................................................
151 
152  void FindSlices(const art::Event& evt,
153  art::Handle< std::vector<rb::Cluster> >& h,
155  {
156  unsigned int i;
157  evt.getByToken(fSliceToken, h);
158  for (i=0; i<h->size(); ++i) {
160  }
161  if (fVerbosity>10) {
162  std::cout << __FILE__ << ":" << __LINE__
163  << " Found " << s.size() << " slices."
164  << std::endl;
165  }
166  }
167 
168  //......................................................................
169  //
170  // Dimuon trident events should have roughly two hit cells in every
171  // plane all the way from start to end. So, the distribution of
172  // cells is expected to be roughly uniform from front to
173  // back. Normal neutrino events will have a hadron shower at the
174  // start, so we expect them to have a "front loaded" distribution of
175  // hits. To test this, compare the distribution of the number of hit
176  // cells vs. plane number to a flat distribution using a KS test to see
177  // if we can separate the tridents from other neutrino interactions.
178  //
179  double PlaneKS(std::vector<int>& plane_number)
180  {
181  unsigned int i;
182  int plane_lo = 9999;
183  int plane_hi = 0;
184  unsigned int n;
185  for (i=0; i<plane_number.size(); ++i) {
186  if (plane_number[i]<plane_lo) plane_lo = plane_number[i];
187  if (plane_number[i]>plane_hi) plane_hi = plane_number[i];
188  }
189  n = plane_hi - plane_lo + 1;
190  TH1F h1("dimuon_h1","",n,(float)plane_lo-0.5,(float)plane_hi+0.5);
191  TH1F h2("dimuon_h2","",n,(float)plane_lo-0.5,(float)plane_hi+0.5);
192  for (i=0; i<plane_number.size(); ++i) {
193  h1.Fill(plane_number[i]);
194  }
195  for (i=0; i<n; ++i) {
196  h2.SetBinContent(i+1,(float)plane_number.size()/(float)n);
197  }
198  double Pks = h1.KolmogorovTest(&h2);
199 
200  if (fVerbosity>20) {
201  std::cout << __FILE__ << ":" << __LINE__ << " KS Test ==" << std::endl;
202  for (i=0; i<n; ++i) {
203  std::cout << i << "\t"
204  << h1.GetBinContent(i+1) << "\t"
205  << h2.GetBinContent(i+1) << std::endl;
206  }
207  std::cout << h1.Integral() << "\t" << h2.Integral() << std::endl;
208  std::cout << "Pks = " << Pks << std::endl;
209  }
210 
211  return Pks;
212  }
213 
214  //....................................................................
215 
217  int* npl,
218  int* ncx,
219  int* ncy,
220  int* n1hp,
221  int* n2hp,
222  int* n3hp,
223  int* n10)
224  {
225  unsigned int i;
226  std::vector<int> hitp(1000);
227  std::vector<int> hitcx(1000);
228  std::vector<int> hitcy(1000);
229  *npl = 0;
230  *ncx = 0;
231  *ncy = 0;
232  for (i=0; i<s->NCell(); ++i) {
233  int p = s->Cell(i)->Plane();
234  int c = s->Cell(i)->Cell();
235 
236  if (hitp[p]==0) ++(*npl);
237  ++hitp[p];
238 
239  if (s->Cell(i)->View()==geo::kX) {
240  if (hitcx[c]==0) {
241  ++(*ncx);
242  hitcx[c] = 1;
243  }
244  }
245  if (s->Cell(i)->View()==geo::kY) {
246  if (hitcy[c]==0) {
247  ++(*ncy);
248  hitcy[c] = 1;
249  }
250  }
251  }
252  //
253  // Count how many planes have exactly one hit in them
254  //
255  int N1hp = 0;
256  int N2hp = 0;
257  int N3hp = 0;
258  int N10 = 0;
259  int P10 = 0;
260  for (i=0; i<hitp.size(); ++i) {
261  if (hitp[i]==1) ++N1hp;
262  if (hitp[i]==2) ++N2hp;
263  if (hitp[i]>2) ++N3hp;
264  if (hitp[i]>0 && P10<10) {
265  N10 += hitp[i];
266  ++P10;
267  }
268  }
269  *n1hp = N1hp;
270  *n2hp = N2hp;
271  *n3hp = N3hp;
272  *n10 = N10;
273  }
274 
275  //......................................................................
276  //
277  // Make an analysis of the variables corresponding to a single slice.
278  //
279  // Return "true" if this is a slice we want to keep in the analysis
280  // "false" if we thinkg this slice is ~100% likely to be background.
281  //
282  // This selection is reduction pass 1 for the analysis
283  //
284  //
285  bool AnaSlice(const rb::Cluster* s) {
286  unsigned int i;
287  //
288  // Define the cell boundaries at the edges of the detector
289  //
290  int icl = 5; // 5 cells on the left side
291  int icr = 90; // 5 cells on the right side
292  int icb = 5; // 5 cells on the bottom face
293  int ict = 90; // 5 cells on the top face
294  int ipf = 5; // 5 planes on the front face
295  int nc5l = 0; // number hits in the boundary on the left
296  int nc5r = 0; // "" on the right
297  int nc5t = 0; // "" on the top
298  int nc5b = 0; // "" on the bottom
299  int np5 = 0; // Number of hits in the first 5 planes
300  std::vector<int> plane_numbers; // A list of all the hit plane numbers, one per cell
301  for (i=0; i<s->NCell(); ++i) {
302  int p = s->Cell(i)->Plane();
303  int c = s->Cell(i)->Cell();
304  plane_numbers.push_back(p);
305  //
306  // Count cell hits near walls. Don't double count hits in the
307  // corners (hence the "else")
308  //
309  if (p<ipf) {
310  ++np5;
311  }
312  else {
313  if (s->Cell(i)->View()==geo::kX) {
314  if (c<icl) ++nc5r;
315  if (c>icr) ++nc5l;
316  }
317  else if (s->Cell(i)->View()==geo::kY) {
318  if (c<icb) ++nc5b;
319  if (c>ict) ++nc5t;
320  }
321  }
322  }
323 
324  int npl = 0; // Number of hit planes
325  int ncx = 0; // Number of hit cells in x view
326  int ncy = 0; // Number of hit cells in y view
327  int n1hp = 0; // Number of planes with 1 hit
328  int n2hp = 0; // Number of phanes with 2 hits
329  int n3hp = 0; // Number of planes with 3+ hits
330  int n10 = 0; // Number of hits in first 10 hit planes
331  this->PlaneCellCounts(s,
332  &npl,
333  &ncx,
334  &ncy,
335  &n1hp,
336  &n2hp,
337  &n3hp,
338  &n10);
339  double Pks = this->PlaneKS(plane_numbers);
340 
341  //
342  // Move the results to the summary ntuple
343  //
344  fNt->np = npl;
345  fNt->ncx = ncx;
346  fNt->ncy = ncy;
347  fNt->nhitx = s->NXCell();
348  fNt->nhity = s->NYCell();
349  fNt->np5 = np5;
350  fNt->nc5l = nc5l;
351  fNt->nc5r = nc5r;
352  fNt->nc5t = nc5t;
353  fNt->nc5b = nc5b;
354  fNt->pks = Pks;
355  fNt->n1p = n1hp;
356  fNt->n2p = n2hp;
357  fNt->n3p = n3hp;
358  fNt->n10 = n10;
359 
360  return true;
361  }
362  //......................................................................
363 
364  void FindVertex(const rb::Cluster* c,
365  double *x,
366  double *y,
367  double *z)
368  {
369  if (fVerbosity>20) {
370  std::cout << __FILE__ << ":" << __LINE__
371  << " Start 'FindVertex'. "
372  << " Cluster has " << c->NCell() << " cells" << std::endl;
373  }
374  unsigned int i, j;
375  unsigned int ip, ic;
376  //
377  // The way we are going to find a candidate vertex z location is
378  // to identify the first plane which is followed by a reasonably
379  // continuous set of activity. So, we will loop over all the hits,
380  // record their plane locations. Then we will look for the first
381  // plane in the list where if I step n positions forward in the
382  // list the plane number doesn't change more than m. While we are
383  // making this list, keep track of the lowest z position we've
384  // seen. In cases where we don't have enough hits to apply the
385  // algorithm above, we'll just use that lowest z value.
386  //
387  std::vector<unsigned int> p(c->NCell());
388  unsigned int pvtx = 999999;
389  for (i=0; i<c->NCell(); ++i) {
390  ip = c->Cell(i)->Plane();
391  if (ip<pvtx) pvtx = ip;
392  p[i] = ip;
393  }
394  if (fVerbosity>20) {
395  std::cout << __FILE__ << ":" << __LINE__
396  << " Set default vertex plane to pvtx="
397  << pvtx << std::endl;
398  }
399  std::sort(p.begin(), p.end());
400 
401  const unsigned int N = 2; // How far to skip forward in list
402  const unsigned int M = N+2; // Plane numbers should be this close or closer
403  for (i=0, j=N; j+1<c->NCell(); ++i,++j) {
404  if ( (p[j]-p[i])<=M ) {
405  pvtx = p[i];
406  if (fVerbosity>20) {
407  std::cout << __FILE__ ":" << __LINE__
408  << " Plane " << pvtx << " satisfies "
409  << " N= " << N
410  << " M= " << M
411  << " pi = " << p[i] << " condition."
412  << " pj = " << p[j] << std::endl;
413  }
414  break;
415  }
416  }
417  //
418  // Now find the closest hits cells that match this plane position
419  //
420  *x = -9999;
421  *y = -9999;
422  *z = -9999;
423  unsigned int dp = 0;
424  unsigned int dx = 99999;
425  unsigned int dy = 99999;
426  geo::View_t v;
428  for (i=0; i<c->NCell(); ++i) {
429  double xyz[3];
430  ip = c->Cell(i)->Plane();
431  ic = c->Cell(i)->Cell();
432  v = geom->Plane(ip)->View();
433  geom->Plane(ip)->Cell(ic)->GetCenter(xyz);
434 
435  dp = 0;
436  if (ip>pvtx) dp = ip-pvtx;
437  else dp = pvtx-ip;
438  if (dp<dx && v==geo::kX) {
439  *x = xyz[0];
440  dx = dp;
441  }
442  if (dp<dy && v==geo::kY) {
443  *y = xyz[1];
444  dy = dp;
445  }
446  if (ip==pvtx) {
447  *z = xyz[2];
448  }
449  }
450  if (fVerbosity>10) {
451  std::cout << __FILE__ << ":" << __LINE__
452  << " Find Vertex = (" << *x << "," << *y << "," << *z << ")"
453  << std::endl;
454  }
455  }
456 
457  //......................................................................
458 
460  {
461  //
462  // Vertex and vertex to cluster ART products
463  //
464  std::unique_ptr< std::vector<rb::Vertex> >
465  vtx(new std::vector<rb::Vertex>);
466  std::unique_ptr< art::Assns<rb::Vertex, rb::Cluster> >
468  std::unique_ptr< rb::FilterList<rb::Cluster> >
469  slice_filt(new rb::FilterList<rb::Cluster>);
470  std::unique_ptr< std::vector<Pass1Nt> >
471  pass1nt(new std::vector<Pass1Nt>);
472 
473  fNt->run = evt.run();
474  fNt->subrun = evt.subRun();
475  fNt->event = evt.id().event();
476  ++fNevtIN;
477  //
478  // Extract the slices, vertices, and tracks we need as inputs
479  //
482  this->FindSlices(evt, sliceh, slicep);
483 
484  unsigned int nGoodSlice = 0;
485  unsigned int islice;
486  for (islice=0; islice<slicep.size(); ++islice) {
487  fNt->slice = islice;
488  //
489  // Get the index of this slices and a pointer to it for
490  // convenient access. Skip the noice slice, no physics there for
491  // us.
492  //
493  const art::Ptr<rb::Cluster> slice = slicep[islice];
494  if (slice->IsNoise()) continue;
495  //
496  // Analyze the slice and see if it passes selections for analysis
497  //
498  this->AnaSlice(slice.get());
499 
500  //
501  // The track fits require a candidate z vertex location
502  //
503  double x, y, z;
504  this->FindVertex(slice.get(), &x, &y, &z);
505  vtx->push_back(rb::Vertex(x, y, z, 0));
506  util::CreateAssn(*this, evt, *vtx, slice, *v2cAssn);
507  fNt->x = x;
508  fNt->y = y;
509  fNt->z = z;
510  //
511  // Annouce that we ran to the log file...
512  //
513  if (fVerbosity>0) {
514  std::cout << __FILE__ << ":" << __LINE__
515  << " Slice #: " << islice << std::endl;
516  }
517  //
518  // Make a go-no-go selection on the slice. At this point the
519  // information in fNt is finalized and we can commit it to the
520  // event.
521  //
522  this->MakeSelections();
523  fNtTree->Fill();
524  pass1nt->push_back(*fNt);
525 
526  if (fNt->SLICE) ++nGoodSlice;
527  else slice_filt->Add(sliceh, islice);
528 
529  //
530  // Keep track of some summary slice counts
531  //
532  ++fNTOTAL;
533  if (fNt->NHIT) { ++fNNHIT;
534  if (fNt->VETO) { ++fNVETO;
535  if (fNt->VTX) { ++fNVTX;
536  if (fNt->SHAPE) ++fNSHAPE;
537  }
538  }
539  }
540  } // Loop on slices
541 
542  evt.put(std::move(vtx));
543  evt.put(std::move(v2cAssn));
544  evt.put(std::move(slice_filt));
545  evt.put(std::move(pass1nt));
546  if (nGoodSlice>0) {
547  if (fVerbosity>10) {
548  std::cout << __FILE__ << ":" << __LINE__
549  << " Event passes: "
550  << fNt->run << ":" << fNt->event
551  << " Has " << nGoodSlice
552  << " slices out of " << slicep.size()
553  << std::endl;
554  }
555  ++fNevtPASS;
556  return true;
557  }
558  if (fVerbosity>10) {
559  std::cout << __FILE__ << ":" << __LINE__
560  << " Event fails: "
561  << fNt->run << ":" << fNt->event
562  << " Has " << nGoodSlice
563  << " slices out of " << slicep.size() << std::endl;
564  }
565  return false;
566  } // filter() method
567 };
568 
569 //......................................................................
570 
572 
573 ////////////////////////////////////////////////////////////////////////
void FindSlices(const art::Event &evt, art::Handle< std::vector< rb::Cluster > > &h, art::PtrVector< rb::Cluster > &s)
A simple list of products that have been marked "filtered out".
Definition: FilterList.h:74
A 3D position and time representing an interaction vertex.
Definition: Vertex.h:15
SubRunNumber_t subRun() const
Definition: Event.h:72
static bool CreateAssn(art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
Create a 1 to 1 association between a new product and one already in the event.
TTree * fNtTree
Tree for ntuple.
unsigned int NCell(geo::View_t view) const
Number of cells in view view.
Definition: Cluster.cxx:134
int run
Run number.
Definition: Pass1Nt.h:15
int subrun
Subrun number.
Definition: Pass1Nt.h:16
void GetCenter(double *xyz, double localz=0.0) const
Definition: CellGeo.cxx:159
fvar< T > fabs(const fvar< T > &x)
Definition: fabs.hpp:15
enum geo::_plane_proj View_t
Enumerate the possible plane projections.
unsigned short Plane() const
Definition: CellHit.h:39
float x
Vertex x locations (cm)
Definition: Pass1Nt.h:34
geo::View_t View() const
Definition: CellHit.h:41
const CellGeo * Cell(int icell) const
Definition: PlaneGeo.h:48
const char * p
Definition: xmltok.h:285
T sqrt(T number)
Definition: d0nt_math.hpp:156
Vertical planes which measure X.
Definition: PlaneGeo.h:28
int nc5t
Number of hits in the 5 edge cells, top.
Definition: Pass1Nt.h:27
int ncx
Number of hit cell numbers in x view.
Definition: Pass1Nt.h:20
A collection of associated CellHits.
Definition: Cluster.h:47
unsigned int fNevtPASS
Total number of events passed.
nhit
Definition: demo1.py:25
void PlaneCellCounts(const rb::Cluster *s, int *npl, int *ncx, int *ncy, int *n1hp, int *n2hp, int *n3hp, int *n10)
int np5
Number of hits in the first 5 detector planes.
Definition: Pass1Nt.h:24
TString ip
Definition: loadincs.C:5
Ntuple for the pass 1 trident selections.
const PlaneGeo * Plane(unsigned int i) const
DEFINE_ART_MODULE(TestTMapFile)
const art::ProductToken< std::vector< rb::Cluster > > fSliceToken
int n3p
Number of planes with three+ hits.
Definition: Pass1Nt.h:32
unsigned int fNSHAPE
Number passing thorugh to SHAPE.
Horizontal planes which measure Y.
Definition: PlaneGeo.h:29
int ncy
Number of hit cell numbers in y view.
Definition: Pass1Nt.h:21
unsigned int fNVTX
Number passing through to VTX.
void FindVertex(const rb::Cluster *c, double *x, double *y, double *z)
ProductID put(std::unique_ptr< PROD > &&product)
Definition: Event.h:102
unsigned short Cell() const
Definition: CellHit.h:40
const XML_Char * s
Definition: expat.h:262
View_t View() const
Which coordinate does this plane measure.
Definition: PlaneGeo.h:53
Pass1Nt * fNt
Summary ntuple.
int event
Event number.
Definition: Pass1Nt.h:17
double dy[NP][NC]
double dx[NP][NC]
double PlaneKS(std::vector< int > &plane_number)
void push_back(Ptr< U > const &p)
Definition: PtrVector.h:441
int nhity
Number of hits in the y view.
Definition: Pass1Nt.h:23
T get(std::string const &key) const
Definition: ParameterSet.h:231
int n2p
Number of planes with two hits.
Definition: Pass1Nt.h:31
unsigned int fNTOTAL
Total number of slices seen.
int evt
const double j
Definition: BetheBloch.cxx:29
int slice
Slice number.
Definition: Pass1Nt.h:18
bool NHIT
Result of nhit selections.
Definition: Pass1Nt.h:37
Vertex location in position and time.
Perform a "2 point" Hough transform on a collection of hits.
int fVerbosity
0-100, how much text output to generate
float pks
K-S probability of uniform hits vs plane.
Definition: Pass1Nt.h:29
z
Definition: test.py:28
size_type size() const
Definition: PtrVector.h:308
int nhitx
Number of hits in the x view.
Definition: Pass1Nt.h:22
unsigned int fNNHIT
Number passing NHIT.
OStream cout
Definition: OStream.cxx:6
TH1F * h2
Definition: plot.C:45
unsigned int NYCell() const
Number of cells in the y-view.
Definition: Cluster.h:108
EventNumber_t event() const
Definition: EventID.h:116
art::Ptr< rb::CellHit > Cell(geo::View_t view, unsigned int viewIdx) const
Get the ith cell from view view.
Definition: Cluster.cxx:145
TH1F * h1
bool AnaSlice(const rb::Cluster *s)
T * make(ARGS...args) const
int n10
Number of hits inside first 10 event planes.
Definition: Pass1Nt.h:33
T const * get() const
Definition: Ptr.h:321
T log10(T number)
Definition: d0nt_math.hpp:120
void reconfigure(fhicl::ParameterSet const &p)
unsigned int NXCell() const
Number of cells in the x-view.
Definition: Cluster.h:106
unsigned int fNVETO
Number passing through to VETO.
void geom(int which=0)
Definition: geom.C:163
bool VTX
Result of vertex selections.
Definition: Pass1Nt.h:39
Ntuple produced by the pass1 trident selections.
Definition: Pass1Nt.h:12
unsigned int fNevtIN
Total number of events seen.
int nc5r
Number of hits in the 5 edge cells, right.
Definition: Pass1Nt.h:26
int n1p
Number of planes with one hit.
Definition: Pass1Nt.h:30
int nc5l
Number of hits in the 5 edge cells, left.
Definition: Pass1Nt.h:25
bool IsNoise() const
Is the noise flag set?
Definition: Cluster.h:163
bool getByToken(ProductToken< PROD > const &token, Handle< PROD > &result) const
Definition: DataViewImpl.h:387
float y
Vertex y locations (cm)
Definition: Pass1Nt.h:35
RunNumber_t run() const
Definition: Event.h:77
int nc5b
Number of hits in the 5 edge cells, bottom.
Definition: Pass1Nt.h:28
bool SHAPE
Result of shape selections.
Definition: Pass1Nt.h:40
ProductToken< T > consumes(InputTag const &)
float z
Vertex z locations (cm)
Definition: Pass1Nt.h:36
int np
Number of hit planes.
Definition: Pass1Nt.h:19
EventID id() const
Definition: Event.h:56
bool SLICE
Overall decision on the slice.
Definition: Pass1Nt.h:41
Encapsulate the geometry of one entire detector (near, far, ndos)
bool filter(art::Event &evt)
DimuonSliceAna(fhicl::ParameterSet const &p)
bool VETO
Result of wall veto selections.
Definition: Pass1Nt.h:38
enum BeamMode string