EvaluatorNumu.cxx
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////
2 // Class: EvaluatorNumu
3 // File: EvaluatorNumu.cxx
4 ////////////////////////////////////////////////////////////////////////
5 #include <algorithm>
6 
10 
16 
19 
20 //------------------------------------------------------------------------------
22 {
23  return s1->ShowerEnergy() > s2->ShowerEnergy();
24 }
25 
26 //------------------------------------------------------------------------------
28 {
29  return p1->TotalLength() > p2->TotalLength();
30 }
31 
32 //------------------------------------------------------------------------------
33 
34 
35 
36 //------------------------------------------------------------------------------
38 {
39  this->reconfigure(p);
40 
41  // Selection Type added to Histogram Names to avoid memory leaks since root desn't like two named objects with the same name.
42  auto selPSet = p.get<fhicl::ParameterSet>("Selection");
43  std::string selType = selPSet.get<std::string>("SelectionType", "NumuSA");
44 
45  // make histograms for each selection criteria
47 
48  fNeutrinoE = tfs->make<TH1F>((selType+"_neutrinoE").c_str(), ";E_{#nu} (GeV);Events", 100, 0., 10. );
49  fReMIdVal = tfs->make<TH1F>((selType+"_remid").c_str(), ";ReMId;Events", 200, -1., 1. );
50  fSliceHits = tfs->make<TH1F>((selType+"_sliceHits").c_str(), ";Hits In Slice;Events", 100, 0., 400. );
51  fSliceContigPlanes = tfs->make<TH1F>((selType+"_sliceContigPlanes").c_str(), ";Contiguous Planes in Slice;Events", 50, 0., 50. );
52  fCellsFromEdge = tfs->make<TH1F>((selType+"_cellsFromEdge").c_str(), ";Cells From Edge;Events", 50, 0., 50. );
53  fQePId1Track = tfs->make<TH1F>((selType+"_qepid1Track").c_str(), ";QePId_{1 track};Events", 200, -1., 1. );
54  fQePId2Track = tfs->make<TH1F>((selType+"_qepid2Track").c_str(), ";QePId_{2 tracks};Events", 200, -1., 1. );
55  fFDKalmanFwdCell = tfs->make<TH1F>((selType+"_fdKalmanFwdCell").c_str(), ";Kalman Foward Cell;Events", 100, 0., 100. );
56  fFDKalmanBakCell = tfs->make<TH1F>((selType+"_fdKalmanBakCell").c_str(), ";Kalman Backward Cell;Events", 100, 0., 100. );
57  fFDCosFwdCell = tfs->make<TH1F>((selType+"_fdCosFwdCell").c_str(), ";cos Foward Cell;Events", 100, 0., 100. );
58  fFDCosBakCell = tfs->make<TH1F>((selType+"_fdCosBakCell").c_str(), ";cos Backward Cell;Events", 100, 0., 100. );
59  fFDPlanesToFront = tfs->make<TH1F>((selType+"_fdPlanesToFront").c_str(), ";Planes to Front;Events", 100, 0., 100. );
60  fFDPlanesToBack = tfs->make<TH1F>((selType+"_fdPlanesToBack").c_str(), ";Planes to Back;Events", 100, 0., 100. );
61  fFDKalmanAngle = tfs->make<TH1F>((selType+"_fdKalmanAngle").c_str(), ";Kalman Angle;Events", 200, -4., 4. );
62  fFDContPID = tfs->make<TH1F>((selType+"_fdContPID").c_str(), ";ContPID;Events", 200, -1., 1. );
63  fFDSliceHits = tfs->make<TH1F>((selType+"_fdSliceHits").c_str(), ";Slice Hits;Events", 500, 0., 500. );
64  fNDMaxPlaneHit = tfs->make<TH1F>((selType+"_ndMaxPlaneHit").c_str(), ";Max Hit Plane;Events", 220, 0., 220. );
65  fNDMinPlaneHit = tfs->make<TH1F>((selType+"_ndMinPlaneHit").c_str(), ";Min Hit Plane;Events", 220, 0., 220. );
66  fNDTrackStartZ = tfs->make<TH1F>((selType+"_ndTrackStartZ").c_str(), ";Track Starting Z Pos (cm);Events", 200, 0., 2000.);
67  fNDTrackStopZ = tfs->make<TH1F>((selType+"_ndTrackStopZ").c_str(), ";Track Ending Z Pos (cm);Events", 200, 0., 2000.);
68  fNDKalmanFwdCell = tfs->make<TH1F>((selType+"_ndKalmanFwdCell").c_str(), ";Kalman Foward Cell;Events", 100, 0., 100. );
69  fNDKalmanBakCell = tfs->make<TH1F>((selType+"_ndKalmanBakCell").c_str(), ";Kalman Backward Cell;Events", 100, 0., 100. );
70  fNDHadCalEnergySum = tfs->make<TH1F>((selType+"_ndHadCalEnergySum").c_str(), ";Hadronic Energy (GeV);Events", 100, 0., 10. );
71 
72  return;
73 }
74 
75 //------------------------------------------------------------------------------
77 {
78  fSliceLabel = p.get<std::string>("SliceLabel", "slicer" );
79  fTrackLabel = p.get<std::string>("TrackLabel", "kalmantrackmerge" );
80  fCosRejLabel = p.get<std::string>("CosRejLabel", "cosrej" );
81  fVertexLabel = p.get<std::string>("VertexLabel", "elasticarmshs" ); // Added for 2017 Analysis
82  fShowerLabel = p.get<std::string>("ShowerLabel", "recluster" ); // Added for 2017 Analysis
83  fLIDLabel = p.get<std::string>("LIDLabel", "slid" ); // Added for 2017 Analysis
84  fNueCosRejLabel= p.get<std::string>("NueCosRejLabel", "nuecosrej" ); // Added for 2017 Analysis
85  fQePIdLabel = p.get<std::string>("QePIdLabel", "qepid" );
86  fReMIdLabel = p.get<std::string>("ReMIdLabel", "remid" );
87  fCVNLabel = p.get<std::string>("CVNLabel", "cvnevalprod3train"); /// 2017, new label for 2018
88  fCVN2017Label = p.get<std::string>("CVN2017Label", "cvneval" ); /// 2018
89  fNumuELabel = p.get<std::string>("NumuELabel", "numue" );
90  fEnergyLabel = p.get<std::string>("EnergyLabel", "numue" );
91  fCosmicsLabel = p.get<std::string>("CosmicsLabel", "cosmictrack" );
92  fRecordLabel = p.get<std::string>("RecordLabel", "cafmaker" );
93 
94  auto prongTag = p.get<std::string>("ProngTag", "fuzzykvertex:Prong3D"); // Added for 2017 Analysis
95  auto pos = prongTag.find(":");
96  fProngTag = art::InputTag(prongTag.substr(0, pos),
97  prongTag.substr(pos+1, prongTag.size()));
98 
99  auto selPSet = p.get<fhicl::ParameterSet>("Selection");
100  auto selType = selPSet.get<std::string>("SelectionType", "NumuSA");
101 
102  if(selType.compare("NumuSA") == 0) fSel = std::make_unique<skim::SelectionNumuSA >();
103  else if(selType.compare("Numu2017") == 0) fSel = std::make_unique<skim::SelectionNumu2017>();
104  else if(selType.compare("Numu2018") == 0) fSel = std::make_unique<skim::SelectionNumu2018>();
105  else
106  throw cet::exception("EvaluatorNumu")
107  << "Requested unknown selection type: "
108  << selType;
109 
110  fSel->reconfigure(selPSet);
111 
112  return;
113 }
114 
115 //------------------------------------------------------------------------------
117  art::Event const& e)
118 {
119  fSlicePtrs .clear();
120  fKeptSlices .clear();
121  fTrack .clear();
122  fNumuE .clear();
123  fEnergy .clear();
124  fReMId .clear();
125  fCosRej .clear();
126  fQePId .clear();
127 
128  fCosmicTrack .clear(); ///
129 
130  fNueCosRej .clear(); /// (2017)
131  fTracks .clear(); /// (2017)
132  fShowers .clear(); /// (2017)
133  fProngs .clear(); /// (2017)
134  fSLIDs .clear(); /// (2017)
135  fVertices .clear(); /// (2017)
136  fCVNs .clear(); /// (2017)
137  fCVN2017s .clear(); /// (2018)
138 
139  fSliceBestTrkPID.clear();
140 
141  fIsData = e.isRealData();
142  fDetId = detId;
143  fCurrentRun = e.run();
144 
145  // fill the vectors of vector<art::Ptr<>> for the reco objects related
146  // to each slice in the spill
147  // get the slices out of the event
149  e.getByLabel(fSliceLabel, slices);
150 
151  if( slices.failedToGet() ){
152  LOG_WARNING("EvaluatorNumu") << "No slices in this event";
153  return false;
154  }
155 
157  e.getByLabel(fCosmicsLabel, cosmics);
158 
159  if( cosmics.failedToGet() ){
160  LOG_WARNING("EvaluatorNumu") << "No cosmics in this event";
161  return false;
162  }
163 
164  // get the FindMany for the slices to shower association.
166  art::FindManyP<rb::Track> fmtp (slices, e, fTrackLabel );
168  art::FindMany<qeef::QePId> fmqe (slices, e, fQePIdLabel );
169  art::FindMany<numue::NumuE> fme (slices, e, fNumuELabel );
170  art::FindMany<cosrej::NueCosRej> fmnuecr(slices, e, fNueCosRejLabel); /// 2017
171  art::FindMany<rb::Track> fmtks (slices, e, fTrackLabel ); /// 2017
172  art::FindMany<slid::ShowerLID> fmslid (slices, e, fLIDLabel ); /// 2017
173  art::FindMany<rb::Vertex> fmv (slices, e, fVertexLabel ); /// 2017
174  art::FindMany<rb::Prong> fmp (slices, e, fProngTag ); /// 2017
175  art::FindMany<cvn::Result> fmcvn (slices, e, fCVNLabel ); /// 2017
176  art::FindMany<cvn::Result> fmocvn (slices, e, fCVN2017Label ); /// 2018 using old cvn
177  art::FindMany<rb::Track> fmct (slices, e, fCosmicsLabel );
178 
180 
181  for(size_t s = 0; s < slices->size(); ++s){
182 
183  fSlicePtrs.emplace_back(slices, s);
184 
185  su.FillSliceMap(s, fmt, fTrack );
186  su.FillSliceMap(s, fmcr, fCosRej );
187  su.FillSliceMap(s, fmqe, fQePId );
188  su.FillSliceMap(s, fme, fNumuE );
189  su.FillSliceMap(s, fmnuecr, fNueCosRej); /// 2017
190  su.FillSliceMap(s, fmtks, fTracks ); /// 2017
191  su.FillSliceMap(s, fmv, fVertices ); /// 2017
192  su.FillSliceMap(s, fmp, fProngs ); /// 2017
193  su.FillSliceMap(s, fmslid, fSLIDs ); /// 2017
194  su.FillSliceMap(s, fmcvn, fCVNs ); /// 2017
195  su.FillSliceMap(s, fmocvn, fCVN2017s ); /// 2018
196 
197  su.FillSliceMap(s, fmct, fCosmicTrack ); ///
198 
199  // sort the showerLIDs vector in order of decreasing energy
200  // sorting now ensures that the showers and slids are in the
201  // proper order for later use
202  std::sort(fSLIDs[s].begin(), fSLIDs[s].end(), showerByEnergyNumu);
203 
204  // now get the shower associated with each ShowerLID
206 
207  // sort the prongs by decreasing length
208  std::sort(fProngs[s].begin(), fProngs[s].end(), prongByLengthNumu);
209 
210 
211  // get the vector of art::Ptrs of tracks for this slice to be able to find
212  // the highest pid track. I am assuming that FindMany and FindManyP
213  std::vector< art::Ptr<rb::Track> > tracks;
214  fmtp.get(s, tracks);
215 
216  // map the tracks to the rb::Energy for the slice - just fill the fEnergyPtrs
217  // value (ie vector< art::Ptr<rb::Energy> > ) in the same order as the fTrackPtrs
218  // value for this slice
219  if(fTrack[s].size() > 0){
220 
221  // save the index of the highest PID track for this slice
223 
224  // this is not terribly efficient, as we are making the FindOneP
225  // for every slice in the event, but I don't see a good way around
226  // that while still getting the bookkeeping right
229 
230  if( !foe.isValid() || !foid.isValid() ) continue;
231 
232  for(size_t t = 0; t < fTrack[s].size(); ++t){
233  fEnergy[s].push_back( &(foe.at(t).ref()) );
234  fReMId[s] .push_back( &(foid.at(t).ref()) );
235  }
236 
237  }// end if we found tracks in the spill
238 
239  } // end the loop over the slices
240 
241 
242  return true;
243 }
244 
245 //------------------------------------------------------------------------------
247 {
248  // fKeptSlicePtrs was cleared in the initialize call
249  // only non-noise slices were put into fSlicePtrs in the initialize call
250  for(size_t s = 0; s < fSlicePtrs.size(); ++s){
251  LOG_DEBUG("EvaluatorNumu")
252  << "on slice " << s;
253  if(this->KeepSlice(s) &&
254  this->CheckTiming( *(fSlicePtrs[s]) ) &&
255  this->CheckSliceQuality( *(fSlicePtrs[s]) )
256  ){
257  LOG_DEBUG("EvaluatorNumu")
258  << "keeping slice " << s;
259 
260  fKeptSlices.emplace_back(fSlicePtrs[s], s);
261  }
262  }
263 
264  return fKeptSlices.size();
265 }
266 
267 //------------------------------------------------------------------------------
269 {
270  LOG_DEBUG("EvaluatorNumu::KeepSlice")
271  << "Inside EvaluatorNumu::KeepSlice";
272  // we don't check for the existance of cosmic rays reconstructed in
273  // this slice because that is for the full event and is tested in
274  // the Initialize method
275 
276  // if there are no tracks in the slice, or it is a noise slice
277  // we don't want it
278  if(fSlicePtrs[s]->IsNoise() ){
279  LOG_DEBUG("EvaluatorNumu::KeepSlice")
280  << "Slice is a Noise";
281  return false;
282  }
283  // need the CosRejObj for this slice
284  // need NueCosRej for this slice (Analysis 2017)
285  // just one NumuE per slice
286  if(fCosRej.count(s) < 1 ||
287  fNumuE.count(s) < 1 ||
288  fNueCosRej.count(s) < 1 ||
289  fShowers.count(s) < 1 ||
290  fProngs.count(s) < 1 ||
291  fSLIDs.count(s) < 1 ||
292  fCosmicTrack.count(s) < 1 || // <<<<<<<<<<<<< Check
293  fVertices.count(s) != 1 ||
294  fTracks.count(s) != 1 ||
295  fCVNs.count(s) != 1 ||
296  fCVN2017s.count(s) != 1
297  ){
298  LOG_DEBUG("EvaluatorNumu")
299  << " # CosRej: " << fCosRej.count(s)
300  << " # NueCosRej: " << fNueCosRej.count(s)
301  << " # NumuE: " << fNumuE.count(s)
302  << " # fShowers: " << fShowers.count(s)
303  << " # fProngs: " << fProngs.count(s)
304  << " # fSLIDs: " << fSLIDs.count(s)
305  << " # fCosmicTracks: " << fCosmicTrack.count(s)
306  << " # fVertices: " << fVertices.count(s)
307  << " # fTracks: " << fTracks.count(s)
308  << " # fCVNs: " << fCVNs.count(s)
309  << " # fCVN2017s: " << fCVN2017s.count(s);
310  return false;
311  }
312 
313  // if the best track pid is not within the bounds of the vectors, then return false
314  // for now, 999 is the default value returned by ReMId::HighestTrackPID if no track
315  // passes the criteria
316  if(fSliceBestTrkPID[s] > fReMId[s] .size() || fReMId[s] .size() < 1 ||
317  fSliceBestTrkPID[s] > fEnergy[s].size() || fEnergy[s].size() < 1 ||
318  fSliceBestTrkPID[s] > fTrack[s] .size() || fTrack[s] .size() < 1 ||
319  fSliceBestTrkPID[s] == 999){
320  LOG_DEBUG("EvaluatorNumu")
321  << "best track PID out of bounds " << fSliceBestTrkPID[s]
322  << " ReMId size: " << fReMId[s].size()
323  << " Energy size: " << fEnergy[s].size()
324  << " Track size: " << fTrack[s].size();
325 
326  return false;
327  }
328 
329  qeef::QePId qepid;
330  if( fQePId.count(s) > 0 ) qepid = *(fQePId[s].front());
331 
332  // 2017
333  std::vector<cosrej::NueCosRej const*> nuecosrejs;
334  if( fNueCosRej.count(s) > 0 ) nuecosrejs = fNueCosRej.find(s)->second;
335 
336  // 2017
337  std::vector<cvn::Result const*> cvns;
338  if( fCVNs.count(s) > 0) cvns = fCVNs.find(s)->second;
339 
340  // 2018
341  std::vector<cvn::Result const*> oldcvns;
342  if( fCVN2017s.count(s) > 0) oldcvns = fCVN2017s.find(s)->second;
343 
344  // get the vectors of showers and vertices for this slice
345  std::vector<rb::Shower const*> showers;
346  if( fShowers.count(s) > 0 ) showers = fShowers.find(s)->second;
347 
348  std::vector<slid::ShowerLID const*> slids;
349  if( fSLIDs.count(s) > 0) slids = fSLIDs.find(s)->second;
350 
351  std::vector<rb::Vertex const*> vertices;
352  if( fVertices.count(s) > 0 ) vertices = fVertices.find(s)->second;
353 
354  std::vector<rb::Prong const*> prongs;
355  if( fProngs.count(s) > 0 ) prongs = fProngs.find(s)->second;
356 
357  std::vector<rb::Track const*> tracks;
358  if( fTracks.count(s) > 0 ) tracks = fTracks.find(s)->second;
359 
360  std::vector<rb::Track const*> cosmictracks;
361  if( fCosmicTrack.count(s) > 0 ) cosmictracks = fCosmicTrack.find(s)->second;
362 
363 
364  // don't bother if there aren't any showers or vertices
365  // there should only be one vertex per slice according to the
366  // module creating the rb::Vertex objects and only one cosrej::NueCosRej
367  // per slice.
368  if(
369  // showers.size() < 1 ||
370  // prongs.size() < 1 ||
371  // slids.size() < 1 ||
372  cosmictracks.size() < 1 || ////// <<<<< Check!!!!!
373  tracks.size() < 1 ||
374  vertices.size() != 1 ||
375  // nuecosrejs.size() != 1 ||
376  cvns.size() != 1 ||
377  oldcvns.size() != 1
378  ){
379  LOG_DEBUG("EvaluatorNumu")
380  << "not enough "
381  // << "showers (" << showers .size()
382  // << ") or prongs(" << prongs .size()
383  // << ") or slids(" << slids .size()
384  // << ") or nuecosrejs(" << nuecosrejs.size()
385  << " tracks(" << tracks .size()
386  << ") or cosmictracks(" << cosmictracks.size()
387  << ") or vertices(" << vertices .size()
388  << ") or cvns(" << cvns .size()
389  << ") or 2017cvns(" << oldcvns .size()
390  << ")";
391  return false;
392  }
393 
394 
395  // check that all the necessary ptrs are legit
396  // return false if they are not
397  if(cvns[0] == nullptr ||
398  oldcvns[0] == nullptr ||
399  //nuecosrejs[0] == nullptr ||
400  //showers[0] == nullptr ||
401  //slids[0] == nullptr ||
402  vertices[0] == nullptr ||
403  tracks[0] == nullptr
404  ){
405  LOG_DEBUG("EvaluatorNumu")
406  << "Necessary ptrs are NOT legit";
407  return false;
408  }
409 
410  cosrej::NueCosRej const* nuecosrej;
411  // Only check the size of the Nue Cosmic rejection object for the
412  // FD events
414  if(nuecosrejs.size() == 1 ) nuecosrej = nuecosrejs[0]; // FD will always have one may not have a
415  //nuecosrej objects but it does not use its values
416  else{
417  LOG_DEBUG("EvaluatorNumu")
418  << "Zero Nue Cosmic rejections. nuecosrejs.size() "
419  << nuecosrejs.size();
420  return false;
421  }
422  } else {//End of FD condition
423  //create object if missing for ND. The information is not used for the ND but the content even if dummy needs to be accessible.
424  nuecosrej = new cosrej::NueCosRej();
425  }
426  auto params = std::make_unique<skim::ParametersNumu>(fSliceBestTrkPID[s],
427  *(fEnergy[s][fSliceBestTrkPID[s]]),
428  *(fReMId [s][fSliceBestTrkPID[s]]),
429  *(fCosRej[s].front()),
430  // *(fNueCosRej[s].front()), // 2017 ?????
431  *(nuecosrej), // 2017
432  *(fVertices[s].front()), // 2017
433  tracks, // 2017
434  showers, // 2017
435  prongs, // 2017
436  slids, // 2017
437  qepid,
438  *(fNumuE[s].front()),
439  *(fSlicePtrs[s]),
440  *fTrack [s][fSliceBestTrkPID[s]],
441  *(cvns[0]), // 2017
442  *(oldcvns[0]), // 2018
443  fIsData);
444 
445  LOG_DEBUG("EvaluatorNumu") << *params;
446 
447  // Fill sanity check histograms
448  this->FillHistograms(*params);
449 
450  return fSel->PassesSelection(params.get(), fDetId);
451 
452 }
453 
454 //------------------------------------------------------------------------------
456 {
457  fNeutrinoE ->Fill(params.NeutrinoE());
458  fReMIdVal ->Fill(params.ReMIdValue());
459  fSliceHits ->Fill(params.SliceHits());
460  fSliceContigPlanes->Fill(params.SliceContigPlanes());
461  fCellsFromEdge ->Fill(params.SliceCellsFromEdge());
462  if(params.QePIDNTracks() == 1) fQePId1Track->Fill(params.QePIDValue());
463  if(params.QePIDNTracks() == 2) fQePId2Track->Fill(params.QePIDValue());
464 
466  fFDKalmanFwdCell->Fill(params.CosRejKalFwdCell());
467  fFDKalmanBakCell->Fill(params.CosRejKalBakCell());
468  fFDKalmanAngle ->Fill(params.CosRejAngleKal());
469  fFDCosBakCell ->Fill(params.CosRejCosBakCell());
470  fFDCosFwdCell ->Fill(params.CosRejCosFwdCell());
471  fFDContPID ->Fill(params.CosRejConCosPID());
472  fFDPlanesToBack ->Fill(params.PlanesToBack());
473  fFDPlanesToFront->Fill(params.PlanesToFront());
474  fFDSliceHits ->Fill(params.SliceHits());
475  }
476  else if(fDetId == novadaq::cnv::kNEARDET){
477  fNDMaxPlaneHit ->Fill(params.SliceMaxPlane());
478  fNDMinPlaneHit ->Fill(params.SliceMinPlane());
479  fNDTrackStartZ ->Fill(params.TrackStartZ());
480  fNDTrackStopZ ->Fill(params.TrackStopZ());
481  fNDKalmanBakCell ->Fill(params.CosRejKalBakCellND());
482  fNDKalmanFwdCell ->Fill(params.CosRejKalFwdCellND());
483  fNDHadCalEnergySum->Fill(params.NDHadronicCal());
484  }
485 
486  return;
487 }
std::vector< art::Ptr< rb::Cluster > > fSlicePtrs
all slices in the spill
Definition: Evaluator.h:92
#define LOG_DEBUG(stream)
Definition: Messenger.h:149
std::map< size_t, std::vector< slid::ShowerLID const * > > fSLIDs
slice index to slid ptrs (2017)
std::map< size_t, std::vector< remid::ReMId const * > > fReMId
slice index to remid ptrs
Definition: EvaluatorNumu.h:88
novadaq::cnv::DetId fDetId
the id of the detector we are looking at
Definition: Evaluator.h:84
float const & SliceCellsFromEdge() const
bool Initialize(novadaq::cnv::DetId const &detId, art::Event const &e)
float const & SliceHits() const
float const & CosRejCosFwdCell() const
float const & PlanesToBack() const
std::string fLIDLabel
label of module creating shower lid (2017)
std::string fReMIdLabel
label of module creating remids
std::map< size_t, std::vector< rb::Vertex const * > > fVertices
slice index to vertex ptrs (2017)
Definition: EvaluatorNumu.h:99
void FillSliceMap(size_t const &s, art::FindMany< T > &fmp, std::map< size_t, std::vector< T const * > > &ptrMap)
std::string fQePIdLabel
label of module creating qepids
std::map< size_t, std::vector< cosrej::CosRejObj const * > > fCosRej
slice index to remid ptrs
Definition: EvaluatorNumu.h:89
const char * p
Definition: xmltok.h:285
std::map< size_t, std::vector< cvn::Result const * > > fCVN2017s
slice index to cvn ptrs (2018)
std::string fCosRejLabel
label of module creating cosrejs
std::string fTrackLabel
label of module creating tracks
std::string fCVN2017Label
label of module creating cvn pids (2018)
bool showerByEnergyNumu(slid::ShowerLID const *s1, slid::ShowerLID const *s2)
bool CheckTiming(rb::Cluster const &slice)
Definition: Evaluator.cxx:20
::xsd::cxx::tree::exception< char > exception
Definition: Database.h:225
double const & ReMIdValue() const
void FillHistograms(skim::ParametersNumu const &params)
float const & QePIDValue() const
bool isRealData() const
Definition: Event.h:83
bool fIsData
is this data or MC?
Definition: Evaluator.h:87
float const & CosRejCosBakCell() const
float const & SliceContigPlanes() const
float const & CosRejKalBakCellND() const
std::map< size_t, std::vector< cosrej::NueCosRej const * > > fNueCosRej
slice index to nuecosrej ptrs (2017)
Definition: EvaluatorNumu.h:95
float const & SliceMinPlane() const
void FillSliceVector(size_t const &s, art::FindMany< T > &fmp, std::vector< T const * > &ptrMap)
std::vector< KeptSliceInfo > fKeptSlices
slices we keep
Definition: Evaluator.h:91
float const & CosRejKalFwdCellND() const
std::string fNueCosRejLabel
label of module creating nuecosrejs (2017)
const XML_Char * s
Definition: expat.h:262
std::map< size_t, std::vector< rb::Prong const * > > fProngs
slice index to prong ptrs (2017)
Definition: EvaluatorNumu.h:98
virtual double TotalLength() const
Distance along prong to reach last cell hit.
Definition: Prong.cxx:186
Far Detector at Ash River, MN.
float const & CosRejKalFwdCell() const
std::map< size_t, std::vector< cvn::Result const * > > fCVNs
slice index to cvn ptrs (2017)
std::string fVertexLabel
label of module creating vertex (2017)
std::string fEnergyLabel
label of module creating energies
T get(std::string const &key) const
Definition: ParameterSet.h:231
float const & CosRejAngleKal() const
float const & TrackStopZ() const
EvaluatorNumu(fhicl::ParameterSet const &p)
std::string fSliceLabel
label of module creating slices
std::string fRecordLabel
label of module creating records
Definition: Evaluator.h:86
Near Detector in the NuMI cavern.
std::map< size_t, std::vector< numue::NumuE const * > > fNumuE
slice index to numue ptrs
Definition: EvaluatorNumu.h:86
std::string fCVNLabel
label of module creating cvn pids (2017)
float const & CosRejKalBakCell() const
void reconfigure(fhicl::ParameterSet const &p)
#define LOG_WARNING(category)
float const & TrackStartZ() const
std::unique_ptr< skim::SelectionBase > fSel
determine which type of selection to use at run time
Definition: EvaluatorNumu.h:83
::xsd::cxx::tree::string< char, simple_type > string
Definition: Database.h:154
float const & PlanesToFront() const
A Cluster with defined start position and direction.
Definition: Prong.h:19
bool KeepSlice(size_t s)
float ShowerEnergy() const
Definition: ShowerLID.h:157
bool getByLabel(std::string const &label, std::string const &productInstanceName, Handle< PROD > &result) const
Definition: DataViewImpl.h:344
float const & SliceMaxPlane() const
bool prongByLengthNumu(rb::Prong const *p1, rb::Prong const *p2)
std::map< size_t, std::vector< qeef::QePId const * > > fQePId
slice index to remid ptrs
Definition: EvaluatorNumu.h:90
std::map< size_t, std::vector< rb::Energy const * > > fEnergy
slice index to energy ptrs
Definition: EvaluatorNumu.h:87
std::map< size_t, size_t > fSliceBestTrkPID
slice index to index of track with best remid
Definition: EvaluatorNumu.h:91
std::map< size_t, std::vector< rb::Track const * > > fCosmicTrack
slice index to track ptrs
Definition: EvaluatorNumu.h:93
size_type get(size_type i, reference item, data_reference data) const
Definition: FindManyP.h:469
float const & NDHadronicCal() const
int fCurrentRun
the current run number
Definition: Evaluator.h:88
float const & QePIDNTracks() const
std::map< size_t, std::vector< rb::Track const * > > fTrack
slice index to track ptrs
Definition: EvaluatorNumu.h:85
std::string fCosmicsLabel
label of module creating cosmic tracks
float const & CosRejConCosPID() const
Float_t e
Definition: plot.C:35
RunNumber_t run() const
Definition: Event.h:77
std::string fShowerLabel
label of module creating showers (2017)
std::map< size_t, std::vector< rb::Shower const * > > fShowers
slice index to shower ptrs (2017)
Definition: EvaluatorNumu.h:97
std::string fNumuELabel
label of module creating numues
float const & NeutrinoE() const
bool CheckSliceQuality(rb::Cluster const &slice)
Definition: Evaluator.cxx:73
unsigned int HighestPIDTrack(const std::vector< art::Ptr< rb::Track > > &sliceTracks, const std::string &remidModuleLabel, const art::Event &e)
Definition: ReMId.cxx:249
bool failedToGet() const
Definition: Handle.h:196
std::map< size_t, std::vector< rb::Track const * > > fTracks
slice index to tracks ptrs (2017)
Definition: EvaluatorNumu.h:96
art::InputTag fProngTag
input tag for prongs used in preselection (2017)