TBRecoAna_module.cc
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////
2 // \file TBRecoAna_module.cc
3 // \brief Analyzer module for basic reco analysis of initial Beamline data files.
4 // \author lackey32@fnal.gov
5 ////////////////////////////////////////////////////////////////////////
6 
7 // C/C++ includes
8 #include <string>
9 
10 // ROOT includes
11 #include "TH1F.h"
12 #include "TH2F.h"
13 #include "TTimeStamp.h"
14 #include "TTree.h"
15 
16 // Framework includes
27 #include "fhiclcpp/ParameterSet.h"
29 
30 // NOvASoft includes
32 #include "BeamlineRecoBase/ToF.h"
34 #include "Geometry/LiveGeometry.h"
35 #include "MCCheater/BackTracker.h"
36 #include "NovaTimingUtilities/TimingUtilities.h"
37 #include "RawData/RawTrigger.h"
38 #include "RecoBase/CellHit.h"
39 #include "RecoBase/Cluster.h"
40 #include "RecoBase/FitSum.h"
41 #include "RecoBase/Prong.h"
42 #include "RecoBase/RecoHit.h"
43 #include "RecoBase/Shower.h"
44 #include "RecoBase/Vertex.h"
45 
46 
47 namespace tbem {
48 
49 
50  class TBRecoAna : public art::EDAnalyzer {
51  public:
52  explicit TBRecoAna(fhicl::ParameterSet const& pset);
53  ~TBRecoAna();
54  void analyze(const art::Event& evt);
55  void reconfigure(const fhicl::ParameterSet& pset);
56  void beginJob();
57  void endJob();
58 
59  private:
60 
70 
71  Int_t nhit, run, subrun, event;
72  Double_t evtTime;
73  Double_t toftime, wcmom, ckovadc;
74 
75  std::vector<int> hitPlane, hitCell;
76  std::vector<double> hitTime;
77 
78  std::vector<int> slice;
79  std::vector<int> sliceNhit, prongNhit;
80  std::vector<double> cosVtxX, cosVtxY, cosVtxZ;
81  std::vector<double> sliceCalE, sliceADCTot, sliceMaxPlane;
82  std::vector<int> cosTrkNhit, winTrkNhit;
83  std::vector<double> cosTrkStrtX, cosTrkStrtY, cosTrkStrtZ;
84  std::vector<double> cosTrkStopX, cosTrkStopY, cosTrkStopZ;
85  std::vector<double> cosTrkDirX, cosTrkDirY, cosTrkDirZ;
86  std::vector<double> winTrkCalE, winTrkADCTot, winTrkMaxPlane;
87  std::vector<double> winTrkStrtX, winTrkStrtY, winTrkStrtZ;
88  std::vector<double> winTrkStopX, winTrkStopY, winTrkStopZ;
89  std::vector<double> winTrkDirX, winTrkDirY, winTrkDirZ;
90  std::vector<double> prongE, prongCalE, prongADCTot;
91  std::vector<double> prongStrtX, prongStrtY, prongStrtZ;
92  std::vector<double> prongDirX, prongDirY, prongDirZ;
93  std::vector<double> prongHitTime;
94  std::vector<double> chitHitTime;
97 
98  std::vector<int> bpfNhit;
99  std::vector<double> bpfStrtX, bpfStrtY, bpfStrtZ;
100  std::vector<double> bpfDirX, bpfDirY, bpfDirZ;
101  std::vector<double> bpfTrkHitTime;
102 
103  TTree *emshower;
104 
105  };
106 
107  //.......................................................................
108 
110  : EDAnalyzer(pset)
111  {
112  reconfigure(pset);
113  }
114 
115  //.......................................................................
116 
118  {
119  }
120 
121  //.......................................................................
122 
124  {
125  fRawDataLabel = pset.get<std::string>("RawDataLabel");
126  fClusterLabel = pset.get<std::string>("ClusterLabel");
127  fVertexLabel = pset.get<std::string>("VertexLabel");
128  fProngModLabel= pset.get<std::string>("ProngModLabel");
129  fProng2DLabel = pset.get<std::string>("Prong2DLabel");
130  fProng3DLabel = pset.get<std::string>("Prong3DLabel");
131  fRecoToFLabel = pset.get<std::string>("RecoToFLabel");
132  fRecoWCLabel = pset.get<std::string>("RecoWCLabel");
133  fRecoCherenkovLabel = pset.get<std::string>("RecoCherenkovLabel");
134  }
135 
136  //.......................................................................
137 
139  {
141 
142  emshower = tfs->make<TTree>("evts","");
143  emshower->Branch("run",&run,"run/I");
144  emshower->Branch("subrun",&subrun,"subrun/I");
145  emshower->Branch("event",&event,"event/I");
146  emshower->Branch("slice",&slice);
147  emshower->Branch("evtTime",&evtTime,"evtTime/D");
148  emshower->Branch("nhit",&nhit,"nhit/I");
149  emshower->Branch("hitPlane",&hitPlane);
150  emshower->Branch("hitCell",&hitCell);
151  emshower->Branch("hitTime",&hitTime);
152  emshower->Branch("sliceCalE",&sliceCalE);
153  emshower->Branch("sliceADCTot",&sliceADCTot);
154  emshower->Branch("sliceMaxPlane",&sliceMaxPlane);
155  emshower->Branch("cosVtxX",&cosVtxX);
156  emshower->Branch("cosVtxY",&cosVtxY);
157  emshower->Branch("cosVtxZ",&cosVtxZ);
158  emshower->Branch("prongE",&prongE);
159  emshower->Branch("prongCalE",&prongCalE);
160  emshower->Branch("prongADCTot",&prongADCTot);
161  emshower->Branch("sliceNhit",&sliceNhit);
162 
163  emshower->Branch("cosTrkNhit",&cosTrkNhit);
164  emshower->Branch("cosTrkMinTime",&cosTrkMinTime);
165  emshower->Branch("cosTrkMeanTime",&cosTrkMeanTime);
166  emshower->Branch("cosTrkStrtX",&cosTrkStrtX);
167  emshower->Branch("cosTrkStrtY",&cosTrkStrtY);
168  emshower->Branch("cosTrkStrtZ",&cosTrkStrtZ);
169  emshower->Branch("cosTrkStopX",&cosTrkStopX);
170  emshower->Branch("cosTrkStopY",&cosTrkStopY);
171  emshower->Branch("cosTrkStopZ",&cosTrkStopZ);
172  emshower->Branch("cosTrkDirX",&cosTrkDirX);
173  emshower->Branch("cosTrkDirY",&cosTrkDirY);
174  emshower->Branch("cosTrkDirZ",&cosTrkDirZ);
175 
176  emshower->Branch("winTrkNhit",&winTrkNhit);
177  emshower->Branch("winTrkMinTime",&winTrkMinTime);
178  emshower->Branch("winTrkMeanTime",&winTrkMeanTime);
179  emshower->Branch("winTrkCalE",&winTrkCalE);
180  emshower->Branch("winTrkADCTot",&winTrkADCTot);
181  emshower->Branch("winTrkMaxPlane",&winTrkMaxPlane);
182  emshower->Branch("winTrkStrtX",&winTrkStrtX);
183  emshower->Branch("winTrkStrtY",&winTrkStrtY);
184  emshower->Branch("winTrkStrtZ",&winTrkStrtZ);
185  emshower->Branch("winTrkStopX",&winTrkStopX);
186  emshower->Branch("winTrkStopY",&winTrkStopY);
187  emshower->Branch("winTrkStopZ",&winTrkStopZ);
188  emshower->Branch("winTrkDirX",&winTrkDirX);
189  emshower->Branch("winTrkDirY",&winTrkDirY);
190  emshower->Branch("winTrkDirZ",&winTrkDirZ);
191 
192  emshower->Branch("prongNhit",&prongNhit);
193  emshower->Branch("prongMinTime",&prongMinTime);
194  emshower->Branch("prongMeanTime",&prongMeanTime);
195  emshower->Branch("prongStrtX",&prongStrtX);
196  emshower->Branch("prongStrtY",&prongStrtY);
197  emshower->Branch("prongStrtZ",&prongStrtZ);
198  emshower->Branch("prongDirX",&prongDirX);
199  emshower->Branch("prongDirY",&prongDirY);
200  emshower->Branch("prongDirZ",&prongDirZ);
201  emshower->Branch("prongHitTime",&prongHitTime);
202  emshower->Branch("chitHitTime",&chitHitTime);
203 
204  emshower->Branch("bpfNhit",&bpfNhit);
205  emshower->Branch("bpfTrkMinTime",&bpfTrkMinTime);
206  emshower->Branch("bpfTrkMeanTime",&bpfTrkMeanTime);
207  emshower->Branch("bpfStrtX",&bpfStrtX);
208  emshower->Branch("bpfStrtY",&bpfStrtY);
209  emshower->Branch("bpfStrtZ",&bpfStrtZ);
210  emshower->Branch("bpfDirX",&bpfDirX);
211  emshower->Branch("bpfDirY",&bpfDirY);
212  emshower->Branch("bpfDirZ",&bpfDirZ);
213  emshower->Branch("bpfTrkHitTime",&bpfTrkHitTime);
214 
215  emshower->Branch("toftime",&toftime,"toftime/D");
216  emshower->Branch("wcmom",&wcmom,"wcmom/D");
217  emshower->Branch("ckovadc",&ckovadc,"ckovadc/D");
218 
219  }
220 
221  //.......................................................................
222 
224  {
225 
226  }
227 
228  //.......................................................................
229 
231  {
232  nhit = -5;
233  toftime = -5;
234  wcmom = -5;
235  ckovadc = -5;
236 
237  // Get "header" info (not all in header, but general info about event)
238  run = evt.run();
239  subrun = evt.subRun();
240  event = evt.event();
241 
242  // Get trigger time
244  evt.getByLabel(fRawDataLabel, trigs);
245  const rawdata::RawTrigger trig = trigs->at(0);
246 
247  struct timespec unixTime;
249 
250  unsigned long int unixTimeSec = unixTime.tv_sec;
251  unsigned long int unixTimeNanoSec = unixTime.tv_nsec;
252  evtTime = unixTimeSec + (1e-9)*unixTimeNanoSec;
253 
254 
255 
257 
258  // Get Beamline info --------------------------------------------------
259  // ToFs
261  std::vector<art::Ptr<brb::ToF>> tofs;
262  if (evt.getByLabel(fRecoToFLabel, tofHandle))
263  art::fill_ptr_vector(tofs, tofHandle);
264 
265  for (auto tof : tofs) {
266  double t = tof->Time();
267  //t -= 21.0;
268  toftime = t;
269  }
270 
271  //WCs
273  std::vector<art::Ptr<brb::WCTrack>> wcs;
274  if (evt.getByLabel(fRecoWCLabel, wcHandle))
275  art::fill_ptr_vector(wcs, wcHandle);
276 
277  for (auto wc : wcs) {
278  wcmom = wc->Momentum();
279  }
280 
281 
282  //Ckov
284  std::vector<art::Ptr<brb::BeamlineDigit>> cherenkovs;
285  if (evt.getByLabel(fRecoCherenkovLabel, cherenkovHandle))
286  art::fill_ptr_vector(cherenkovs, cherenkovHandle);
287 
288  for (auto ckov : cherenkovs) {
289  ckovadc = ckov->PeakADC();
290  }
291 
292 
293  // Get Detector info --------------------------------------------------
294 
295  // Get list of CellHits for event
297  evt.getByLabel("calhit", cellhits);
298  nhit = cellhits->size();
299  // Loop over all CellHits to get location and timing information
300  for (unsigned int hitIdx=0; hitIdx<cellhits->size(); ++hitIdx){
301  art::Ptr<rb::CellHit> ihit(cellhits,hitIdx);
302  hitPlane.push_back(ihit->Plane());
303  hitCell.push_back(ihit->Cell());
304  hitTime.push_back(ihit->TNS());
305  }
306 
307 
308  // Get Slices for event
310  evt.getByLabel(fClusterLabel, sliceHandle);
311 
312  // get associations between slices and other objects
313  art::FindManyP<rb::Vertex> cosVtxAssn(sliceHandle, evt, "cosmicrayvertex");
314  art::FindManyP<rb::Track> cosTrkAssn(sliceHandle, evt, "cosmictrack");
315  art::FindManyP<rb::Track> winTrkAssn(sliceHandle, evt, "windowtrack");
316  art::FindManyP<rb::Prong> fuzzykAssn(sliceHandle, evt, "fuzzykvertex");
317  art::FindManyP<rb::Track> bpfTrkAssn(sliceHandle, evt, "breakpoint");
318 
320  for ( unsigned int i=0; i<sliceHandle->size(); ++i )
321  slices.push_back(art::Ptr<rb::Cluster>(sliceHandle, i));
322 
323 
324  // Loop over slices
325  for ( unsigned int sliceIdx = 0; sliceIdx<slices.size(); ++sliceIdx ){
326  slice.push_back(sliceIdx);
327  art::Ptr<rb::Cluster> islice = slices.at(sliceIdx);
328 
329  //sliceNhit.push_back(islice->NCell());
330  // slice E
331  if (islice->NCell() > 0) {
332  //sliceCalE.push_back(islice->CalorimetricEnergy());
333 
334  // tracks
335  TVector3 cosTrkStrt;
336  TVector3 cosTrkStop;
337  TVector3 winTrkStrt;
338  TVector3 winTrkStop;
339 
340  if ( cosTrkAssn.isValid() ) {
341  std::vector< art::Ptr< rb::Track > > tracks = cosTrkAssn.at(sliceIdx);
342  for (unsigned int trackIdx = 0; trackIdx<tracks.size(); ++trackIdx ){
343  art::Ptr<rb::Track> cosTrk = tracks.at(trackIdx);
344  cosTrkStrt = cosTrk->Start();
345  cosTrkStop = cosTrk->Stop();
346  // force track to start downstream
347  if ( cosTrkStop.Z() < cosTrkStrt.Z() ) {
348  cosTrkStrt = cosTrk->Stop();
349  cosTrkStop = cosTrk->Start();
350  }
351  cosTrkStrtX.push_back(cosTrkStrt.X());
352  cosTrkStrtY.push_back(cosTrkStrt.Y());
353  cosTrkStrtZ.push_back(cosTrkStrt.Z());
354  cosTrkStopX.push_back(cosTrkStop.X());
355  cosTrkStopY.push_back(cosTrkStop.Y());
356  cosTrkStopZ.push_back(cosTrkStop.Z());
357  cosTrkDirX.push_back(cosTrk->Dir().X());
358  cosTrkDirY.push_back(cosTrk->Dir().Y());
359  cosTrkDirZ.push_back(cosTrk->Dir().Z());
360  cosTrkNhit.push_back(cosTrk->NCell());
361  cosTrkMinTime.push_back(cosTrk->MinTNS());
362  cosTrkMeanTime.push_back(cosTrk->MeanTNS());
363  } // loop over cosmic tracks
364  } // valid cosmic track
365 
366 
367  if ( winTrkAssn.isValid() ) {
368  std::vector< art::Ptr< rb::Track > > tracks = winTrkAssn.at(sliceIdx);
369  for (unsigned int trackIdx = 0; trackIdx<tracks.size(); ++trackIdx ){
370  art::Ptr<rb::Track> winTrk = tracks.at(trackIdx);
371  winTrkStrt = winTrk->Start();
372  winTrkStop = winTrk->Stop();
373  // force track to start downstream
374  if ( winTrkStop.Z() < winTrkStrt.Z() ) {
375  winTrkStrt = winTrk->Stop();
376  winTrkStop = winTrk->Start();
377  }
378  winTrkStrtX.push_back(winTrkStrt.X());
379  winTrkStrtY.push_back(winTrkStrt.Y());
380  winTrkStrtZ.push_back(winTrkStrt.Z());
381  winTrkStopX.push_back(winTrkStop.X());
382  winTrkStopY.push_back(winTrkStop.Y());
383  winTrkStopZ.push_back(winTrkStop.Z());
384  winTrkDirX.push_back(winTrk->Dir().X());
385  winTrkDirY.push_back(winTrk->Dir().Y());
386  winTrkDirZ.push_back(winTrk->Dir().Z());
387  winTrkNhit.push_back(winTrk->NCell());
388  winTrkMinTime.push_back(winTrk->MinTNS());
389  winTrkMeanTime.push_back(winTrk->MeanTNS());
390 
391  winTrkCalE.push_back(winTrk->CalorimetricEnergy());
392  winTrkADCTot.push_back(winTrk->TotalADC());
393  winTrkMaxPlane.push_back(winTrk->MaxPlane());
394 
395  sliceNhit.push_back(islice->NCell());
396  sliceCalE.push_back(islice->CalorimetricEnergy());
397  sliceADCTot.push_back(islice->TotalADC());
398  sliceMaxPlane.push_back(islice->MaxPlane());
399  } // loop over window tracks
400  } // valid window track
401 
402 
403 
404  // get prongs
405  std::vector<art::Ptr<rb::Prong>> prongs3D;
406  art::FindManyP<rb::Prong> fmProng3D(sliceHandle, evt,
408  if ( !fmProng3D.isValid() ) continue;
409  else prongs3D = fmProng3D.at(sliceIdx);
410  if (prongs3D.size() == 0 ) continue;
411 
412  art::FindManyP<rb::Track> fmTrackBPF(prongs3D, evt, "breakpoint");
413 
414  // vertices
415  std::vector<art::Ptr<rb::Vertex>> cosVtx;
416  if (cosVtxAssn.isValid())
417  cosVtx = cosVtxAssn.at(sliceIdx);
418  if (cosVtx.size() == 1){
419  cosVtxX.push_back(cosVtx.at(0)->GetX());
420  cosVtxY.push_back(cosVtx.at(0)->GetY());
421  cosVtxZ.push_back(cosVtx.at(0)->GetZ());
422  }
423 
424 
425  // prongs
426  for (unsigned int prongIdx=0; prongIdx<prongs3D.size(); ++prongIdx){
427  art::Ptr<rb::Prong> iprong = prongs3D.at(prongIdx);
428  int nhitprong = iprong->NCell();
429  prongNhit.push_back(nhitprong);
430 
431  prongStrtX.push_back(iprong->Start().X());
432  prongStrtY.push_back(iprong->Start().Y());
433  prongStrtZ.push_back(iprong->Start().Z());
434  prongDirX.push_back(iprong->Dir().X());
435  prongDirY.push_back(iprong->Dir().Y());
436  prongDirZ.push_back(iprong->Dir().Z());
437  prongMinTime.push_back(iprong->MinTNS());
438  prongMeanTime.push_back(iprong->MeanTNS());
439 
440  for (unsigned int hitIdx = 0; hitIdx<iprong->NCell(); ++hitIdx){
441  const art::Ptr<rb::CellHit> chit = iprong->Cell(hitIdx);
442  const rb::RecoHit rhit = iprong->RecoHit(chit);
443  double hitTime = chit->TNS();
444  // Events pre-July 3 11:42 CDT (pre run 100192) were 1ms, not 100μs.
445  // Need to adjust time for timing cuts to work.
446  if (run<100192)
447  hitTime -= 450e3;
448 
449  chitHitTime.push_back(hitTime);
450  if (hitIdx==0)
451  prongHitTime.push_back(hitTime);
452 
453  } // end loop over hits
454 
455  prongE.push_back(iprong->TotalGeV());
456  prongCalE.push_back(iprong->CalorimetricEnergy());
457  prongADCTot.push_back(iprong->TotalADC());
458 
459 
460  // Get bpf tracks
461  std::vector<art::Ptr<rb::Track>> bpftracks;
462  if(fmTrackBPF.isValid()) bpftracks = fmTrackBPF.at(prongIdx);
463 
464  art::FindManyP<rb::FitSum> fmFitsum(bpftracks, evt, "breakpoint");
465 
466  for (unsigned int trackIdx = 0; trackIdx < bpftracks.size(); ++trackIdx){
467 
468  std::vector<art::Ptr<rb::FitSum>> fitsums;
469  if(fmFitsum.isValid()) fitsums = fmFitsum.at(trackIdx);
470  if(fitsums.size()==0) continue;
471 
472  // Only look at muon assumption - this should be expanded
473  if(fitsums[0]->PDG() == 13) {
474  art::Ptr<rb::Track> bpfTrk = bpftracks[trackIdx];
475  int nhitbpf = bpfTrk->NCell();
476  bpfNhit.push_back(nhitbpf);
477  bpfTrkMinTime.push_back(bpfTrk->MinTNS());
478  bpfTrkMeanTime.push_back(bpfTrk->MeanTNS());
479 
480  bpfStrtX.push_back(bpfTrk->Start().X());
481  bpfStrtY.push_back(bpfTrk->Start().Y());
482  bpfStrtZ.push_back(bpfTrk->Start().Z());
483  bpfDirX.push_back(bpfTrk->Dir().X());
484  bpfDirY.push_back(bpfTrk->Dir().Y());
485  bpfDirZ.push_back(bpfTrk->Dir().Z());
486 
487 
488  const art::Ptr<rb::CellHit> bpfhit = bpfTrk->Cell(0);
489  double trkTime = bpfhit->TNS();
490  // Events pre-July 3 11:42 CDT (pre run 100192) were 1ms, not 100μs.
491  // Need to adjust time for timing cuts to work.
492  if (run<100192)
493  trkTime -= 450e3;
494  bpfTrkHitTime.push_back(trkTime);
495  }
496  } // loop over bpf tracks
497 
498  }//loop over prongs
499 
500  } // end non-noise slice
501 
502  } // end loop over slices
503 
504 
505  emshower->Fill();
506 
507  // Cleanup vectors
508  hitPlane.clear();
509  hitCell.clear();
510  hitTime.clear();
511 
512  slice.clear();
513  cosVtxX.clear();
514  cosVtxY.clear();
515  cosVtxZ.clear();
516 
517  sliceNhit.clear();
518  sliceCalE.clear();
519  sliceADCTot.clear();
520  sliceMaxPlane.clear();
521  cosTrkNhit.clear();
522  cosTrkMinTime.clear();
523  cosTrkMeanTime.clear();
524  cosTrkStrtX.clear();
525  cosTrkStrtY.clear();
526  cosTrkStrtZ.clear();
527  cosTrkStopX.clear();
528  cosTrkStopY.clear();
529  cosTrkStopZ.clear();
530  cosTrkDirX.clear();
531  cosTrkDirY.clear();
532  cosTrkDirZ.clear();
533  winTrkNhit.clear();
534  winTrkMinTime.clear();
535  winTrkMeanTime.clear();
536  winTrkCalE.clear();
537  winTrkADCTot.clear();
538  winTrkMaxPlane.clear();
539  winTrkStrtX.clear();
540  winTrkStrtY.clear();
541  winTrkStrtZ.clear();
542  winTrkStopX.clear();
543  winTrkStopY.clear();
544  winTrkStopZ.clear();
545  winTrkDirX.clear();
546  winTrkDirY.clear();
547  winTrkDirZ.clear();
548 
549  prongNhit.clear();
550  prongMinTime.clear();
551  prongMeanTime.clear();
552  prongE.clear();
553  prongCalE.clear();
554  prongADCTot.clear();
555  prongStrtX.clear();
556  prongStrtY.clear();
557  prongStrtZ.clear();
558  prongDirX.clear();
559  prongDirY.clear();
560  prongDirZ.clear();
561  prongHitTime.clear();
562  chitHitTime.clear();
563 
564  bpfNhit.clear();
565  bpfTrkMinTime.clear();
566  bpfTrkMeanTime.clear();
567  bpfStrtX.clear();
568  bpfStrtY.clear();
569  bpfStrtZ.clear();
570  bpfDirX.clear();
571  bpfDirY.clear();
572  bpfDirZ.clear();
573  bpfTrkHitTime.clear();
574 
575  } // end analyze
576 
577  //.......................................................................
579 } // end namespace tbem
580 ///////////////////////////////////////////////////////////////////
std::vector< double > winTrkADCTot
std::vector< double > bpfDirZ
float TNS() const
Definition: CellHit.h:46
std::string fRecoToFLabel
SubRunNumber_t subRun() const
Definition: Event.h:72
back track the reconstruction to the simulation
unsigned int NCell(geo::View_t view) const
Number of cells in view view.
Definition: Cluster.cxx:134
std::vector< double > cosTrkStopX
std::vector< double > prongStrtZ
std::string fRawDataLabel
unsigned short Plane() const
Definition: CellHit.h:39
std::vector< double > winTrkStopX
std::vector< double > bpfTrkMeanTime
std::string fRecoCherenkovLabel
std::vector< double > cosTrkStopY
std::vector< double > prongMeanTime
void analyze(const art::Event &evt)
std::vector< double > winTrkStopZ
std::vector< double > bpfTrkMinTime
std::vector< double > hitTime
DEFINE_ART_MODULE(TestTMapFile)
virtual TVector3 Start() const
Definition: Prong.h:73
bool convertNovaTimeToUnixTime(uint64_t const &inputNovaTime, struct timespec &outputUnixTime)
std::vector< double > bpfDirY
std::vector< double > cosTrkStrtY
std::vector< double > prongDirX
std::vector< double > prongE
std::vector< double > cosTrkStopZ
std::vector< double > cosTrkDirY
std::vector< double > winTrkMinTime
Calibrated quantities relying on position in the orthogonal view. To generate a rb::CellHit from a rb...
Definition: RecoHit.h:19
std::vector< int > winTrkNhit
std::vector< int > cosTrkNhit
unsigned short Cell() const
Definition: CellHit.h:40
std::vector< double > prongHitTime
double MinTNS() const
Definition: Cluster.cxx:482
double TotalADC() const
Sum of the ADC of all the contained hits.
Definition: Cluster.cxx:360
std::vector< double > bpfStrtY
std::vector< double > winTrkStopY
double CalorimetricEnergy(EEnergyCalcScheme escheme=kRecomputeEnergy) const
Simple estimate of neutrino energy.
Definition: Cluster.cxx:439
std::vector< double > winTrkDirX
std::vector< double > winTrkStrtX
Encapsulation of reconstructed digitizer &#39;hits&#39;. Used for ToF PMTs and SiPMs, and Cherenkov and Muon ...
std::vector< double > winTrkMaxPlane
void push_back(Ptr< U > const &p)
Definition: PtrVector.h:441
std::vector< int > hitCell
std::vector< double > cosTrkMinTime
T get(std::string const &key) const
Definition: ParameterSet.h:231
Encapsulation of reconstructed Time-of-Flight (ToF) information. Part of beamline reconstruction for ...
virtual TVector3 Dir() const
Unit vector describing prong direction.
Definition: Prong.h:77
rb::RecoHit RecoHit(const art::Ptr< rb::CellHit > &chit) const
Return calibrated hit based on assumed W coordinate.
Definition: Cluster.cxx:259
std::vector< double > cosVtxZ
std::vector< double > sliceMaxPlane
std::vector< double > prongStrtY
Encapsulation of reconstructed Wire Chamber track. Part of beamline reconstruction for NOvA test beam...
std::vector< double > winTrkDirY
std::vector< double > winTrkStrtY
EventNumber_t event() const
Definition: Event.h:67
reference at(size_type n)
Definition: PtrVector.h:365
EDAnalyzer(Table< Config > const &config)
Definition: EDAnalyzer.h:100
std::vector< int > sliceNhit
Vertex location in position and time.
std::vector< double > bpfDirX
std::vector< double > sliceCalE
std::string fProngModLabel
std::vector< int > prongNhit
Definition: run.py:1
size_type size() const
Definition: PtrVector.h:308
std::vector< double > prongDirZ
std::string fVertexLabel
art::Ptr< rb::CellHit > Cell(geo::View_t view, unsigned int viewIdx) const
Get the ith cell from view view.
Definition: Cluster.cxx:145
::xsd::cxx::tree::string< char, simple_type > string
Definition: Database.h:154
std::string fClusterLabel
T * make(ARGS...args) const
std::vector< double > cosVtxY
std::vector< double > winTrkStrtZ
TBRecoAna(fhicl::ParameterSet const &pset)
std::vector< double > winTrkCalE
std::vector< double > winTrkDirZ
bool getByLabel(std::string const &label, std::string const &productInstanceName, Handle< PROD > &result) const
Definition: DataViewImpl.h:344
unsigned long long fTriggerTimingMarker_TimeStart
Definition: RawTrigger.h:38
std::vector< int > hitPlane
std::string fProng3DLabel
std::vector< double > cosTrkMeanTime
std::vector< double > winTrkMeanTime
double MeanTNS(rb::AveragingScheme scheme=kDefaultScheme) const
Definition: Cluster.cxx:554
std::vector< double > cosTrkStrtX
std::vector< int > bpfNhit
double TotalGeV(EEnergyCalcScheme escheme=kRecomputeEnergy) const
Simple sum of the estimated GeV of all the hits.
Definition: Cluster.cxx:378
std::vector< double > cosVtxX
std::vector< double > prongCalE
unsigned int MaxPlane(geo::View_t view=geo::kXorY) const
Definition: Cluster.cxx:508
std::vector< double > bpfStrtZ
std::string fProng2DLabel
std::string fRecoWCLabel
std::vector< double > prongStrtX
TVector3 Stop() const
Position of the final trajectory point.
Definition: Track.cxx:186
void fill_ptr_vector(std::vector< Ptr< T >> &ptrs, H const &h)
Definition: Ptr.h:464
std::vector< double > cosTrkDirZ
Float_t e
Definition: plot.C:35
std::vector< int > slice
RunNumber_t run() const
Definition: Event.h:77
std::vector< double > prongDirY
std::vector< double > sliceADCTot
void reconfigure(const fhicl::ParameterSet &pset)
std::vector< double > bpfStrtX
std::vector< double > cosTrkDirX
std::vector< double > bpfTrkHitTime
std::vector< double > prongMinTime
std::vector< double > cosTrkStrtZ
std::vector< double > chitHitTime
std::vector< double > prongADCTot