Public Member Functions | Private Member Functions | Private Attributes | List of all members
cheat::RecoCheckAna Class Reference
Inheritance diagram for cheat::RecoCheckAna:
art::EDAnalyzer art::detail::Analyzer art::detail::LegacyModule art::Observer art::ModuleBase

Public Member Functions

 RecoCheckAna (fhicl::ParameterSet const &p)
 
- Public Member Functions inherited from art::EDAnalyzer
 EDAnalyzer (fhicl::ParameterSet const &pset)
 
template<typename Config >
 EDAnalyzer (Table< Config > const &config)
 
std::string workerType () const
 
- Public Member Functions inherited from art::detail::Analyzer
virtual ~Analyzer () noexcept
 
 Analyzer (fhicl::ParameterSet const &pset)
 
template<typename Config >
 Analyzer (Table< Config > const &config)
 
void doBeginJob (SharedResources const &resources)
 
void doEndJob ()
 
void doRespondToOpenInputFile (FileBlock const &fb)
 
void doRespondToCloseInputFile (FileBlock const &fb)
 
void doRespondToOpenOutputFiles (FileBlock const &fb)
 
void doRespondToCloseOutputFiles (FileBlock const &fb)
 
bool doBeginRun (RunPrincipal &rp, ModuleContext const &mc)
 
bool doEndRun (RunPrincipal &rp, ModuleContext const &mc)
 
bool doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
 
bool doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
 
bool doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)
 
- Public Member Functions inherited from art::Observer
 ~Observer () noexcept
 
 Observer (Observer const &)=delete
 
 Observer (Observer &&)=delete
 
Observeroperator= (Observer const &)=delete
 
Observeroperator= (Observer &&)=delete
 
void registerProducts (ProductDescriptions &, ModuleDescription const &)
 
void fillDescriptions (ModuleDescription const &)
 
fhicl::ParameterSetID selectorConfig () const
 
- Public Member Functions inherited from art::ModuleBase
virtual ~ModuleBase () noexcept
 
 ModuleBase ()
 
ModuleDescription const & moduleDescription () const
 
void setModuleDescription (ModuleDescription const &)
 
std::array< std::vector< ProductInfo >, NumBranchTypes > const & getConsumables () const
 
void sortConsumables (std::string const &current_process_name)
 
template<typename T , BranchType BT>
ViewToken< T > consumesView (InputTag const &tag)
 
template<typename T , BranchType BT>
ViewToken< T > mayConsumeView (InputTag const &tag)
 

Private Member Functions

void analyze (art::Event const &e) override
 
void beginRun (art::Run const &r) override
 
void CheckReco (detinfo::DetectorClocksData const &clockData, int const &colID, std::vector< art::Ptr< recob::Hit >> const &allhits, std::vector< art::Ptr< recob::Hit >> const &colHits, std::map< std::pair< int, int >, std::pair< double, double >> &g4RecoBaseIDToPurityEfficiency)
 
void CheckRecoClusters (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Cluster >> const &clscol, std::vector< art::Ptr< recob::Hit >> const &allhits)
 
void CheckRecoTracks (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Track >> const &tcol, std::vector< art::Ptr< recob::Hit >> const &allhits)
 
void CheckRecoShowers (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Shower >> const &scol, std::vector< art::Ptr< recob::Hit >> const &allhits)
 
void CheckRecoVertices (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Vertex >> const &vtxcol, std::vector< art::Ptr< recob::Hit >> const &allhits)
 
void CheckRecoEvents (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Event >> const &evtcol, std::vector< art::Ptr< recob::Hit >> const &allhits)
 
void FillResults (detinfo::DetectorClocksData const &clockData, std::vector< art::Ptr< recob::Hit >> const &allhits)
 
void FlattenMap (std::map< std::pair< int, int >, std::pair< double, double >> const &g4RecoBaseIDToPurityEfficiency, std::map< int, std::vector< std::pair< int, std::pair< double, double >>>> &g4IDToRecoBasePurityEfficiency, TH1D *purity, TH1D *efficiency, TH1D *purityEfficiency, TH2D *purityEfficiency2D)
 

Private Attributes

art::ServiceHandle< cheat::BackTrackerService const > fBT
 the back tracker service More...
 
art::ServiceHandle< cheat::ParticleInventoryService const > fPI
 the back tracker service More...
 
std::string fHitModuleLabel
 label for module making the hits More...
 
std::string fClusterModuleLabel
 label for module making the clusters More...
 
std::string fShowerModuleLabel
 label for module making the showers More...
 
std::string fTrackModuleLabel
 label for module making the tracks More...
 
std::string fVertexModuleLabel
 label for module making the vertices More...
 
std::string fEventModuleLabel
 label for module making the events More...
 
bool fCheckClusters
 should we check the reconstruction of clusters? More...
 
bool fCheckShowers
 should we check the reconstruction of showers? More...
 
bool fCheckTracks
 should we check the reconstruction of tracks? More...
 
bool fCheckVertices
 should we check the reconstruction of vertices? More...
 
bool fCheckEvents
 should we check the reconstruction of events? More...
 
TH1D * fClusterPurity
 histogram of cluster purity More...
 
TH1D * fClusterEfficiency
 histogram of cluster efficiency More...
 
TH1D * fClusterPurityEfficiency
 histogram of cluster efficiency times purity More...
 
TH2D * fClusterPurityEfficiency2D
 scatter histogram of cluster purity and efficiency More...
 
TH1D * fShowerPurity
 histogram of shower purity More...
 
TH1D * fShowerEfficiency
 histogram of shower efficiency More...
 
TH1D * fShowerPurityEfficiency
 histogram of shower efficiency times purity More...
 
TH2D * fShowerPurityEfficiency2D
 scatter histogram of cluster purity and efficiency More...
 
TH1D * fTrackPurity
 histogram of track purity More...
 
TH1D * fTrackEfficiency
 histogram of track efficiency More...
 
TH1D * fTrackPurityEfficiency
 histogram of track efficiency times purity More...
 
TH2D * fTrackPurityEfficiency2D
 scatter histogram of cluster purity and efficiency More...
 
TH1D * fVertexPurity
 histogram of vertex purity More...
 
TH1D * fVertexEfficiency
 histogram of vertex efficiency More...
 
TH1D * fVertexPurityEfficiency
 histogram of vertex efficiency times purity More...
 
TH1D * fEventPurity
 histogram of event purity More...
 
TH1D * fEventEfficiency
 histogram of event efficiency More...
 
TH1D * fEventPurityEfficiency
 histogram of event efficiency times purity More...
 
std::map< std::pair< int, int >, std::pair< double, double > > fG4ClusterIDToPurityEfficiency
 
std::map< std::pair< int, int >, std::pair< double, double > > fG4ShowerIDToPurityEfficiency
 
std::map< std::pair< int, int >, std::pair< double, double > > fG4TrackIDToPurityEfficiency
 
TTree * fTree
 TTree to save efficiencies. More...
 
int frun
 run number More...
 
int fevent
 event number More...
 
int ftrackid
 geant track ID More...
 
int fpdg
 particle pdg code More...
 
double fpmom
 particle momentum More...
 
double fhiteff
 hitfinder efficiency for this particle More...
 
int fnclu
 number of clusters for this particle More...
 
std::vector< double > fclueff
 cluster efficiencies More...
 
std::vector< double > fclupur
 cluster purities More...
 
std::vector< int > fcluid
 cluster IDs More...
 
int fnshw
 number of showers for this particle More...
 
std::vector< double > fshweff
 shower efficiencies More...
 
std::vector< double > fshwpur
 shower purities More...
 
std::vector< int > fshwid
 shower IDs More...
 
int fntrk
 number of tracks for this particle More...
 
std::vector< double > ftrkeff
 track efficiencies More...
 
std::vector< double > ftrkpur
 track purities More...
 
std::vector< int > ftrkid
 track IDs More...
 

Additional Inherited Members

- Public Types inherited from art::EDAnalyzer
using WorkerType = WorkerT< EDAnalyzer >
 
using ModuleType = EDAnalyzer
 
- Protected Member Functions inherited from art::Observer
std::string const & processName () const
 
bool wantAllEvents () const noexcept
 
bool wantEvent (ScheduleID id, Event const &e) const
 
Handle< TriggerResultsgetTriggerResults (Event const &e) const
 
 Observer (fhicl::ParameterSet const &config)
 
 Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)
 
- Protected Member Functions inherited from art::ModuleBase
ConsumesCollectorconsumesCollector ()
 
template<typename T , BranchType = InEvent>
ProductToken< T > consumes (InputTag const &)
 
template<typename Element , BranchType = InEvent>
ViewToken< Element > consumesView (InputTag const &)
 
template<typename T , BranchType = InEvent>
void consumesMany ()
 
template<typename T , BranchType = InEvent>
ProductToken< T > mayConsume (InputTag const &)
 
template<typename Element , BranchType = InEvent>
ViewToken< Element > mayConsumeView (InputTag const &)
 
template<typename T , BranchType = InEvent>
void mayConsumeMany ()
 

Detailed Description

Definition at line 48 of file RecoCheckAna_module.cc.

Constructor & Destructor Documentation

cheat::RecoCheckAna::RecoCheckAna ( fhicl::ParameterSet const &  p)
explicit

Definition at line 160 of file RecoCheckAna_module.cc.

161  : EDAnalyzer(p)
162  , fHitModuleLabel{p.get<std::string>("HitModuleLabel")}
163  , fClusterModuleLabel{p.get<std::string>("ClusterModuleLabel")}
164  , fShowerModuleLabel{p.get<std::string>("ShowerModuleLabel")}
165  , fTrackModuleLabel{p.get<std::string>("TrackModuleLabel")}
166  , fVertexModuleLabel{p.get<std::string>("VertexModuleLabel")}
167  , fEventModuleLabel{p.get<std::string>("EventModuleLabel")}
168  , fCheckClusters{p.get<bool>("CheckClusters")}
169  , fCheckShowers{p.get<bool>("CheckShowers")}
170  , fCheckTracks{p.get<bool>("CheckTracks")}
171  , fCheckVertices{p.get<bool>("CheckVertices")}
172  , fCheckEvents{p.get<bool>("CheckEvents")}
173 {}
bool fCheckVertices
should we check the reconstruction of vertices?
std::string string
Definition: nybbler.cc:12
bool fCheckEvents
should we check the reconstruction of events?
EDAnalyzer(fhicl::ParameterSet const &pset)
Definition: EDAnalyzer.h:25
bool fCheckClusters
should we check the reconstruction of clusters?
p
Definition: test.py:223
bool fCheckTracks
should we check the reconstruction of tracks?
std::string fTrackModuleLabel
label for module making the tracks
bool fCheckShowers
should we check the reconstruction of showers?
std::string fClusterModuleLabel
label for module making the clusters
std::string fShowerModuleLabel
label for module making the showers
std::string fEventModuleLabel
label for module making the events
std::string fVertexModuleLabel
label for module making the vertices
std::string fHitModuleLabel
label for module making the hits

Member Function Documentation

void cheat::RecoCheckAna::analyze ( art::Event const &  e)
overrideprivatevirtual

Implements art::EDAnalyzer.

Definition at line 177 of file RecoCheckAna_module.cc.

178 {
179  // check that this is MC, stop if it isn't
180  if (e.isRealData()) {
181  mf::LogWarning("RecoVetter") << "attempting to run MC truth check on "
182  << "real data, bail";
183  return;
184  }
185 
186  // get all hits in the event to figure out how many there are
188  e.getByLabel(fHitModuleLabel, hithdl);
189  std::vector<art::Ptr<recob::Hit>> allhits;
190  art::fill_ptr_vector(allhits, hithdl);
191 
192  // define variables to hold the reconstructed objects
198 
199  if (fCheckClusters) {
200  e.getByLabel(fClusterModuleLabel, clscol);
201  if (!clscol.failedToGet()) this->CheckRecoClusters(e, fClusterModuleLabel, clscol, allhits);
202  }
203  if (fCheckTracks) {
204  e.getByLabel(fTrackModuleLabel, trkcol);
205  if (!trkcol.failedToGet()) this->CheckRecoTracks(e, fTrackModuleLabel, trkcol, allhits);
206  }
207  if (fCheckShowers) {
208  e.getByLabel(fShowerModuleLabel, shwcol);
209  if (!shwcol.failedToGet()) this->CheckRecoShowers(e, fShowerModuleLabel, shwcol, allhits);
210  }
211  if (fCheckVertices) {
212  e.getByLabel(fVertexModuleLabel, vtxcol);
213  if (!vtxcol.failedToGet()) this->CheckRecoVertices(e, fVertexModuleLabel, vtxcol, allhits);
214  }
215  if (fCheckEvents) {
216  e.getByLabel(fEventModuleLabel, evtcol);
217  if (!evtcol.failedToGet()) this->CheckRecoEvents(e, fEventModuleLabel, evtcol, allhits);
218  }
219 
220  frun = e.run();
221  fevent = e.id().event();
222 
223  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(e);
224  this->FillResults(clockData, allhits);
225 
226  return;
227 }
bool fCheckVertices
should we check the reconstruction of vertices?
void CheckRecoEvents(art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Event >> const &evtcol, std::vector< art::Ptr< recob::Hit >> const &allhits)
bool fCheckEvents
should we check the reconstruction of events?
void CheckRecoTracks(art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Track >> const &tcol, std::vector< art::Ptr< recob::Hit >> const &allhits)
const double e
bool fCheckClusters
should we check the reconstruction of clusters?
bool fCheckTracks
should we check the reconstruction of tracks?
std::string fTrackModuleLabel
label for module making the tracks
bool fCheckShowers
should we check the reconstruction of showers?
void CheckRecoShowers(art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Shower >> const &scol, std::vector< art::Ptr< recob::Hit >> const &allhits)
void FillResults(detinfo::DetectorClocksData const &clockData, std::vector< art::Ptr< recob::Hit >> const &allhits)
void CheckRecoVertices(art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Vertex >> const &vtxcol, std::vector< art::Ptr< recob::Hit >> const &allhits)
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
std::string fClusterModuleLabel
label for module making the clusters
void CheckRecoClusters(art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Cluster >> const &clscol, std::vector< art::Ptr< recob::Hit >> const &allhits)
std::string fShowerModuleLabel
label for module making the showers
std::string fEventModuleLabel
label for module making the events
void fill_ptr_vector(std::vector< Ptr< T >> &ptrs, H const &h)
Definition: Ptr.h:297
std::string fVertexModuleLabel
label for module making the vertices
bool failedToGet() const
Definition: Handle.h:198
std::string fHitModuleLabel
label for module making the hits
void cheat::RecoCheckAna::beginRun ( art::Run const &  r)
overrideprivatevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 231 of file RecoCheckAna_module.cc.

232 {
234 
235  if (fCheckEvents) {
236  fEventPurity = tfs->make<TH1D>("eventPurity", ";Purity;Events", 100, 0., 1.1);
237  fEventEfficiency = tfs->make<TH1D>("eventEfficiency", ";Efficiency;Events", 100, 0., 1.1);
239  tfs->make<TH1D>("eventPurityEfficiency", ";purityEfficiency;Events", 110, 0., 1.1);
240  }
241  if (fCheckVertices) {
242  fVertexPurity = tfs->make<TH1D>("vertexPurity", ";Purity;Vertices", 100, 0., 1.1);
243  fVertexEfficiency = tfs->make<TH1D>("vertexEfficiency", ";Efficiency;Vertices", 100, 0., 1.1);
245  tfs->make<TH1D>("vertexPurityEfficiency", ";purityEfficiency;Vertex", 110, 0., 1.1);
246  }
247  if (fCheckTracks) {
248  fTrackPurity = tfs->make<TH1D>("trackPurity", ";Purity;Tracks", 100, 0., 1.1);
249  fTrackEfficiency = tfs->make<TH1D>("trackEfficiency", ";Efficiency;Tracks", 100, 0., 1.1);
251  tfs->make<TH1D>("trackPurityEfficiency", ";purityEfficiency;Tracks", 110, 0., 1.1);
253  tfs->make<TH2D>("trackPurityEfficiency2D", ";purity;efficiency", 110, 0., 1.1, 110, 0., 1.1);
254  }
255  if (fCheckShowers) {
256  fShowerPurity = tfs->make<TH1D>("showerPurity", ";Purity;Showers", 100, 0., 1.1);
257  fShowerEfficiency = tfs->make<TH1D>("showerEfficiency", ";Efficiency;Showers", 100, 0., 1.1);
259  tfs->make<TH1D>("showerPurityEfficiency", ";purityEfficiency;Showers", 110, 0., 1.1);
261  tfs->make<TH2D>("showerPurityEfficiency2D", ";purity;efficiency", 110, 0., 1.1, 110, 0., 1.1);
262  }
263  if (fCheckClusters) {
264  fClusterPurity = tfs->make<TH1D>("clusterPurity", ";Purity;Clusters", 110, 0., 1.1);
265  fClusterEfficiency = tfs->make<TH1D>("clusterEfficiency", ";Efficiency;Clusters", 110, 0., 1.1);
267  tfs->make<TH1D>("clusterPurityEfficiency", ";purityEfficiency;Clusters", 110, 0., 1.1);
268  fClusterPurityEfficiency2D = tfs->make<TH2D>(
269  "clusterPurityEfficiency2D", ";purity;efficiency", 110, 0., 1.1, 110, 0., 1.1);
270  }
271 
272  fTree = tfs->make<TTree>("cheatertree", "cheater tree");
273  fTree->Branch("run", &frun, "run/I");
274  fTree->Branch("event", &fevent, "event/I");
275  fTree->Branch("trackid", &ftrackid, "trackid/I");
276  fTree->Branch("pdg", &fpdg, "pdg/I");
277  fTree->Branch("pmom", &fpmom, "pmom/D");
278  fTree->Branch("hiteff", &fhiteff, "hiteff/D");
279  fTree->Branch("nclu", &fnclu, "nclu/I");
280  fTree->Branch("clueff", &fclueff);
281  fTree->Branch("clupur", &fclupur);
282  fTree->Branch("cluid", &fcluid);
283  fTree->Branch("nshw", &fnshw, "nshw/I");
284  fTree->Branch("shweff", &fshweff);
285  fTree->Branch("shwpur", &fshwpur);
286  fTree->Branch("shwid", &fshwid);
287  fTree->Branch("ntrk", &fntrk, "ntrk/I");
288  fTree->Branch("trkeff", &ftrkeff);
289  fTree->Branch("trkpur", &ftrkpur);
290  fTree->Branch("trkid", &ftrkid);
291 
292  return;
293 }
int fpdg
particle pdg code
int fnshw
number of showers for this particle
TH1D * fTrackPurityEfficiency
histogram of track efficiency times purity
bool fCheckVertices
should we check the reconstruction of vertices?
double fhiteff
hitfinder efficiency for this particle
TH1D * fClusterPurityEfficiency
histogram of cluster efficiency times purity
int fnclu
number of clusters for this particle
int fntrk
number of tracks for this particle
TH1D * fEventPurity
histogram of event purity
bool fCheckEvents
should we check the reconstruction of events?
TH2D * fTrackPurityEfficiency2D
scatter histogram of cluster purity and efficiency
TH1D * fEventEfficiency
histogram of event efficiency
TH1D * fVertexPurity
histogram of vertex purity
TH1D * fEventPurityEfficiency
histogram of event efficiency times purity
TH1D * fVertexPurityEfficiency
histogram of vertex efficiency times purity
std::vector< double > fclupur
cluster purities
std::vector< double > fshweff
shower efficiencies
bool fCheckClusters
should we check the reconstruction of clusters?
std::vector< double > fshwpur
shower purities
TTree * fTree
TTree to save efficiencies.
std::vector< int > fshwid
shower IDs
TH1D * fVertexEfficiency
histogram of vertex efficiency
std::vector< int > ftrkid
track IDs
std::vector< double > ftrkeff
track efficiencies
bool fCheckTracks
should we check the reconstruction of tracks?
std::vector< double > fclueff
cluster efficiencies
double fpmom
particle momentum
std::vector< int > fcluid
cluster IDs
std::vector< double > ftrkpur
track purities
bool fCheckShowers
should we check the reconstruction of showers?
int ftrackid
geant track ID
TH1D * fShowerPurityEfficiency
histogram of shower efficiency times purity
TH1D * fClusterPurity
histogram of cluster purity
TH1D * fClusterEfficiency
histogram of cluster efficiency
TH1D * fShowerPurity
histogram of shower purity
TH1D * fShowerEfficiency
histogram of shower efficiency
TH1D * fTrackPurity
histogram of track purity
TH2D * fClusterPurityEfficiency2D
scatter histogram of cluster purity and efficiency
TH1D * fTrackEfficiency
histogram of track efficiency
TH2D * fShowerPurityEfficiency2D
scatter histogram of cluster purity and efficiency
void cheat::RecoCheckAna::CheckReco ( detinfo::DetectorClocksData const &  clockData,
int const &  colID,
std::vector< art::Ptr< recob::Hit >> const &  allhits,
std::vector< art::Ptr< recob::Hit >> const &  colHits,
std::map< std::pair< int, int >, std::pair< double, double >> &  g4RecoBaseIDToPurityEfficiency 
)
private

Definition at line 299 of file RecoCheckAna_module.cc.

305 {
306 
307  // grab the set of track IDs for these hits
308  std::set<int> trackIDs = fBT->GetSetOfTrackIds(clockData, colHits);
309 
310  geo::View_t view = colHits[0]->View();
311 
312  std::set<int>::iterator itr = trackIDs.begin();
313  while (itr != trackIDs.end()) {
314 
315  std::set<int> id;
316  id.insert(*itr);
317 
318  // use the cheat::BackTrackerService to find purity and efficiency for these
319  // hits
320  double purity = fBT->HitCollectionPurity(clockData, id, colHits);
321  double efficiency = fBT->HitCollectionEfficiency(clockData, id, colHits, allhits, view);
322 
323  // make the purity and efficiency pair
324  std::pair<double, double> pe(purity, efficiency);
325 
326  // make the pair of the RecoBase object id to the pair of purity/efficiency
327  std::pair<int, int> g4reco(*itr, colID);
328 
329  // insert idpe into the map
330  g4RecoBaseIDToPurityEfficiency[g4reco] = pe;
331 
332  itr++;
333 
334  } // end loop over eveIDs
335 
336  return;
337 }
art::ServiceHandle< cheat::BackTrackerService const > fBT
the back tracker service
intermediate_table::iterator iterator
enum geo::_plane_proj View_t
Enumerate the possible plane projections.
double HitCollectionEfficiency(detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits, std::vector< art::Ptr< recob::Hit >> const &allhits, geo::View_t const &view) const
std::set< int > GetSetOfTrackIds() const
double HitCollectionPurity(detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits) const
void cheat::RecoCheckAna::CheckRecoClusters ( art::Event const &  evt,
std::string const &  label,
art::Handle< std::vector< recob::Cluster >> const &  clscol,
std::vector< art::Ptr< recob::Hit >> const &  allhits 
)
private

Definition at line 341 of file RecoCheckAna_module.cc.

345 {
346  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
347  art::FindManyP<recob::Hit> fmh(clscol, evt, label);
348 
349  for (size_t c = 0; c < clscol->size(); ++c) {
350 
351  // get the hits associated with this event
352  std::vector<art::Ptr<recob::Hit>> hits = fmh.at(c);
353 
354  this->CheckReco(clockData, clscol->at(c).ID(), allhits, hits, fG4ClusterIDToPurityEfficiency);
355 
356  } // end loop over clusters
357 
358  return;
359 }
void CheckReco(detinfo::DetectorClocksData const &clockData, int const &colID, std::vector< art::Ptr< recob::Hit >> const &allhits, std::vector< art::Ptr< recob::Hit >> const &colHits, std::map< std::pair< int, int >, std::pair< double, double >> &g4RecoBaseIDToPurityEfficiency)
std::map< std::pair< int, int >, std::pair< double, double > > fG4ClusterIDToPurityEfficiency
TCEvent evt
Definition: DataStructs.cxx:7
void cheat::RecoCheckAna::CheckRecoEvents ( art::Event const &  evt,
std::string const &  label,
art::Handle< std::vector< recob::Event >> const &  evtcol,
std::vector< art::Ptr< recob::Hit >> const &  allhits 
)
private
Todo:
need to divy it up in the case where there is more than 1 true interaction in a spill

Definition at line 471 of file RecoCheckAna_module.cc.

475 {
476  const sim::ParticleList& plist = fPI->ParticleList();
477 
478  // loop over all primaries in the plist and grab them and their daughters to put into
479  // the set of track ids to pass on to the back tracker
480  std::set<int> ids;
481  for (const auto& PartPair : plist) {
482  auto trackID = PartPair.first;
483  if (!plist.IsPrimary(trackID)) continue;
484  const simb::MCParticle& part = *(PartPair.second);
485  ids.insert(trackID);
486  for (int d = 0; d < part.NumberDaughters(); ++d)
487  ids.insert(part.Daughter(d));
488  } // end loop over primaries
489 
490  art::FindManyP<recob::Hit> fmh(evtcol, evt, label);
491 
492  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
493  for (size_t ev = 0; ev < evtcol->size(); ++ev) {
494 
495  // get the hits associated with this event
496  std::vector<art::Ptr<recob::Hit>> hits = fmh.at(ev);
497 
498  // use the cheat::BackTrackerService to find purity and efficiency for these
499  // hits
500  double purity = fBT->HitCollectionPurity(clockData, ids, hits);
501  double efficiency = fBT->HitCollectionEfficiency(clockData, ids, hits, allhits, geo::k3D);
502 
503  fEventPurity->Fill(purity);
504  fEventEfficiency->Fill(efficiency);
505  fEventPurityEfficiency->Fill(purity * efficiency);
506 
507  } // end loop over events
508 
509  return;
510 }
art::ServiceHandle< cheat::BackTrackerService const > fBT
the back tracker service
double HitCollectionEfficiency(detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits, std::vector< art::Ptr< recob::Hit >> const &allhits, geo::View_t const &view) const
art::ServiceHandle< cheat::ParticleInventoryService const > fPI
the back tracker service
TH1D * fEventPurity
histogram of event purity
TH1D * fEventEfficiency
histogram of event efficiency
int NumberDaughters() const
Definition: MCParticle.h:217
int Daughter(const int i) const
Definition: MCParticle.cxx:112
TH1D * fEventPurityEfficiency
histogram of event efficiency times purity
3-dimensional objects, potentially hits, clusters, prongs, etc.
Definition: geo_types.h:135
double HitCollectionPurity(detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits) const
const sim::ParticleList & ParticleList() const
TCEvent evt
Definition: DataStructs.cxx:7
void cheat::RecoCheckAna::CheckRecoShowers ( art::Event const &  evt,
std::string const &  label,
art::Handle< std::vector< recob::Shower >> const &  scol,
std::vector< art::Ptr< recob::Hit >> const &  allhits 
)
private

Definition at line 385 of file RecoCheckAna_module.cc.

389 {
390  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
391  art::FindManyP<recob::Hit> fmh(scol, evt, label);
392 
393  for (size_t p = 0; p < scol->size(); ++p) {
394 
395  // get the hits associated with this event
396  std::vector<art::Ptr<recob::Hit>> hits = fmh.at(p);
397 
398  this->CheckReco(clockData, scol->at(p).ID(), allhits, hits, fG4ShowerIDToPurityEfficiency);
399 
400  } // end loop over events
401 
402  return;
403 }
void CheckReco(detinfo::DetectorClocksData const &clockData, int const &colID, std::vector< art::Ptr< recob::Hit >> const &allhits, std::vector< art::Ptr< recob::Hit >> const &colHits, std::map< std::pair< int, int >, std::pair< double, double >> &g4RecoBaseIDToPurityEfficiency)
p
Definition: test.py:223
std::map< std::pair< int, int >, std::pair< double, double > > fG4ShowerIDToPurityEfficiency
TCEvent evt
Definition: DataStructs.cxx:7
void cheat::RecoCheckAna::CheckRecoTracks ( art::Event const &  evt,
std::string const &  label,
art::Handle< std::vector< recob::Track >> const &  tcol,
std::vector< art::Ptr< recob::Hit >> const &  allhits 
)
private

Definition at line 363 of file RecoCheckAna_module.cc.

367 {
368  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
369  art::FindManyP<recob::Hit> fmh(tcol, evt, label);
370 
371  for (size_t p = 0; p < tcol->size(); ++p) {
372 
373  // get the hits associated with this event
374  std::vector<art::Ptr<recob::Hit>> hits = fmh.at(p);
375 
376  this->CheckReco(clockData, tcol->at(p).ID(), allhits, hits, fG4TrackIDToPurityEfficiency);
377 
378  } // end loop over tracks
379 
380  return;
381 }
void CheckReco(detinfo::DetectorClocksData const &clockData, int const &colID, std::vector< art::Ptr< recob::Hit >> const &allhits, std::vector< art::Ptr< recob::Hit >> const &colHits, std::map< std::pair< int, int >, std::pair< double, double >> &g4RecoBaseIDToPurityEfficiency)
p
Definition: test.py:223
std::map< std::pair< int, int >, std::pair< double, double > > fG4TrackIDToPurityEfficiency
TCEvent evt
Definition: DataStructs.cxx:7
void cheat::RecoCheckAna::CheckRecoVertices ( art::Event const &  evt,
std::string const &  label,
art::Handle< std::vector< recob::Vertex >> const &  vtxcol,
std::vector< art::Ptr< recob::Hit >> const &  allhits 
)
private

Definition at line 409 of file RecoCheckAna_module.cc.

413 {
414  const sim::ParticleList& plist = fPI->ParticleList();
415 
416  std::vector<std::set<int>> ids(1);
417  // loop over all primary particles and put their ids into the first set of the
418  // vector. add another set for each primary particle that also has daughters
419  // and put those daughters into the new set
420  // PartPair is a (track ID, particle pointer) pair
421  for (const auto& PartPair : plist) {
422  auto trackID = PartPair.first;
423  if (!plist.IsPrimary(trackID)) continue;
424  const simb::MCParticle& part = *(PartPair.second);
425  ids[0].insert(trackID);
426  if (part.NumberDaughters() > 0) {
427  std::set<int> dv;
428  for (int d = 0; d < part.NumberDaughters(); ++d)
429  dv.insert(part.Daughter(d));
430  ids.push_back(std::move(dv));
431  } // end if this primary particle has daughters
432  } // end loop over primaries
433 
434  art::FindManyP<recob::Hit> fmh(vtxcol, evt, label);
435 
436  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
437 
438  for (size_t v = 0; v < vtxcol->size(); ++v) {
439 
440  // get the hits associated with this event
441  std::vector<art::Ptr<recob::Hit>> hits = fmh.at(v);
442 
443  double maxPurity = -1.;
444  double maxEfficiency = -1.;
445 
446  for (size_t tv = 0; tv < ids.size(); ++tv) {
447 
448  // use the cheat::BackTrackerService to find purity and efficiency for
449  // these hits
450  double purity = fBT->HitCollectionPurity(clockData, ids[tv], hits);
451  double efficiency = fBT->HitCollectionEfficiency(clockData, ids[tv], hits, allhits, geo::k3D);
452 
453  if (purity > maxPurity) maxPurity = purity;
454  if (efficiency > maxEfficiency) maxEfficiency = efficiency;
455  }
456 
457  fVertexPurity->Fill(maxPurity);
458  fVertexEfficiency->Fill(maxEfficiency);
459  fVertexPurityEfficiency->Fill(maxPurity * maxEfficiency);
460 
461  } // end loop over vertices
462 
463  return;
464 }
art::ServiceHandle< cheat::BackTrackerService const > fBT
the back tracker service
double HitCollectionEfficiency(detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits, std::vector< art::Ptr< recob::Hit >> const &allhits, geo::View_t const &view) const
art::ServiceHandle< cheat::ParticleInventoryService const > fPI
the back tracker service
int NumberDaughters() const
Definition: MCParticle.h:217
TH1D * fVertexPurity
histogram of vertex purity
int Daughter(const int i) const
Definition: MCParticle.cxx:112
3-dimensional objects, potentially hits, clusters, prongs, etc.
Definition: geo_types.h:135
TH1D * fVertexPurityEfficiency
histogram of vertex efficiency times purity
double HitCollectionPurity(detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits) const
def move(depos, offset)
Definition: depos.py:107
TH1D * fVertexEfficiency
histogram of vertex efficiency
const sim::ParticleList & ParticleList() const
TCEvent evt
Definition: DataStructs.cxx:7
void cheat::RecoCheckAna::FillResults ( detinfo::DetectorClocksData const &  clockData,
std::vector< art::Ptr< recob::Hit >> const &  allhits 
)
private

Definition at line 574 of file RecoCheckAna_module.cc.

576 {
577  // map the g4 track id to energy deposited in a hit
578  std::map<int, double> g4IDToHitEnergy;
579  for (size_t h = 0; h < allhits.size(); ++h) {
580  const std::vector<sim::TrackIDE> hitTrackIDs = fBT->HitToTrackIDEs(clockData, allhits[h]);
581  for (size_t e = 0; e < hitTrackIDs.size(); ++e) {
582  g4IDToHitEnergy[hitTrackIDs[e].trackID] += hitTrackIDs[e].energy;
583  }
584  } // end loop over hits to fill map
585 
586  // flatten the G4RecoBaseIDToPurityEfficiency maps to have just the g4ID as
587  // the key and the rest of the information in vector form
588  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
589  g4IDToClusterPurityEfficiency;
590  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
591  g4IDToShowerPurityEfficiency;
592  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>> g4IDToTrackPurityEfficiency;
593  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>::iterator g4peItr;
594 
595  if (fCheckClusters)
597  g4IDToClusterPurityEfficiency,
602  if (fCheckShowers)
604  g4IDToShowerPurityEfficiency,
609  if (fCheckTracks)
611  g4IDToTrackPurityEfficiency,
612  fTrackPurity,
616 
617  // fill the tree vectors
618  // get all the eveIDs from this event
619  std::set<int> trackIDs = fBT->GetSetOfTrackIds();
620  std::set<int>::const_iterator trackItr = trackIDs.begin();
621 
622  // loop over them
623  while (trackItr != trackIDs.end()) {
624 
625  const simb::MCParticle* part = fPI->TrackIdToParticle_P(*trackItr);
626 
627  ftrackid = std::abs(*trackItr);
628  fpdg = part->PdgCode();
629  fpmom = part->P();
630 
631  // figure out how much of the energy deposited from this particle is stored in hits
632  std::vector<const sim::IDE*> ides = fBT->TrackIdToSimIDEs_Ps(*trackItr);
633  double totalDep = 0.;
634  for (size_t i = 0; i < ides.size(); ++i)
635  totalDep += ides[i]->energy;
636 
637  if (totalDep > 0.) fhiteff = g4IDToHitEnergy[*trackItr] / totalDep;
638 
639  std::vector<std::pair<int, std::pair<double, double>>> clVec;
640  std::vector<std::pair<int, std::pair<double, double>>> shVec;
641  std::vector<std::pair<int, std::pair<double, double>>> trVec;
642 
643  if (g4IDToClusterPurityEfficiency.find(*trackItr) != g4IDToClusterPurityEfficiency.end())
644  clVec = g4IDToClusterPurityEfficiency.find(*trackItr)->second;
645 
646  if (g4IDToShowerPurityEfficiency.find(*trackItr) != g4IDToShowerPurityEfficiency.end())
647  shVec = g4IDToShowerPurityEfficiency.find(*trackItr)->second;
648 
649  if (g4IDToTrackPurityEfficiency.find(*trackItr) != g4IDToTrackPurityEfficiency.end())
650  trVec = g4IDToTrackPurityEfficiency.find(*trackItr)->second;
651 
652  fnclu = clVec.size();
653  fnshw = shVec.size();
654  fntrk = trVec.size();
655 
656  for (size_t c = 0; c < clVec.size(); ++c) {
657  fcluid.push_back(clVec[c].first);
658  fclupur.push_back(clVec[c].second.first);
659  fclueff.push_back(clVec[c].second.second);
660  }
661 
662  for (size_t s = 0; s < shVec.size(); ++s) {
663  fshwid.push_back(shVec[s].first);
664  fshwpur.push_back(shVec[s].second.first);
665  fshweff.push_back(shVec[s].second.second);
666  }
667 
668  for (size_t t = 0; t < trVec.size(); ++t) {
669  ftrkid.push_back(trVec[t].first);
670  ftrkpur.push_back(trVec[t].second.first);
671  ftrkeff.push_back(trVec[t].second.second);
672  }
673 
674  fTree->Fill();
675 
676  trackItr++;
677  }
678 
679  // clean up for the next event
680 
681  // clear the maps of G4 track id to efficiency and purity for
682  // various RecoBase objects
686 
687  // clear the vectors hooked up to the tree
688  fclueff.clear();
689  fclupur.clear();
690  fcluid.clear();
691  ftrkeff.clear();
692  ftrkpur.clear();
693  ftrkid.clear();
694  fshweff.clear();
695  fshwpur.clear();
696  fshwid.clear();
697 
698  return;
699 }
art::ServiceHandle< cheat::BackTrackerService const > fBT
the back tracker service
int fpdg
particle pdg code
int fnshw
number of showers for this particle
int PdgCode() const
Definition: MCParticle.h:212
TH1D * fTrackPurityEfficiency
histogram of track efficiency times purity
std::vector< sim::TrackIDE > HitToTrackIDEs(detinfo::DetectorClocksData const &clockData, recob::Hit const &hit) const
const simb::MCParticle * TrackIdToParticle_P(int id) const
double fhiteff
hitfinder efficiency for this particle
TH1D * fClusterPurityEfficiency
histogram of cluster efficiency times purity
int fnclu
number of clusters for this particle
art::ServiceHandle< cheat::ParticleInventoryService const > fPI
the back tracker service
int fntrk
number of tracks for this particle
std::vector< const sim::IDE * > TrackIdToSimIDEs_Ps(int const &id) const
intermediate_table::const_iterator const_iterator
std::map< std::pair< int, int >, std::pair< double, double > > fG4ClusterIDToPurityEfficiency
TH2D * fTrackPurityEfficiency2D
scatter histogram of cluster purity and efficiency
T abs(T value)
const double e
std::set< int > GetSetOfTrackIds() const
std::vector< double > fclupur
cluster purities
std::vector< double > fshweff
shower efficiencies
bool fCheckClusters
should we check the reconstruction of clusters?
double P(const int i=0) const
Definition: MCParticle.h:234
std::vector< double > fshwpur
shower purities
TTree * fTree
TTree to save efficiencies.
std::vector< int > fshwid
shower IDs
std::vector< int > ftrkid
track IDs
std::vector< double > ftrkeff
track efficiencies
bool fCheckTracks
should we check the reconstruction of tracks?
std::vector< double > fclueff
cluster efficiencies
double fpmom
particle momentum
void FlattenMap(std::map< std::pair< int, int >, std::pair< double, double >> const &g4RecoBaseIDToPurityEfficiency, std::map< int, std::vector< std::pair< int, std::pair< double, double >>>> &g4IDToRecoBasePurityEfficiency, TH1D *purity, TH1D *efficiency, TH1D *purityEfficiency, TH2D *purityEfficiency2D)
std::vector< int > fcluid
cluster IDs
std::vector< double > ftrkpur
track purities
bool fCheckShowers
should we check the reconstruction of showers?
std::map< std::pair< int, int >, std::pair< double, double > > fG4TrackIDToPurityEfficiency
int ftrackid
geant track ID
TH1D * fShowerPurityEfficiency
histogram of shower efficiency times purity
TH1D * fClusterPurity
histogram of cluster purity
std::map< std::pair< int, int >, std::pair< double, double > > fG4ShowerIDToPurityEfficiency
TH1D * fClusterEfficiency
histogram of cluster efficiency
TH1D * fShowerPurity
histogram of shower purity
TH1D * fShowerEfficiency
histogram of shower efficiency
TH1D * fTrackPurity
histogram of track purity
TH2D * fClusterPurityEfficiency2D
scatter histogram of cluster purity and efficiency
second_as<> second
Type of time stored in seconds, in double precision.
Definition: spacetime.h:85
if(!yymsg) yymsg
static QCString * s
Definition: config.cpp:1042
TH1D * fTrackEfficiency
histogram of track efficiency
TH2D * fShowerPurityEfficiency2D
scatter histogram of cluster purity and efficiency
void cheat::RecoCheckAna::FlattenMap ( std::map< std::pair< int, int >, std::pair< double, double >> const &  g4RecoBaseIDToPurityEfficiency,
std::map< int, std::vector< std::pair< int, std::pair< double, double >>>> &  g4IDToRecoBasePurityEfficiency,
TH1D *  purity,
TH1D *  efficiency,
TH1D *  purityEfficiency,
TH2D *  purityEfficiency2D 
)
private

Definition at line 514 of file RecoCheckAna_module.cc.

522 {
523 
524  std::map<std::pair<int, int>, std::pair<double, double>>::const_iterator rbItr =
525  g4RecoBaseIDToPurityEfficiency.begin();
526 
527  // map of key cluster ID to pair of purity, efficiency
528  std::map<int, std::pair<double, double>> recoBIDToPurityEfficiency;
529  std::map<int, std::pair<double, double>>::iterator rbpeItr;
530 
531  while (rbItr != g4RecoBaseIDToPurityEfficiency.end()) {
532 
533  // trackID, cluster ID
534  std::pair<int, int> g4cl = rbItr->first;
535  // purity, efficiency
536  std::pair<double, double> pe = rbItr->second;
537 
538  // add the efficiency and purity values for clusters corresponding
539  // to the current g4 id to the map
540  // pair of cluster id, pair of purity, efficiency
541  std::pair<int, std::pair<double, double>> clpe(g4cl.second, pe);
542  // g4IDToRecoBasePurityEfficiency is a map with key of trackID of a vector of clusterIDs of pairs of purity and efficiency
543  g4IDToRecoBasePurityEfficiency[g4cl.first].push_back(clpe);
544 
545  // now find the maximum purity to determine the purity and efficiency
546  // for this RecoBase object
547  rbpeItr = recoBIDToPurityEfficiency.find(g4cl.second);
548  if (rbpeItr != recoBIDToPurityEfficiency.end()) {
549  std::pair<double, double> curpe = rbpeItr->second;
550  if (pe.first > curpe.first) recoBIDToPurityEfficiency[g4cl.second] = pe;
551  }
552  else
553  recoBIDToPurityEfficiency[g4cl.second] = pe;
554 
555  rbItr++;
556  }
557 
558  rbpeItr = recoBIDToPurityEfficiency.begin();
559 
560  // now fill the histograms,
561  while (rbpeItr != recoBIDToPurityEfficiency.end()) {
562  purity->Fill(rbpeItr->second.first);
563  efficiency->Fill(rbpeItr->second.second);
564  purityEfficiency->Fill(rbpeItr->second.first * rbpeItr->second.second);
565  purityEfficiency2D->Fill(rbpeItr->second.first, rbpeItr->second.second);
566  rbpeItr++;
567  }
568 
569  return;
570 }

Member Data Documentation

art::ServiceHandle<cheat::BackTrackerService const> cheat::RecoCheckAna::fBT
private

the back tracker service

Definition at line 96 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckClusters
private

should we check the reconstruction of clusters?

Definition at line 106 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckEvents
private

should we check the reconstruction of events?

Definition at line 110 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckShowers
private

should we check the reconstruction of showers?

Definition at line 107 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckTracks
private

should we check the reconstruction of tracks?

Definition at line 108 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckVertices
private

should we check the reconstruction of vertices?

Definition at line 109 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::fclueff
private

cluster efficiencies

Definition at line 146 of file RecoCheckAna_module.cc.

std::vector<int> cheat::RecoCheckAna::fcluid
private

cluster IDs

Definition at line 148 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::fclupur
private

cluster purities

Definition at line 147 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fClusterEfficiency
private

histogram of cluster efficiency

Definition at line 113 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fClusterModuleLabel
private

label for module making the clusters

Definition at line 100 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fClusterPurity
private

histogram of cluster purity

Definition at line 112 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fClusterPurityEfficiency
private

histogram of cluster efficiency times purity

Definition at line 114 of file RecoCheckAna_module.cc.

TH2D* cheat::RecoCheckAna::fClusterPurityEfficiency2D
private

scatter histogram of cluster purity and efficiency

Definition at line 115 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fevent
private

event number

Definition at line 140 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fEventEfficiency
private

histogram of event efficiency

Definition at line 128 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fEventModuleLabel
private

label for module making the events

Definition at line 104 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fEventPurity
private

histogram of event purity

Definition at line 127 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fEventPurityEfficiency
private

histogram of event efficiency times purity

Definition at line 129 of file RecoCheckAna_module.cc.

std::map<std::pair<int, int>, std::pair<double, double> > cheat::RecoCheckAna::fG4ClusterIDToPurityEfficiency
private

Definition at line 134 of file RecoCheckAna_module.cc.

std::map<std::pair<int, int>, std::pair<double, double> > cheat::RecoCheckAna::fG4ShowerIDToPurityEfficiency
private

Definition at line 135 of file RecoCheckAna_module.cc.

std::map<std::pair<int, int>, std::pair<double, double> > cheat::RecoCheckAna::fG4TrackIDToPurityEfficiency
private

Definition at line 136 of file RecoCheckAna_module.cc.

double cheat::RecoCheckAna::fhiteff
private

hitfinder efficiency for this particle

Definition at line 144 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fHitModuleLabel
private

label for module making the hits

Definition at line 99 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fnclu
private

number of clusters for this particle

Definition at line 145 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fnshw
private

number of showers for this particle

Definition at line 149 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fntrk
private

number of tracks for this particle

Definition at line 153 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fpdg
private

particle pdg code

Definition at line 142 of file RecoCheckAna_module.cc.

art::ServiceHandle<cheat::ParticleInventoryService const> cheat::RecoCheckAna::fPI
private

the back tracker service

Definition at line 97 of file RecoCheckAna_module.cc.

double cheat::RecoCheckAna::fpmom
private

particle momentum

Definition at line 143 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::frun
private

run number

Definition at line 139 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fShowerEfficiency
private

histogram of shower efficiency

Definition at line 117 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fShowerModuleLabel
private

label for module making the showers

Definition at line 101 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fShowerPurity
private

histogram of shower purity

Definition at line 116 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fShowerPurityEfficiency
private

histogram of shower efficiency times purity

Definition at line 118 of file RecoCheckAna_module.cc.

TH2D* cheat::RecoCheckAna::fShowerPurityEfficiency2D
private

scatter histogram of cluster purity and efficiency

Definition at line 119 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::fshweff
private

shower efficiencies

Definition at line 150 of file RecoCheckAna_module.cc.

std::vector<int> cheat::RecoCheckAna::fshwid
private

shower IDs

Definition at line 152 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::fshwpur
private

shower purities

Definition at line 151 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fTrackEfficiency
private

histogram of track efficiency

Definition at line 121 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::ftrackid
private

geant track ID

Definition at line 141 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fTrackModuleLabel
private

label for module making the tracks

Definition at line 102 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fTrackPurity
private

histogram of track purity

Definition at line 120 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fTrackPurityEfficiency
private

histogram of track efficiency times purity

Definition at line 122 of file RecoCheckAna_module.cc.

TH2D* cheat::RecoCheckAna::fTrackPurityEfficiency2D
private

scatter histogram of cluster purity and efficiency

Definition at line 123 of file RecoCheckAna_module.cc.

TTree* cheat::RecoCheckAna::fTree
private

TTree to save efficiencies.

Definition at line 138 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::ftrkeff
private

track efficiencies

Definition at line 154 of file RecoCheckAna_module.cc.

std::vector<int> cheat::RecoCheckAna::ftrkid
private

track IDs

Definition at line 156 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::ftrkpur
private

track purities

Definition at line 155 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fVertexEfficiency
private

histogram of vertex efficiency

Definition at line 125 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fVertexModuleLabel
private

label for module making the vertices

Definition at line 103 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fVertexPurity
private

histogram of vertex purity

Definition at line 124 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fVertexPurityEfficiency
private

histogram of vertex efficiency times purity

Definition at line 126 of file RecoCheckAna_module.cc.


The documentation for this class was generated from the following file: