Inheritance diagram for lar_pandora::PFParticleValidation:

Classes
class	MatchingDetails
	MatchingDetails class. More...

class	SimpleMatchedPfo
	SimpleMatchedPfo class. More...

class	SimpleMCPrimary
	SimpleMCPrimary class. More...

Public Member Functions
	PFParticleValidation (fhicl::ParameterSet const &pset)
	Constructor. More...

virtual	~PFParticleValidation ()
	Destructor. More...

void	beginJob ()

void	endJob ()

void	analyze (const art::Event &evt)

void	reconfigure (fhicl::ParameterSet const &pset)

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 Types
typedef std::vector< SimpleMCPrimary >	SimpleMCPrimaryList

typedef std::vector< SimpleMatchedPfo >	SimpleMatchedPfoList

typedef std::map< int, MatchingDetails >	MatchingDetailsMap

typedef std::map< SimpleMCPrimary, SimpleMatchedPfoList >	MCPrimaryMatchingMap

typedef std::map< art::Ptr< recob::PFParticle >, HitVector >	PFParticleToMatchedHits

typedef std::map< art::Ptr< simb::MCParticle >, PFParticleToMatchedHits >	MCParticleMatchingMap

typedef std::set< int >	IntSet

Private Member Functions
void	GetMCParticleMatchingMap (const PFParticlesToHits &recoParticlesToHits, const MCParticlesToHits &trueParticlesToHits, const HitsToMCParticles &hitsToTrueParticles, MCParticleMatchingMap &mcParticleMatchingMap) const
	Performing matching between true and reconstructed particles. More...

void	GetSimpleMCPrimaryList (const art::Event &evt, const MCParticlesToHits &mcParticlesToHits, const HitsToMCParticles &hitsToMCParticles, const MCParticleMatchingMap &mcParticleMatchingMap, SimpleMCPrimaryList &simpleMCPrimaryList) const
	Extract details of each mc primary (ordered by number of true hits) More...

void	GetMCPrimaryMatchingMap (const SimpleMCPrimaryList &simpleMCPrimaryList, const MCParticleMatchingMap &mcParticleMatchingMap, const PFParticlesToHits &pfParticlesToHits, MCPrimaryMatchingMap &mcPrimaryMatchingMap) const
	Obtain a sorted list of matched pfos for each mc primary. More...

bool	IsNeutrinoInduced (const art::Ptr< simb::MCParticle > pMCParticle, const MCParticlesToMCTruth &artMCParticlesToMCTruth) const
	Whether a mc particle is neutrino induced. More...

void	GetMCTruth (const art::Event &evt, MCTruthVector &mcTruthVector) const
	Obtain a vector of mc truth. More...

void	GetRecoNeutrinos (const art::Event &evt, PFParticleVector &recoNeutrinoVector) const
	Obtain a vector of reco neutrinos. More...

void	PrintAllOutput (const MCTruthVector &mcTruthVector, const PFParticleVector &recoNeutrinoVector, const MCPrimaryMatchingMap &mcPrimaryMatchingMap) const
	Print all the raw matching output to screen. More...

void	PerformMatching (const MCPrimaryMatchingMap &mcPrimaryMatchingMap, MatchingDetailsMap &matchingDetailsMap) const
	Apply a well-defined matching procedure to the comprehensive matches in the provided mc primary matching map. More...

bool	GetStrongestPfoMatch (const MCPrimaryMatchingMap &mcPrimaryMatchingMap, IntSet &usedMCIds, IntSet &usedPfoIds, MatchingDetailsMap &matchingDetailsMap) const
	Get the strongest pfo match (most matched hits) between an available mc primary and an available pfo. More...

void	GetRemainingPfoMatches (const MCPrimaryMatchingMap &mcPrimaryMatchingMap, const IntSet &usedPfoIds, MatchingDetailsMap &matchingDetailsMap) const
	Get the best matches for any pfos left-over after the strong matching procedure. More...

void	PrintMatchingOutput (const MCPrimaryMatchingMap &mcPrimaryMatchingMap, const MatchingDetailsMap &matchingDetailsMap) const
	Print the results of the matching procedure. More...

bool	IsGoodMCPrimary (const SimpleMCPrimary &simpleMCPrimary) const
	Whether a provided mc primary passes selection, based on number of "good" hits. More...

bool	HasMatch (const SimpleMCPrimary &simpleMCPrimary, const SimpleMatchedPfoList &simpleMatchedPfoList, const MatchingDetailsMap &matchingDetailsMap) const
	Whether a provided mc primary has a match, of any quality (use simple matched pfo list and information in matching details map) More...

bool	IsGoodMatch (const SimpleMCPrimary &simpleMCPrimary, const SimpleMatchedPfo &simpleMatchedPfo) const
	Whether a provided mc primary and pfo are deemed to be a good match. More...

unsigned int	CountHitsByType (const geo::View_t view, const HitVector &hitVector) const
	Count the number of hits, in a provided vector, of a specified view. More...

Static Private Member Functions
static bool	SortSimpleMCPrimaries (const SimpleMCPrimary &lhs, const SimpleMCPrimary &rhs)
	Sort simple mc primaries by number of mc hits. More...

static bool	SortSimpleMatchedPfos (const SimpleMatchedPfo &lhs, const SimpleMatchedPfo &rhs)
	Sort simple matched pfos by number of matched hits. More...

Private Attributes
std::string	m_hitfinderLabel
	The name/label of the hit producer module. More...

std::string	m_particleLabel
	The name/label of the particle producer module. More...

std::string	m_geantModuleLabel
	The name/label of the geant module. More...

std::string	m_backtrackerLabel
	The name/label of the back-tracker module. More...

bool	m_printAllToScreen
	Whether to print all/raw matching details to screen. More...

bool	m_printMatchingToScreen
	Whether to print matching output to screen. More...

bool	m_neutrinoInducedOnly
	Whether to consider only mc particles that were neutrino induced. More...

int	m_matchingMinPrimaryHits
	The minimum number of good mc primary hits used in matching scheme. More...

int	m_matchingMinHitsForGoodView
	The minimum number of good mc primary hits in given view to declare view to be good. More...

int	m_matchingMinPrimaryGoodViews
	The minimum number of good views for a mc primary. More...

bool	m_useSmallPrimaries
	Whether to consider matches to mc primaries with fewer than m_matchingMinPrimaryHits. More...

int	m_matchingMinSharedHits
	The minimum number of shared hits used in matching scheme. More...

float	m_matchingMinCompleteness
	The minimum particle completeness to declare a match. More...

float	m_matchingMinPurity
	The minimum particle purity to declare a match. 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

PFParticleValidation class.

Definition at line 24 of file PFParticleValidation_module.cc.

Member Typedef Documentation

typedef std::set<int> lar_pandora::PFParticleValidation::IntSet

private

Definition at line 204 of file PFParticleValidation_module.cc.

typedef std::map<int, MatchingDetails> lar_pandora::PFParticleValidation::MatchingDetailsMap

private

Definition at line 121 of file PFParticleValidation_module.cc.

typedef std::map< art::Ptr<simb::MCParticle>, PFParticleToMatchedHits > lar_pandora::PFParticleValidation::MCParticleMatchingMap

private

Definition at line 125 of file PFParticleValidation_module.cc.

typedef std::map<SimpleMCPrimary, SimpleMatchedPfoList> lar_pandora::PFParticleValidation::MCPrimaryMatchingMap

private

Definition at line 122 of file PFParticleValidation_module.cc.

typedef std::map< art::Ptr<recob::PFParticle>, HitVector > lar_pandora::PFParticleValidation::PFParticleToMatchedHits

private

Definition at line 124 of file PFParticleValidation_module.cc.

typedef std::vector<SimpleMatchedPfo> lar_pandora::PFParticleValidation::SimpleMatchedPfoList

private

Definition at line 103 of file PFParticleValidation_module.cc.

typedef std::vector<SimpleMCPrimary> lar_pandora::PFParticleValidation::SimpleMCPrimaryList

private

Definition at line 76 of file PFParticleValidation_module.cc.

Constructor & Destructor Documentation

lar_pandora::PFParticleValidation::PFParticleValidation ( fhicl::ParameterSet const & pset )

Constructor.

Parameters

pset

Definition at line 336 of file PFParticleValidation_module.cc.

                                                                         :
     art::EDAnalyzer(pset)
 {
     this->reconfigure(pset);
 }

lar_pandora::PFParticleValidation::~PFParticleValidation ( )

virtual

Destructor.

Definition at line 344 of file PFParticleValidation_module.cc.

345 {

346 }

Member Function Documentation

void lar_pandora::PFParticleValidation::analyze ( const art::Event & evt )

Definition at line 382 of file PFParticleValidation_module.cc.

 {
     HitVector hitVector;
     LArPandoraHelper::CollectHits(evt, m_hitfinderLabel, hitVector);
 
     PFParticlesToHits pfParticlesToHits;
     HitsToPFParticles hitsToPfParticles;
     LArPandoraHelper::BuildPFParticleHitMaps(evt, m_particleLabel, pfParticlesToHits, hitsToPfParticles, LArPandoraHelper::kAddDaughters);
 
     MCParticlesToHits mcParticlesToHits;
     HitsToMCParticles hitsToMCParticles;
 
     LArPandoraHelper::BuildMCParticleHitMaps(evt, m_geantModuleLabel, hitVector,
         mcParticlesToHits, hitsToMCParticles, LArPandoraHelper::kAddDaughters);
 
     if (hitsToMCParticles.empty())
     {
         if (m_backtrackerLabel.empty())
             throw cet::exception("LArPandora") << " PFParticleValidation::analyze - no sim channels found, backtracker module must be set in FHiCL " << std::endl;
 
         LArPandoraHelper::BuildMCParticleHitMaps(evt, m_geantModuleLabel, m_hitfinderLabel, m_backtrackerLabel,
             mcParticlesToHits, hitsToMCParticles, LArPandoraHelper::kAddDaughters);
     }
 
     MCParticleMatchingMap mcParticleMatchingMap;
     this->GetMCParticleMatchingMap(pfParticlesToHits, mcParticlesToHits, hitsToMCParticles, mcParticleMatchingMap);
 
     SimpleMCPrimaryList simpleMCPrimaryList;
     this->GetSimpleMCPrimaryList(evt, mcParticlesToHits, hitsToMCParticles, mcParticleMatchingMap, simpleMCPrimaryList);
 
     MCPrimaryMatchingMap mcPrimaryMatchingMap;
     this->GetMCPrimaryMatchingMap(simpleMCPrimaryList, mcParticleMatchingMap, pfParticlesToHits, mcPrimaryMatchingMap);
 
     MCTruthVector mcTruthVector;
     this->GetMCTruth(evt, mcTruthVector);
 
     PFParticleVector recoNeutrinoVector;
     this->GetRecoNeutrinos(evt, recoNeutrinoVector);
 
     if (m_printAllToScreen)
         this->PrintAllOutput(mcTruthVector, recoNeutrinoVector, mcPrimaryMatchingMap);
 
     if (m_printMatchingToScreen)
     {
         MatchingDetailsMap matchingDetailsMap;
         this->PerformMatching(mcPrimaryMatchingMap, matchingDetailsMap);
         this->PrintMatchingOutput(mcPrimaryMatchingMap, matchingDetailsMap);
     }
 }

void lar_pandora::PFParticleValidation::beginJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 370 of file PFParticleValidation_module.cc.

371 {

372 }

unsigned int lar_pandora::PFParticleValidation::CountHitsByType	(	const geo::View_t	view,
		const HitVector &	hitVector
	)		const

private

Count the number of hits, in a provided vector, of a specified view.

Parameters

view	the view
hitVector	the hit vector

Returns: the number of hits of the specified view

Definition at line 857 of file PFParticleValidation_module.cc.

 {
     unsigned int nHitsOfSpecifiedType(0);
 
     for (const art::Ptr<recob::Hit> pHit : hitVector)
     {
         if (view == pHit->View())
             ++nHitsOfSpecifiedType;
     }
 
     return nHitsOfSpecifiedType;
 }

void lar_pandora::PFParticleValidation::endJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 376 of file PFParticleValidation_module.cc.

377 {

378 }

void lar_pandora::PFParticleValidation::GetMCParticleMatchingMap	(	const PFParticlesToHits &	recoParticlesToHits,
		const MCParticlesToHits &	trueParticlesToHits,
		const HitsToMCParticles &	hitsToTrueParticles,
		MCParticleMatchingMap &	mcParticleMatchingMap
	)		const

private

Performing matching between true and reconstructed particles.

Parameters

recoParticlesToHits	the mapping from reconstructed particles to hits
trueParticlesToHits	the mapping from true particles to hits
hitsToTrueParticles	the mapping from hits to true particles
mcParticleMatchingMap	the output matches between all reconstructed and true particles

Definition at line 434 of file PFParticleValidation_module.cc.

 {
     // Create a placeholder entry for all mc particles with >0 hits
     for (const MCParticlesToHits::value_type &mcParticleToHitsEntry : mcParticlesToHits)
     {
         if (!mcParticleToHitsEntry.second.empty())
             (void) mcParticleMatchingMap.insert(MCParticleMatchingMap::value_type(mcParticleToHitsEntry.first, PFParticleToMatchedHits()));
     }
 
     // Store true to reco matching details
     for (const PFParticlesToHits::value_type &recoParticleToHits : pfParticlesToHits)
     {
         const art::Ptr<recob::PFParticle> pRecoParticle(recoParticleToHits.first);
         const HitVector &hitVector(recoParticleToHits.second);
 
         for (const art::Ptr<recob::Hit> pHit : hitVector)
         {
             HitsToMCParticles::const_iterator mcParticleIter = hitsToMCParticles.find(pHit);
 
             if (hitsToMCParticles.end() == mcParticleIter)
                 continue;
 
             const art::Ptr<simb::MCParticle> pTrueParticle = mcParticleIter->second;
             mcParticleMatchingMap[pTrueParticle][pRecoParticle].push_back(pHit);
         }
     }
 }

void lar_pandora::PFParticleValidation::GetMCPrimaryMatchingMap	(	const SimpleMCPrimaryList &	simpleMCPrimaryList,
		const MCParticleMatchingMap &	mcParticleMatchingMap,
		const PFParticlesToHits &	pfParticlesToHits,
		MCPrimaryMatchingMap &	mcPrimaryMatchingMap
	)		const

private

Obtain a sorted list of matched pfos for each mc primary.

Parameters

simpleMCPrimaryList	the simple mc primary list
mcToFullPfoMatchingMap	the mc to full pfo matching map
pfoToHitListMap	the pfo to hit list map
mcPrimaryMatchingMap	to receive the populated mc primary matching map

Definition at line 526 of file PFParticleValidation_module.cc.

 {
     for (const SimpleMCPrimary &simpleMCPrimary : simpleMCPrimaryList)
     {
         SimpleMatchedPfoList simpleMatchedPfoList;
         MCParticleMatchingMap::const_iterator matchedPfoIter = mcParticleMatchingMap.end();
 
         // ATTN Nasty workaround I
         for (MCParticleMatchingMap::const_iterator iter = mcParticleMatchingMap.begin(), iterEnd = mcParticleMatchingMap.end(); iter != iterEnd; ++iter)
         {
             if (simpleMCPrimary.m_pAddress == iter->first.get())
             {
                 matchedPfoIter = iter;
                 break;
             };
         }
 
         if (mcParticleMatchingMap.end() != matchedPfoIter)
         {
             for (const PFParticleToMatchedHits::value_type &contribution : matchedPfoIter->second)
             {
                 const art::Ptr<recob::PFParticle> pMatchedPfo(contribution.first);
                 const HitVector &matchedHitVector(contribution.second);
 
                 SimpleMatchedPfo simpleMatchedPfo;
                 simpleMatchedPfo.m_pAddress = pMatchedPfo.get();
                 simpleMatchedPfo.m_id = pMatchedPfo->Self();
 
                 // ATTN Assume pfos have either zero or one parents. Ignore parent neutrino.
                 PFParticlesToHits::const_iterator parentPfoIter = pfParticlesToHits.end();
 
                 // ATTN Nasty workaround II, bad place for another loop.
                 for (PFParticlesToHits::const_iterator iter = pfParticlesToHits.begin(), iterEnd = pfParticlesToHits.end(); iter != iterEnd; ++iter)
                 {
                     if (pMatchedPfo->Parent() == iter->first->Self())
                     {
                         parentPfoIter = iter;
                         break;
                     };
                 }
 
                 if ((pfParticlesToHits.end() != parentPfoIter) && !LArPandoraHelper::IsNeutrino(parentPfoIter->first))
                     simpleMatchedPfo.m_parentId = parentPfoIter->first->Self();
 
                 simpleMatchedPfo.m_pdgCode = pMatchedPfo->PdgCode();
                 simpleMatchedPfo.m_nMatchedHitsTotal = matchedHitVector.size();
                 simpleMatchedPfo.m_nMatchedHitsU = this->CountHitsByType(geo::kU, matchedHitVector);
                 simpleMatchedPfo.m_nMatchedHitsV = this->CountHitsByType(geo::kV, matchedHitVector);
                 simpleMatchedPfo.m_nMatchedHitsW = this->CountHitsByType(geo::kW, matchedHitVector);
 
                 PFParticlesToHits::const_iterator pfoHitsIter = pfParticlesToHits.find(pMatchedPfo);
 
                 if (pfParticlesToHits.end() == pfoHitsIter)
                     throw cet::exception("LArPandora") << " PFParticleValidation::analyze --- Presence of PFParticle in map mandatory.";
 
                 const HitVector &pfoHitVector(pfoHitsIter->second);
 
                 simpleMatchedPfo.m_nPfoHitsTotal = pfoHitVector.size();
                 simpleMatchedPfo.m_nPfoHitsU = this->CountHitsByType(geo::kU, pfoHitVector);
                 simpleMatchedPfo.m_nPfoHitsV = this->CountHitsByType(geo::kV, pfoHitVector);
                 simpleMatchedPfo.m_nPfoHitsW = this->CountHitsByType(geo::kW, pfoHitVector);
 
                 simpleMatchedPfoList.push_back(simpleMatchedPfo);
             }
         }
 
         // Store the ordered vectors of matched pfo details
         std::sort(simpleMatchedPfoList.begin(), simpleMatchedPfoList.end(), PFParticleValidation::SortSimpleMatchedPfos);
 
         if (!mcPrimaryMatchingMap.insert(MCPrimaryMatchingMap::value_type(simpleMCPrimary, simpleMatchedPfoList)).second)
             throw cet::exception("LArPandora") << " PFParticleValidation::analyze --- Double-counting MC primaries.";
     }
 }

void lar_pandora::PFParticleValidation::GetMCTruth	(	const art::Event &	evt,
		MCTruthVector &	mcTruthVector
	)		const

private

Obtain a vector of mc truth.

Parameters

evt	the event
mcNeutrinoVector	to receive the populated vector of mc truth

Definition at line 603 of file PFParticleValidation_module.cc.

 {
     MCTruthToMCParticles artMCTruthToMCParticles;
     MCParticlesToMCTruth artMCParticlesToMCTruth;
     LArPandoraHelper::CollectMCParticles(evt, m_geantModuleLabel, artMCTruthToMCParticles, artMCParticlesToMCTruth);
 
     for (const auto &mapEntry : artMCTruthToMCParticles)
     {
         const art::Ptr<simb::MCTruth> truth = mapEntry.first;
 
         if (!truth->NeutrinoSet())
             continue;
 
         if (mcTruthVector.end() == std::find(mcTruthVector.begin(), mcTruthVector.end(), truth))
             mcTruthVector.push_back(truth);
     }
 }

void lar_pandora::PFParticleValidation::GetRecoNeutrinos	(	const art::Event &	evt,
		PFParticleVector &	recoNeutrinoVector
	)		const

private

Obtain a vector of reco neutrinos.

Parameters

evt	the event
recoNeutrinoVector	to receive the populated vector of reco neutrinos

Definition at line 623 of file PFParticleValidation_module.cc.

 {
     PFParticleVector allPFParticles;
     LArPandoraHelper::CollectPFParticles(evt, m_particleLabel, allPFParticles);
     LArPandoraHelper::SelectNeutrinoPFParticles(allPFParticles, recoNeutrinoVector);
 }

void lar_pandora::PFParticleValidation::GetRemainingPfoMatches	(	const MCPrimaryMatchingMap &	mcPrimaryMatchingMap,
		const IntSet &	usedPfoIds,
		MatchingDetailsMap &	matchingDetailsMap
	)		const

private

Get the best matches for any pfos left-over after the strong matching procedure.

Parameters

mcPrimaryMatchingMap	the input/raw mc primary matching map
usedPfoIds	the list of pfo ids with an existing match
matchingDetailsMap	the matching details map, to be populated

Definition at line 732 of file PFParticleValidation_module.cc.

 {
     for (const MCPrimaryMatchingMap::value_type &mapValue : mcPrimaryMatchingMap)
     {
         const SimpleMCPrimary &simpleMCPrimary(mapValue.first);
 
         if (!m_useSmallPrimaries && !this->IsGoodMCPrimary(simpleMCPrimary))
             continue;
 
         for (const SimpleMatchedPfo &simpleMatchedPfo : mapValue.second)
         {
             if (usedPfoIds.count(simpleMatchedPfo.m_id))
                 continue;
 
             MatchingDetails &matchingDetails(matchingDetailsMap[simpleMatchedPfo.m_id]);
 
             if (simpleMatchedPfo.m_nMatchedHitsTotal > matchingDetails.m_nMatchedHits)
             {
                 matchingDetails.m_matchedPrimaryId = simpleMCPrimary.m_id;
                 matchingDetails.m_nMatchedHits = simpleMatchedPfo.m_nMatchedHitsTotal;
                 matchingDetails.m_completeness = static_cast<float>(simpleMatchedPfo.m_nMatchedHitsTotal) / static_cast<float>(simpleMCPrimary.m_nMCHitsTotal);
             }
         }
     }
 }

void lar_pandora::PFParticleValidation::GetSimpleMCPrimaryList	(	const art::Event &	evt,
		const MCParticlesToHits &	mcParticlesToHits,
		const HitsToMCParticles &	hitsToMCParticles,
		const MCParticleMatchingMap &	mcParticleMatchingMap,
		SimpleMCPrimaryList &	simpleMCPrimaryList
	)		const

private

Extract details of each mc primary (ordered by number of true hits)

Parameters

evt	the event
mcParticlesToHits	the mc primary to hits map
hitsToMCParticles	the hits to mc particles map
mcParticleMatchingMap	the mc to particle to pf particle matching map (to record number of matched pf particles)
simpleMCPrimaryList	to receive the populated simple mc primary list

Definition at line 465 of file PFParticleValidation_module.cc.

 {
     MCTruthToMCParticles artMCTruthToMCParticles;
     MCParticlesToMCTruth artMCParticlesToMCTruth;
     LArPandoraHelper::CollectMCParticles(evt, m_geantModuleLabel, artMCTruthToMCParticles, artMCParticlesToMCTruth);
 
     for (const MCParticlesToHits::value_type &mapEntry : mcParticlesToHits)
     {
         const art::Ptr<simb::MCParticle> pMCPrimary(mapEntry.first);
 
         if (m_neutrinoInducedOnly && !this->IsNeutrinoInduced(pMCPrimary, artMCParticlesToMCTruth))
             continue;
 
         SimpleMCPrimary simpleMCPrimary;
         // ATTN simpleMCPrimary.m_id assigned later, after sorting
         simpleMCPrimary.m_pAddress = pMCPrimary.get();
         simpleMCPrimary.m_pdgCode = pMCPrimary->PdgCode();
         simpleMCPrimary.m_energy = pMCPrimary->E();
 
         MCParticlesToHits::const_iterator trueHitsIter = mcParticlesToHits.find(pMCPrimary);
 
         if (mcParticlesToHits.end() != trueHitsIter)
         {
             const HitVector &hitVector(trueHitsIter->second);
             simpleMCPrimary.m_nMCHitsTotal = hitVector.size();
             simpleMCPrimary.m_nMCHitsU = this->CountHitsByType(geo::kU, hitVector);
             simpleMCPrimary.m_nMCHitsV = this->CountHitsByType(geo::kV, hitVector);
             simpleMCPrimary.m_nMCHitsW = this->CountHitsByType(geo::kW, hitVector);
         }
 
         MCParticleMatchingMap::const_iterator matchedPfoIter = mcParticleMatchingMap.find(pMCPrimary);
 
         if (mcParticleMatchingMap.end() != matchedPfoIter)
             simpleMCPrimary.m_nMatchedPfos = matchedPfoIter->second.size();
 
         simpleMCPrimaryList.push_back(simpleMCPrimary);
     }
 
     std::sort(simpleMCPrimaryList.begin(), simpleMCPrimaryList.end(), PFParticleValidation::SortSimpleMCPrimaries);
 
     int mcPrimaryId(0);
     for (SimpleMCPrimary &simpleMCPrimary : simpleMCPrimaryList)
         simpleMCPrimary.m_id = mcPrimaryId++;
 }

bool lar_pandora::PFParticleValidation::GetStrongestPfoMatch	(	const MCPrimaryMatchingMap &	mcPrimaryMatchingMap,
		IntSet &	usedMCIds,
		IntSet &	usedPfoIds,
		MatchingDetailsMap &	matchingDetailsMap
	)		const

private

Get the strongest pfo match (most matched hits) between an available mc primary and an available pfo.

Parameters

mcPrimaryMatchingMap	the input/raw mc primary matching map
usedMCIds	the list of mc primary ids with an existing match
usedPfoIds	the list of pfo ids with an existing match
matchingDetailsMap	the matching details map, to be populated

Definition at line 685 of file PFParticleValidation_module.cc.

 {
     int bestPfoMatchId(-1);
     MatchingDetails bestMatchingDetails;
 
     for (const MCPrimaryMatchingMap::value_type &mapValue : mcPrimaryMatchingMap)
     {
         const SimpleMCPrimary &simpleMCPrimary(mapValue.first);
 
         if (!m_useSmallPrimaries && !this->IsGoodMCPrimary(simpleMCPrimary))
             continue;
 
         if (usedMCIds.count(simpleMCPrimary.m_id))
             continue;
 
         for (const SimpleMatchedPfo &simpleMatchedPfo : mapValue.second)
         {
             if (usedPfoIds.count(simpleMatchedPfo.m_id))
                 continue;
 
             if (!this->IsGoodMatch(simpleMCPrimary, simpleMatchedPfo))
                 continue;
 
             if (simpleMatchedPfo.m_nMatchedHitsTotal > bestMatchingDetails.m_nMatchedHits)
             {
                 bestPfoMatchId = simpleMatchedPfo.m_id;
                 bestMatchingDetails.m_matchedPrimaryId = simpleMCPrimary.m_id;
                 bestMatchingDetails.m_nMatchedHits = simpleMatchedPfo.m_nMatchedHitsTotal;
                 bestMatchingDetails.m_completeness = static_cast<float>(simpleMatchedPfo.m_nMatchedHitsTotal) / static_cast<float>(simpleMCPrimary.m_nMCHitsTotal);
             }
         }
     }
 
     if (bestPfoMatchId > -1)
     {
         matchingDetailsMap[bestPfoMatchId] = bestMatchingDetails;
         usedMCIds.insert(bestMatchingDetails.m_matchedPrimaryId);
         usedPfoIds.insert(bestPfoMatchId);
         return true;
     }
 
     return false;
 }

bool lar_pandora::PFParticleValidation::HasMatch	(	const SimpleMCPrimary &	simpleMCPrimary,
		const SimpleMatchedPfoList &	simpleMatchedPfoList,
		const MatchingDetailsMap &	matchingDetailsMap
	)		const

private

Whether a provided mc primary has a match, of any quality (use simple matched pfo list and information in matching details map)

Parameters

simpleMCPrimary	the simple mc primary
simpleMatchedPfoList	the list of simple matched pfos
matchingDetailsMap	the matching details map

Returns: boolean

Definition at line 833 of file PFParticleValidation_module.cc.

 {
     for (const SimpleMatchedPfo &simpleMatchedPfo : simpleMatchedPfoList)
     {
         if (matchingDetailsMap.count(simpleMatchedPfo.m_id) && (simpleMCPrimary.m_id == matchingDetailsMap.at(simpleMatchedPfo.m_id).m_matchedPrimaryId))
             return true;
     }
 
     return false;
 }

bool lar_pandora::PFParticleValidation::IsGoodMatch	(	const SimpleMCPrimary &	simpleMCPrimary,
		const SimpleMatchedPfo &	simpleMatchedPfo
	)		const

private

Whether a provided mc primary and pfo are deemed to be a good match.

Parameters

simpleMCPrimary	the simple mc primary
simpleMatchedPfo	the simple matched pfo

Returns: boolean

Definition at line 847 of file PFParticleValidation_module.cc.

 {
     const float purity((simpleMatchedPfo.m_nPfoHitsTotal > 0) ? static_cast<float>(simpleMatchedPfo.m_nMatchedHitsTotal) / static_cast<float>(simpleMatchedPfo.m_nPfoHitsTotal) : 0.f);
     const float completeness((simpleMCPrimary.m_nMCHitsTotal > 0) ? static_cast<float>(simpleMatchedPfo.m_nMatchedHitsTotal) / static_cast<float>(simpleMCPrimary.m_nMCHitsTotal) : 0.f);
 
     return ((simpleMatchedPfo.m_nMatchedHitsTotal >= m_matchingMinSharedHits) && (purity >= m_matchingMinPurity) && (completeness >= m_matchingMinCompleteness));
 }

bool lar_pandora::PFParticleValidation::IsGoodMCPrimary ( const SimpleMCPrimary & simpleMCPrimary ) const

private

Whether a provided mc primary passes selection, based on number of "good" hits.

Parameters

simpleMCPrimary the simple mc primary

Returns: boolean

Definition at line 815 of file PFParticleValidation_module.cc.

 {
     if (simpleMCPrimary.m_nMCHitsTotal < m_matchingMinPrimaryHits)
         return false;
 
     int nGoodViews(0);
     if (simpleMCPrimary.m_nMCHitsU >= m_matchingMinHitsForGoodView) ++nGoodViews;
     if (simpleMCPrimary.m_nMCHitsV >= m_matchingMinHitsForGoodView) ++nGoodViews;
     if (simpleMCPrimary.m_nMCHitsW >= m_matchingMinHitsForGoodView) ++nGoodViews;
 
     if (nGoodViews < m_matchingMinPrimaryGoodViews)
         return false;
 
     return true;
 }

bool lar_pandora::PFParticleValidation::IsNeutrinoInduced	(	const art::Ptr< simb::MCParticle >	pMCParticle,
		const MCParticlesToMCTruth &	artMCParticlesToMCTruth
	)		const

private

Whether a mc particle is neutrino induced.

Parameters

pMCParticle	address of the mc particle
artMCParticlesToMCTruth	the mapping from mc particles to mc truth

Returns: boolean

Definition at line 513 of file PFParticleValidation_module.cc.

 {
     MCParticlesToMCTruth::const_iterator iter = artMCParticlesToMCTruth.find(pMCParticle);
 
     if (artMCParticlesToMCTruth.end() == iter)
         return false;
 
     const art::Ptr<simb::MCTruth> pMCTruth = iter->second;
     return (simb::kBeamNeutrino == pMCTruth->Origin());
 }

void lar_pandora::PFParticleValidation::PerformMatching	(	const MCPrimaryMatchingMap &	mcPrimaryMatchingMap,
		MatchingDetailsMap &	matchingDetailsMap
	)		const

private

Apply a well-defined matching procedure to the comprehensive matches in the provided mc primary matching map.

Parameters

mcPrimaryMatchingMap	the input/raw mc primary matching map
matchingDetailsMap	the matching details map, to be populated

Definition at line 673 of file PFParticleValidation_module.cc.

 {
     // Get best matches, one-by-one, until no more strong matches possible
     IntSet usedMCIds, usedPfoIds;
     while (GetStrongestPfoMatch(mcPrimaryMatchingMap, usedMCIds, usedPfoIds, matchingDetailsMap)) {}
 
     // Assign any remaining pfos to primaries, based on number of matched hits
     GetRemainingPfoMatches(mcPrimaryMatchingMap, usedPfoIds, matchingDetailsMap);
 }

void lar_pandora::PFParticleValidation::PrintAllOutput	(	const MCTruthVector &	mcTruthVector,
		const PFParticleVector &	recoNeutrinoVector,
		const MCPrimaryMatchingMap &	mcPrimaryMatchingMap
	)		const

private

Print all the raw matching output to screen.

Parameters

mcTruthVector	the mc truth vector
recoNeutrinoVector	the reco neutrino vector
mcPrimaryMatchingMap	the input/raw mc primary matching map

Definition at line 632 of file PFParticleValidation_module.cc.

 {
     std::cout << "---RAW-MATCHING-OUTPUT--------------------------------------------------------------------------" << std::endl;
 
     for (const art::Ptr<simb::MCTruth> pMCTruth : mcTruthVector)
     {
         std::cout << "MCNeutrino, PDG " << pMCTruth->GetNeutrino().Nu().PdgCode() << ", InteractionType " << pMCTruth->GetNeutrino().InteractionType() << std::endl;
     }
 
     for (const art::Ptr<recob::PFParticle> pPfo : recoNeutrinoVector)
     {
         std::cout << "RecoNeutrino, PDG " << pPfo->PdgCode() << ", nDaughters " << pPfo->NumDaughters() << std::endl;
     }
 
     for (const MCPrimaryMatchingMap::value_type &mapValue : mcPrimaryMatchingMap)
     {
         const SimpleMCPrimary &simpleMCPrimary(mapValue.first);
 
         std::cout << std::endl << "Primary " << simpleMCPrimary.m_id << ", PDG " << simpleMCPrimary.m_pdgCode << ", nMCHits " << simpleMCPrimary.m_nMCHitsTotal
             << " (" << simpleMCPrimary.m_nMCHitsU << ", " << simpleMCPrimary.m_nMCHitsV << ", " << simpleMCPrimary.m_nMCHitsW << ")" << std::endl;
 
         for (const SimpleMatchedPfo &simpleMatchedPfo : mapValue.second)
         {
             std::cout << "-MatchedPfo " << simpleMatchedPfo.m_id;
 
             if (simpleMatchedPfo.m_parentId >= 0)
                 std::cout << ", ParentPfo " << simpleMatchedPfo.m_parentId;
 
             std::cout << ", PDG " << simpleMatchedPfo.m_pdgCode << ", nMatchedHits " << simpleMatchedPfo.m_nMatchedHitsTotal
                 << " (" << simpleMatchedPfo.m_nMatchedHitsU << ", " << simpleMatchedPfo.m_nMatchedHitsV << ", " << simpleMatchedPfo.m_nMatchedHitsW << ")"
                 << ", nPfoHits " << simpleMatchedPfo.m_nPfoHitsTotal << " (" << simpleMatchedPfo.m_nPfoHitsU << ", " << simpleMatchedPfo.m_nPfoHitsV << ", "
                 << simpleMatchedPfo.m_nPfoHitsW << ")" << std::endl;
         }
     }
 
     std::cout << "------------------------------------------------------------------------------------------------" << std::endl;
 }

void lar_pandora::PFParticleValidation::PrintMatchingOutput	(	const MCPrimaryMatchingMap &	mcPrimaryMatchingMap,
		const MatchingDetailsMap &	matchingDetailsMap
	)		const

private

Print the results of the matching procedure.

Parameters

mcPrimaryMatchingMap	the input/raw mc primary matching map
matchingDetailsMap	the matching details map

Definition at line 761 of file PFParticleValidation_module.cc.

 {
     std::cout << "---PROCESSED-MATCHING-OUTPUT--------------------------------------------------------------------" << std::endl;
     std::cout << "MinPrimaryGoodHits " << m_matchingMinPrimaryHits << ", MinHitsForGoodView " << m_matchingMinHitsForGoodView << ", MinPrimaryGoodViews " << m_matchingMinPrimaryGoodViews << std::endl;
     std::cout << "UseSmallPrimaries " << m_useSmallPrimaries << ", MinSharedHits " << m_matchingMinSharedHits << ", MinCompleteness " << m_matchingMinCompleteness << ", MinPurity " << m_matchingMinPurity << std::endl;
 
     bool isCorrect(true), isCalculable(false);
 
     for (const MCPrimaryMatchingMap::value_type &mapValue : mcPrimaryMatchingMap)
     {
         const SimpleMCPrimary &simpleMCPrimary(mapValue.first);
         const bool hasMatch(this->HasMatch(simpleMCPrimary, mapValue.second, matchingDetailsMap));
         const bool isTargetPrimary(this->IsGoodMCPrimary(simpleMCPrimary) && (2112 != simpleMCPrimary.m_pdgCode));
 
         if (!hasMatch && !isTargetPrimary)
             continue;
 
         std::cout << std::endl << (!isTargetPrimary ? "(Non target) " : "")
                   << "Primary " << simpleMCPrimary.m_id << ", PDG " << simpleMCPrimary.m_pdgCode << ", nMCHits " << simpleMCPrimary.m_nMCHitsTotal
                   << " (" << simpleMCPrimary.m_nMCHitsU << ", " << simpleMCPrimary.m_nMCHitsV << ", " << simpleMCPrimary.m_nMCHitsW << ")" << std::endl;
 
         if (2112 != simpleMCPrimary.m_pdgCode)
             isCalculable = true;
 
         unsigned int nMatches(0);
 
         for (const SimpleMatchedPfo &simpleMatchedPfo : mapValue.second)
         {
             if (matchingDetailsMap.count(simpleMatchedPfo.m_id) && (simpleMCPrimary.m_id == matchingDetailsMap.at(simpleMatchedPfo.m_id).m_matchedPrimaryId))
             {
                 const bool isGoodMatch(this->IsGoodMatch(simpleMCPrimary, simpleMatchedPfo));
 
                 if (isGoodMatch) ++nMatches;
                 std::cout << "-" << (!isGoodMatch ? "(Below threshold) " : "") << "MatchedPfo " << simpleMatchedPfo.m_id;
 
                 if (simpleMatchedPfo.m_parentId >= 0) std::cout << ", ParentPfo " << simpleMatchedPfo.m_parentId;
 
                 std::cout << ", PDG " << simpleMatchedPfo.m_pdgCode << ", nMatchedHits " << simpleMatchedPfo.m_nMatchedHitsTotal
                           << " (" << simpleMatchedPfo.m_nMatchedHitsU << ", " << simpleMatchedPfo.m_nMatchedHitsV << ", " << simpleMatchedPfo.m_nMatchedHitsW << ")"
                           << ", nPfoHits " << simpleMatchedPfo.m_nPfoHitsTotal
                           << " (" << simpleMatchedPfo.m_nPfoHitsU << ", " << simpleMatchedPfo.m_nPfoHitsV << ", " << simpleMatchedPfo.m_nPfoHitsW << ")" << std::endl;
             }
         }
 
         if (isTargetPrimary && (1 != nMatches))
             isCorrect = false;
     }
 
     std::cout << std::endl << "Is correct? " << (isCorrect && isCalculable) << std::endl;
     std::cout << "------------------------------------------------------------------------------------------------" << std::endl;
 }

void lar_pandora::PFParticleValidation::reconfigure ( fhicl::ParameterSet const & pset )

Definition at line 350 of file PFParticleValidation_module.cc.

 {
     m_particleLabel = pset.get<std::string>("PFParticleModule", "pandoraNu");
     m_hitfinderLabel = pset.get<std::string>("HitFinderModule", "gaushit");
     m_geantModuleLabel = pset.get<std::string>("GeantModule","largeant");
     m_backtrackerLabel = pset.get<std::string>("BackTrackerModule","gaushitTruthMatch");
     m_printAllToScreen = pset.get<bool>("PrintAllToScreen", true);
     m_printMatchingToScreen = pset.get<bool>("PrintMatchingToScreen", true);
     m_neutrinoInducedOnly = pset.get<bool>("NeutrinoInducedOnly", true);
     m_matchingMinPrimaryHits = pset.get<int>("MatchingMinPrimaryHits", 15);
     m_matchingMinHitsForGoodView = pset.get<int>("MatchingMinHitsForGoodView", 5);
     m_matchingMinPrimaryGoodViews = pset.get<int>("MatchingMinPrimaryGoodViews", 2);
     m_useSmallPrimaries = pset.get<bool>("UseSmallPrimaries", true);
     m_matchingMinSharedHits = pset.get<int>("MatchingMinSharedHits", 5);
     m_matchingMinCompleteness = pset.get<float>("MatchingMinCompleteness", 0.1f);
     m_matchingMinPurity = pset.get<float>("MatchingMinPurity", 0.5f);
 }

bool lar_pandora::PFParticleValidation::SortSimpleMatchedPfos	(	const SimpleMatchedPfo &	lhs,
		const SimpleMatchedPfo &	rhs
	)

staticprivate

Sort simple matched pfos by number of matched hits.

Parameters

lhs	the left-hand side
rhs	the right-hand side

Returns: boolean

Definition at line 882 of file PFParticleValidation_module.cc.

 {
     if (lhs.m_nMatchedHitsTotal != rhs.m_nMatchedHitsTotal)
         return (lhs.m_nMatchedHitsTotal > rhs.m_nMatchedHitsTotal);
 
     if (lhs.m_nPfoHitsTotal != rhs.m_nPfoHitsTotal)
         return (lhs.m_nPfoHitsTotal > rhs.m_nPfoHitsTotal);
 
     return (lhs.m_id < rhs.m_id);
 }

bool lar_pandora::PFParticleValidation::SortSimpleMCPrimaries	(	const SimpleMCPrimary &	lhs,
		const SimpleMCPrimary &	rhs
	)

staticprivate

Sort simple mc primaries by number of mc hits.

Parameters

lhs	the left-hand side
rhs	the right-hand side

Returns: boolean

Definition at line 872 of file PFParticleValidation_module.cc.

 {
     if (lhs.m_nMCHitsTotal != rhs.m_nMCHitsTotal)
         return (lhs.m_nMCHitsTotal > rhs.m_nMCHitsTotal);
 
     return (lhs.m_energy > rhs.m_energy);
 }