Inheritance diagram for cheat::RecoCheckAna:

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

Observer &	operator= (Observer const &)=delete

Observer &	operator= (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< TriggerResults >	getTriggerResults (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
ConsumesCollector &	consumesCollector ()

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.

   : EDAnalyzer(p)
   , fHitModuleLabel{p.get<std::string>("HitModuleLabel")}
   , fClusterModuleLabel{p.get<std::string>("ClusterModuleLabel")}
   , fShowerModuleLabel{p.get<std::string>("ShowerModuleLabel")}
   , fTrackModuleLabel{p.get<std::string>("TrackModuleLabel")}
   , fVertexModuleLabel{p.get<std::string>("VertexModuleLabel")}
   , fEventModuleLabel{p.get<std::string>("EventModuleLabel")}
   , fCheckClusters{p.get<bool>("CheckClusters")}
   , fCheckShowers{p.get<bool>("CheckShowers")}
   , fCheckTracks{p.get<bool>("CheckTracks")}
   , fCheckVertices{p.get<bool>("CheckVertices")}
   , fCheckEvents{p.get<bool>("CheckEvents")}
 {}

Member Function Documentation

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

overrideprivatevirtual

Implements art::EDAnalyzer.

Definition at line 177 of file RecoCheckAna_module.cc.

 {
   // check that this is MC, stop if it isn't
   if (e.isRealData()) {
     mf::LogWarning("RecoVetter") << "attempting to run MC truth check on "
                                  << "real data, bail";
     return;
   }
 
   // get all hits in the event to figure out how many there are
   art::Handle<std::vector<recob::Hit>> hithdl;
   e.getByLabel(fHitModuleLabel, hithdl);
   std::vector<art::Ptr<recob::Hit>> allhits;
   art::fill_ptr_vector(allhits, hithdl);
 
   // define variables to hold the reconstructed objects
   art::Handle<std::vector<recob::Cluster>> clscol;
   art::Handle<std::vector<recob::Track>> trkcol;
   art::Handle<std::vector<recob::Shower>> shwcol;
   art::Handle<std::vector<recob::Vertex>> vtxcol;
   art::Handle<std::vector<recob::Event>> evtcol;
 
   if (fCheckClusters) {
     e.getByLabel(fClusterModuleLabel, clscol);
     if (!clscol.failedToGet()) this->CheckRecoClusters(e, fClusterModuleLabel, clscol, allhits);
   }
   if (fCheckTracks) {
     e.getByLabel(fTrackModuleLabel, trkcol);
     if (!trkcol.failedToGet()) this->CheckRecoTracks(e, fTrackModuleLabel, trkcol, allhits);
   }
   if (fCheckShowers) {
     e.getByLabel(fShowerModuleLabel, shwcol);
     if (!shwcol.failedToGet()) this->CheckRecoShowers(e, fShowerModuleLabel, shwcol, allhits);
   }
   if (fCheckVertices) {
     e.getByLabel(fVertexModuleLabel, vtxcol);
     if (!vtxcol.failedToGet()) this->CheckRecoVertices(e, fVertexModuleLabel, vtxcol, allhits);
   }
   if (fCheckEvents) {
     e.getByLabel(fEventModuleLabel, evtcol);
     if (!evtcol.failedToGet()) this->CheckRecoEvents(e, fEventModuleLabel, evtcol, allhits);
   }
 
   frun = e.run();
   fevent = e.id().event();
 
   auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(e);
   this->FillResults(clockData, allhits);
 
   return;
 }

void cheat::RecoCheckAna::beginRun ( art::Run const & r )

overrideprivatevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 231 of file RecoCheckAna_module.cc.

 {
   art::ServiceHandle<art::TFileService const> tfs;
 
   if (fCheckEvents) {
     fEventPurity = tfs->make<TH1D>("eventPurity", ";Purity;Events", 100, 0., 1.1);
     fEventEfficiency = tfs->make<TH1D>("eventEfficiency", ";Efficiency;Events", 100, 0., 1.1);
     fEventPurityEfficiency =
       tfs->make<TH1D>("eventPurityEfficiency", ";purityEfficiency;Events", 110, 0., 1.1);
   }
   if (fCheckVertices) {
     fVertexPurity = tfs->make<TH1D>("vertexPurity", ";Purity;Vertices", 100, 0., 1.1);
     fVertexEfficiency = tfs->make<TH1D>("vertexEfficiency", ";Efficiency;Vertices", 100, 0., 1.1);
     fVertexPurityEfficiency =
       tfs->make<TH1D>("vertexPurityEfficiency", ";purityEfficiency;Vertex", 110, 0., 1.1);
   }
   if (fCheckTracks) {
     fTrackPurity = tfs->make<TH1D>("trackPurity", ";Purity;Tracks", 100, 0., 1.1);
     fTrackEfficiency = tfs->make<TH1D>("trackEfficiency", ";Efficiency;Tracks", 100, 0., 1.1);
     fTrackPurityEfficiency =
       tfs->make<TH1D>("trackPurityEfficiency", ";purityEfficiency;Tracks", 110, 0., 1.1);
     fTrackPurityEfficiency2D =
       tfs->make<TH2D>("trackPurityEfficiency2D", ";purity;efficiency", 110, 0., 1.1, 110, 0., 1.1);
   }
   if (fCheckShowers) {
     fShowerPurity = tfs->make<TH1D>("showerPurity", ";Purity;Showers", 100, 0., 1.1);
     fShowerEfficiency = tfs->make<TH1D>("showerEfficiency", ";Efficiency;Showers", 100, 0., 1.1);
     fShowerPurityEfficiency =
       tfs->make<TH1D>("showerPurityEfficiency", ";purityEfficiency;Showers", 110, 0., 1.1);
     fShowerPurityEfficiency2D =
       tfs->make<TH2D>("showerPurityEfficiency2D", ";purity;efficiency", 110, 0., 1.1, 110, 0., 1.1);
   }
   if (fCheckClusters) {
     fClusterPurity = tfs->make<TH1D>("clusterPurity", ";Purity;Clusters", 110, 0., 1.1);
     fClusterEfficiency = tfs->make<TH1D>("clusterEfficiency", ";Efficiency;Clusters", 110, 0., 1.1);
     fClusterPurityEfficiency =
       tfs->make<TH1D>("clusterPurityEfficiency", ";purityEfficiency;Clusters", 110, 0., 1.1);
     fClusterPurityEfficiency2D = tfs->make<TH2D>(
       "clusterPurityEfficiency2D", ";purity;efficiency", 110, 0., 1.1, 110, 0., 1.1);
   }
 
   fTree = tfs->make<TTree>("cheatertree", "cheater tree");
   fTree->Branch("run", &frun, "run/I");
   fTree->Branch("event", &fevent, "event/I");
   fTree->Branch("trackid", &ftrackid, "trackid/I");
   fTree->Branch("pdg", &fpdg, "pdg/I");
   fTree->Branch("pmom", &fpmom, "pmom/D");
   fTree->Branch("hiteff", &fhiteff, "hiteff/D");
   fTree->Branch("nclu", &fnclu, "nclu/I");
   fTree->Branch("clueff", &fclueff);
   fTree->Branch("clupur", &fclupur);
   fTree->Branch("cluid", &fcluid);
   fTree->Branch("nshw", &fnshw, "nshw/I");
   fTree->Branch("shweff", &fshweff);
   fTree->Branch("shwpur", &fshwpur);
   fTree->Branch("shwid", &fshwid);
   fTree->Branch("ntrk", &fntrk, "ntrk/I");
   fTree->Branch("trkeff", &ftrkeff);
   fTree->Branch("trkpur", &ftrkpur);
   fTree->Branch("trkid", &ftrkid);
 
   return;
 }

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.

 {
 
   // grab the set of track IDs for these hits
   std::set<int> trackIDs = fBT->GetSetOfTrackIds(clockData, colHits);
 
   geo::View_t view = colHits[0]->View();
 
   std::set<int>::iterator itr = trackIDs.begin();
   while (itr != trackIDs.end()) {
 
     std::set<int> id;
     id.insert(*itr);
 
     // use the cheat::BackTrackerService to find purity and efficiency for these
     // hits
     double purity = fBT->HitCollectionPurity(clockData, id, colHits);
     double efficiency = fBT->HitCollectionEfficiency(clockData, id, colHits, allhits, view);
 
     // make the purity and efficiency pair
     std::pair<double, double> pe(purity, efficiency);
 
     // make the pair of the RecoBase object id to the pair of purity/efficiency
     std::pair<int, int> g4reco(*itr, colID);
 
     // insert idpe into the map
     g4RecoBaseIDToPurityEfficiency[g4reco] = pe;
 
     itr++;
 
   } // end loop over eveIDs
 
   return;
 }

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.

 {
   auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
   art::FindManyP<recob::Hit> fmh(clscol, evt, label);
 
   for (size_t c = 0; c < clscol->size(); ++c) {
 
     // get the hits associated with this event
     std::vector<art::Ptr<recob::Hit>> hits = fmh.at(c);
 
     this->CheckReco(clockData, clscol->at(c).ID(), allhits, hits, fG4ClusterIDToPurityEfficiency);
 
   } // end loop over clusters
 
   return;
 }

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.

 {
   const sim::ParticleList& plist = fPI->ParticleList();
 
   // loop over all primaries in the plist and grab them and their daughters to put into
   // the set of track ids to pass on to the back tracker
   std::set<int> ids;
   for (const auto& PartPair : plist) {
     auto trackID = PartPair.first;
     if (!plist.IsPrimary(trackID)) continue;
     const simb::MCParticle& part = *(PartPair.second);
     ids.insert(trackID);
     for (int d = 0; d < part.NumberDaughters(); ++d)
       ids.insert(part.Daughter(d));
   } // end loop over primaries
 
   art::FindManyP<recob::Hit> fmh(evtcol, evt, label);
 
   auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
   for (size_t ev = 0; ev < evtcol->size(); ++ev) {
 
     // get the hits associated with this event
     std::vector<art::Ptr<recob::Hit>> hits = fmh.at(ev);
 
     // use the cheat::BackTrackerService to find purity and efficiency for these
     // hits
     double purity = fBT->HitCollectionPurity(clockData, ids, hits);
     double efficiency = fBT->HitCollectionEfficiency(clockData, ids, hits, allhits, geo::k3D);
 
     fEventPurity->Fill(purity);
     fEventEfficiency->Fill(efficiency);
     fEventPurityEfficiency->Fill(purity * efficiency);
 
   } // end loop over events
 
   return;
 }

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.

 {
   auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
   art::FindManyP<recob::Hit> fmh(scol, evt, label);
 
   for (size_t p = 0; p < scol->size(); ++p) {
 
     // get the hits associated with this event
     std::vector<art::Ptr<recob::Hit>> hits = fmh.at(p);
 
     this->CheckReco(clockData, scol->at(p).ID(), allhits, hits, fG4ShowerIDToPurityEfficiency);
 
   } // end loop over events
 
   return;
 }

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.

 {
   auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
   art::FindManyP<recob::Hit> fmh(tcol, evt, label);
 
   for (size_t p = 0; p < tcol->size(); ++p) {
 
     // get the hits associated with this event
     std::vector<art::Ptr<recob::Hit>> hits = fmh.at(p);
 
     this->CheckReco(clockData, tcol->at(p).ID(), allhits, hits, fG4TrackIDToPurityEfficiency);
 
   } // end loop over tracks
 
   return;
 }

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.

 {
   const sim::ParticleList& plist = fPI->ParticleList();
 
   std::vector<std::set<int>> ids(1);
   // loop over all primary particles and put their ids into the first set of the
   // vector.  add another set for each primary particle that also has daughters
   // and put those daughters into the new set
   // PartPair is a (track ID, particle pointer) pair
   for (const auto& PartPair : plist) {
     auto trackID = PartPair.first;
     if (!plist.IsPrimary(trackID)) continue;
     const simb::MCParticle& part = *(PartPair.second);
     ids[0].insert(trackID);
     if (part.NumberDaughters() > 0) {
       std::set<int> dv;
       for (int d = 0; d < part.NumberDaughters(); ++d)
         dv.insert(part.Daughter(d));
       ids.push_back(std::move(dv));
     } // end if this primary particle has daughters
   }   // end loop over primaries
 
   art::FindManyP<recob::Hit> fmh(vtxcol, evt, label);
 
   auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
 
   for (size_t v = 0; v < vtxcol->size(); ++v) {
 
     // get the hits associated with this event
     std::vector<art::Ptr<recob::Hit>> hits = fmh.at(v);
 
     double maxPurity = -1.;
     double maxEfficiency = -1.;
 
     for (size_t tv = 0; tv < ids.size(); ++tv) {
 
       // use the cheat::BackTrackerService to find purity and efficiency for
       // these hits
       double purity = fBT->HitCollectionPurity(clockData, ids[tv], hits);
       double efficiency = fBT->HitCollectionEfficiency(clockData, ids[tv], hits, allhits, geo::k3D);
 
       if (purity > maxPurity) maxPurity = purity;
       if (efficiency > maxEfficiency) maxEfficiency = efficiency;
     }
 
     fVertexPurity->Fill(maxPurity);
     fVertexEfficiency->Fill(maxEfficiency);
     fVertexPurityEfficiency->Fill(maxPurity * maxEfficiency);
 
   } // end loop over vertices
 
   return;
 }

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.

 {
   // map the g4 track id to energy deposited in a hit
   std::map<int, double> g4IDToHitEnergy;
   for (size_t h = 0; h < allhits.size(); ++h) {
     const std::vector<sim::TrackIDE> hitTrackIDs = fBT->HitToTrackIDEs(clockData, allhits[h]);
     for (size_t e = 0; e < hitTrackIDs.size(); ++e) {
       g4IDToHitEnergy[hitTrackIDs[e].trackID] += hitTrackIDs[e].energy;
     }
   } // end loop over hits to fill map
 
   // flatten the G4RecoBaseIDToPurityEfficiency maps to have just the g4ID as
   // the key and the rest of the information in vector form
   std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
     g4IDToClusterPurityEfficiency;
   std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
     g4IDToShowerPurityEfficiency;
   std::map<int, std::vector<std::pair<int, std::pair<double, double>>>> g4IDToTrackPurityEfficiency;
   std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>::iterator g4peItr;
 
   if (fCheckClusters)
     this->FlattenMap(fG4ClusterIDToPurityEfficiency,
                      g4IDToClusterPurityEfficiency,
                      fClusterPurity,
                      fClusterEfficiency,
                      fClusterPurityEfficiency,
                      fClusterPurityEfficiency2D);
   if (fCheckShowers)
     this->FlattenMap(fG4ShowerIDToPurityEfficiency,
                      g4IDToShowerPurityEfficiency,
                      fShowerPurity,
                      fShowerEfficiency,
                      fShowerPurityEfficiency,
                      fShowerPurityEfficiency2D);
   if (fCheckTracks)
     this->FlattenMap(fG4TrackIDToPurityEfficiency,
                      g4IDToTrackPurityEfficiency,
                      fTrackPurity,
                      fTrackEfficiency,
                      fTrackPurityEfficiency,
                      fTrackPurityEfficiency2D);
 
   // fill the tree vectors
   // get all the eveIDs from this event
   std::set<int> trackIDs = fBT->GetSetOfTrackIds();
   std::set<int>::const_iterator trackItr = trackIDs.begin();
 
   // loop over them
   while (trackItr != trackIDs.end()) {
 
     const simb::MCParticle* part = fPI->TrackIdToParticle_P(*trackItr);
 
     ftrackid = std::abs(*trackItr);
     fpdg = part->PdgCode();
     fpmom = part->P();
 
     // figure out how much of the energy deposited from this particle is stored in hits
     std::vector<const sim::IDE*> ides = fBT->TrackIdToSimIDEs_Ps(*trackItr);
     double totalDep = 0.;
     for (size_t i = 0; i < ides.size(); ++i)
       totalDep += ides[i]->energy;
 
     if (totalDep > 0.) fhiteff = g4IDToHitEnergy[*trackItr] / totalDep;
 
     std::vector<std::pair<int, std::pair<double, double>>> clVec;
     std::vector<std::pair<int, std::pair<double, double>>> shVec;
     std::vector<std::pair<int, std::pair<double, double>>> trVec;
 
     if (g4IDToClusterPurityEfficiency.find(*trackItr) != g4IDToClusterPurityEfficiency.end())
       clVec = g4IDToClusterPurityEfficiency.find(*trackItr)->second;
 
     if (g4IDToShowerPurityEfficiency.find(*trackItr) != g4IDToShowerPurityEfficiency.end())
       shVec = g4IDToShowerPurityEfficiency.find(*trackItr)->second;
 
     if (g4IDToTrackPurityEfficiency.find(*trackItr) != g4IDToTrackPurityEfficiency.end())
       trVec = g4IDToTrackPurityEfficiency.find(*trackItr)->second;
 
     fnclu = clVec.size();
     fnshw = shVec.size();
     fntrk = trVec.size();
 
     for (size_t c = 0; c < clVec.size(); ++c) {
       fcluid.push_back(clVec[c].first);
       fclupur.push_back(clVec[c].second.first);
       fclueff.push_back(clVec[c].second.second);
     }
 
     for (size_t s = 0; s < shVec.size(); ++s) {
       fshwid.push_back(shVec[s].first);
       fshwpur.push_back(shVec[s].second.first);
       fshweff.push_back(shVec[s].second.second);
     }
 
     for (size_t t = 0; t < trVec.size(); ++t) {
       ftrkid.push_back(trVec[t].first);
       ftrkpur.push_back(trVec[t].second.first);
       ftrkeff.push_back(trVec[t].second.second);
     }
 
     fTree->Fill();
 
     trackItr++;
   }
 
   // clean up for the next event
 
   // clear the maps of G4 track id to efficiency and purity for
   // various RecoBase objects
   fG4ClusterIDToPurityEfficiency.clear();
   fG4ShowerIDToPurityEfficiency.clear();
   fG4TrackIDToPurityEfficiency.clear();
 
   // clear the vectors hooked up to the tree
   fclueff.clear();
   fclupur.clear();
   fcluid.clear();
   ftrkeff.clear();
   ftrkpur.clear();
   ftrkid.clear();
   fshweff.clear();
   fshwpur.clear();
   fshwid.clear();
 
   return;
 }

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.

 {
 
   std::map<std::pair<int, int>, std::pair<double, double>>::const_iterator rbItr =
     g4RecoBaseIDToPurityEfficiency.begin();
 
   // map of key cluster ID to pair of purity, efficiency
   std::map<int, std::pair<double, double>> recoBIDToPurityEfficiency;
   std::map<int, std::pair<double, double>>::iterator rbpeItr;
 
   while (rbItr != g4RecoBaseIDToPurityEfficiency.end()) {
 
     // trackID, cluster ID
     std::pair<int, int> g4cl = rbItr->first;
     // purity, efficiency
     std::pair<double, double> pe = rbItr->second;
 
     // add the efficiency and purity values for clusters corresponding
     // to the current g4 id to the map
     // pair of cluster id, pair of purity, efficiency
     std::pair<int, std::pair<double, double>> clpe(g4cl.second, pe);
     // g4IDToRecoBasePurityEfficiency is a map with key of trackID of a vector of clusterIDs of pairs of purity and efficiency
     g4IDToRecoBasePurityEfficiency[g4cl.first].push_back(clpe);
 
     // now find the maximum purity to determine the purity and efficiency
     // for this RecoBase object
     rbpeItr = recoBIDToPurityEfficiency.find(g4cl.second);
     if (rbpeItr != recoBIDToPurityEfficiency.end()) {
       std::pair<double, double> curpe = rbpeItr->second;
       if (pe.first > curpe.first) recoBIDToPurityEfficiency[g4cl.second] = pe;
     }
     else
       recoBIDToPurityEfficiency[g4cl.second] = pe;
 
     rbItr++;
   }
 
   rbpeItr = recoBIDToPurityEfficiency.begin();
 
   // now fill the histograms,
   while (rbpeItr != recoBIDToPurityEfficiency.end()) {
     purity->Fill(rbpeItr->second.first);
     efficiency->Fill(rbpeItr->second.second);
     purityEfficiency->Fill(rbpeItr->second.first * rbpeItr->second.second);
     purityEfficiency2D->Fill(rbpeItr->second.first, rbpeItr->second.second);
     rbpeItr++;
   }
 
   return;
 }

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:

larsim/larsim/MCCheater/RecoCheckAna_module.cc

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation