Obtains truth matching by using hit <–> MCParticle associations. More...

#include <MCTruthAssociations.h>

Classes
struct	HitPartAssnsStruct

Public Member Functions
	MCTruthAssociations (fhicl::ParameterSet const &config)

void	setup (const HitParticleAssociationsVec &, const MCParticleVec &, const MCTruthAssns &, const geo::GeometryCore &)

const MCTruthParticleList &	getParticleList () const

const simb::MCParticle *	TrackIDToParticle (int const &id) const

const simb::MCParticle *	TrackIDToMotherParticle (int const &id) const

const art::Ptr< simb::MCTruth > &	TrackIDToMCTruth (int const &id) const

const art::Ptr< simb::MCTruth > &	ParticleToMCTruth (const simb::MCParticle *p) const

std::vector< const simb::MCParticle * >	MCTruthToParticles (art::Ptr< simb::MCTruth > const &mct) const

const MCTruthTruthVec &	MCTruthVector () const

std::vector< TrackIDE >	HitToTrackID (const recob::Hit *) const

std::vector< TrackIDE >	HitToTrackID (art::Ptr< recob::Hit > const &) const

const std::vector< std::vector < art::Ptr< recob::Hit > > >	TrackIDsToHits (std::vector< art::Ptr< recob::Hit >> const &, std::vector< int > const &) const

std::vector< TrackIDE >	HitToEveID (art::Ptr< recob::Hit > const &hit) const

std::vector< double >	HitToXYZ (art::Ptr< recob::Hit > const &hit) const

std::vector< double >	SpacePointHitsToXYZ (art::PtrVector< recob::Hit > const &hits) const

double	HitCollectionPurity (std::set< int >, std::vector< art::Ptr< recob::Hit > > const &) const

double	HitCollectionEfficiency (std::set< int >, std::vector< art::Ptr< recob::Hit > > const &, std::vector< art::Ptr< recob::Hit > > const &, geo::View_t const &) const

double	HitChargeCollectionPurity (std::set< int >, std::vector< art::Ptr< recob::Hit > > const &) const

double	HitChargeCollectionEfficiency (std::set< int >, std::vector< art::Ptr< recob::Hit > > const &, std::vector< art::Ptr< recob::Hit > > const &, geo::View_t const &) const

std::set< int >	GetSetOfEveIDs () const

std::set< int >	GetSetOfTrackIDs () const

std::set< int >	GetSetOfEveIDs (std::vector< art::Ptr< recob::Hit > > const &) const

std::set< int >	GetSetOfTrackIDs (std::vector< art::Ptr< recob::Hit > > const &) const

Private Types
using	HitMatchDataPair = std::pair< const recob::Hit , const anab::BackTrackerHitMatchingData >

using	PartMatchDataPair = std::pair< const simb::MCParticle , const anab::BackTrackerHitMatchingData >

using	HitToPartVecMap = std::map< const recob::Hit *, std::set< PartMatchDataPair >>

using	PartToHitVecMap = std::map< const simb::MCParticle *, std::set< HitMatchDataPair >>

using	MCTruthTrackIDMap = std::unordered_map< int, art::Ptr< simb::MCTruth >>

using	HitPartAssnsList = std::list< HitPartAssnsStruct >

Private Member Functions
int	calculateEvdID (int) const

double	length (const recob::Track *) const

double	length (const detinfo::DetectorPropertiesData &detProp, const simb::MCParticle &part, double dx, TVector3 &start, TVector3 &end, TVector3 &startmom, TVector3 &endmom, unsigned int tpc=0, unsigned int cstat=0) const

Private Attributes
HitPartAssnsList	fHitPartAssnsVec
	Container for the (multiple) associations. More...

MCTruthParticleList	fParticleList
	ParticleList to map track ID to. More...

MCTruthTruthVec	fMCTruthVec
	all the MCTruths for the event More...

MCTruthTrackIDMap	fTrackIDToMCTruthIndex
	map of track ids to MCTruthList entry More...

float	fMinHitEnergyFraction

geo::GeometryCore const *	fGeometry = nullptr

Detailed Description

Obtains truth matching by using hit <–> MCParticle associations.

Configuration

Definition at line 64 of file MCTruthAssociations.h.

Member Typedef Documentation

using truth::MCTruthAssociations::HitMatchDataPair = std::pair<const recob::Hit*,const anab::BackTrackerHitMatchingData*>

private

Definition at line 144 of file MCTruthAssociations.h.

using truth::MCTruthAssociations::HitPartAssnsList = std::list<HitPartAssnsStruct>

private

Definition at line 160 of file MCTruthAssociations.h.

using truth::MCTruthAssociations::HitToPartVecMap = std::map<const recob::Hit*,std::set<PartMatchDataPair>>

private

Definition at line 146 of file MCTruthAssociations.h.

using truth::MCTruthAssociations::MCTruthTrackIDMap = std::unordered_map<int, art::Ptr<simb::MCTruth>>

private

Definition at line 148 of file MCTruthAssociations.h.

using truth::MCTruthAssociations::PartMatchDataPair = std::pair<const simb::MCParticle*,const anab::BackTrackerHitMatchingData*>

private

Definition at line 145 of file MCTruthAssociations.h.

using truth::MCTruthAssociations::PartToHitVecMap = std::map<const simb::MCParticle*, std::set<HitMatchDataPair>>

private

Definition at line 147 of file MCTruthAssociations.h.

Constructor & Destructor Documentation

truth::MCTruthAssociations::MCTruthAssociations ( fhicl::ParameterSet const & config )

Definition at line 33 of file MCTruthAssociations.cpp.

 {
     fMinHitEnergyFraction = config.get<float>("MinHitEnergyFraction", 0.);
 }

Member Function Documentation

int truth::MCTruthAssociations::calculateEvdID ( int ) const

private

const MCTruthParticleList & truth::MCTruthAssociations::getParticleList ( ) const

Definition at line 107 of file MCTruthAssociations.cpp.

 {
     return fParticleList;
 }

std::set< int > truth::MCTruthAssociations::GetSetOfEveIDs ( ) const

Definition at line 494 of file MCTruthAssociations.cpp.

 {
     std::set<int>              eveIDs;
     const MCTruthParticleList& particleList = getParticleList();
     
     for(const auto& pl : particleList) eveIDs.insert(particleList.EveId(pl.first));
     
     return eveIDs;
 }

std::set< int > truth::MCTruthAssociations::GetSetOfEveIDs ( std::vector< art::Ptr< recob::Hit > > const & hitVec ) const

Definition at line 517 of file MCTruthAssociations.cpp.

 {
     std::set<int> eveIDs;
     
     for(const auto& hit : hitVec)
     {
         const std::vector<TrackIDE> ideVec = HitToEveID(hit);
         
         // loop over the ides and extract the track ids
         for(const auto& trackIDE : ideVec) eveIDs.insert(trackIDE.trackID);
     }
     
     return eveIDs;
 }

std::set< int > truth::MCTruthAssociations::GetSetOfTrackIDs ( ) const

Definition at line 505 of file MCTruthAssociations.cpp.

 {
     // fParticleList::value_type is a pair (track, particle pointer)
     std::set<int>              trackIDs;
     const MCTruthParticleList& particleList = getParticleList();
     
     for (const auto& pl: particleList) trackIDs.insert(pl.first);
     
     return trackIDs;
 }

std::set< int > truth::MCTruthAssociations::GetSetOfTrackIDs ( std::vector< art::Ptr< recob::Hit > > const & hitVec ) const

Definition at line 533 of file MCTruthAssociations.cpp.

 {
     std::set<int> trackIDs;
     
     for(const auto& hit : hitVec)
     {
         std::vector<TrackIDE> trackIDEVec = this->HitToTrackID(hit);
         
         for(const auto& trackIDE : trackIDEVec) trackIDs.insert(trackIDE.trackID);
     }
     
     return trackIDs;
 }

double truth::MCTruthAssociations::HitChargeCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::Hit > > const &	hitVec,
		std::vector< art::Ptr< recob::Hit > > const &	allHitVec,
		geo::View_t const &	view
	)		const

Definition at line 434 of file MCTruthAssociations.cpp.

 {
     // get the list of EveIDs that correspond to the hits in this collection
     // and the energy associated with the desired trackID
     float desired = 0.;
     float total   = 0.;
     
     // don't have to check the view in the hits collection because
     // those are assumed to be from the object we are testing and will
     // the correct view by definition then.
     for(const auto& hit : hitVec)
     {
         std::vector<TrackIDE> hitTrackIDs = this->HitToTrackID(hit);
         
         // don't worry about hits where the energy fraction for the chosen
         // trackID is < 0.1
         // also don't double count if this hit has more than one of the
         // desired track IDs associated with it
         for(const auto& trackIDE : hitTrackIDs)
         {
             if (trackIDs.find(trackIDE.trackID) != trackIDs.end() &&
                 trackIDE.energyFrac             >= fMinHitEnergyFraction)
             {
                 desired += hit->Integral();
                 break;
             }
         }
     }
     
     // now figure out how many hits in the whole collection are associated with this id
     for(const auto& hit : allHitVec)
     {
         
         // check that we are looking at the appropriate view here
         // in the case of 3D objects we take all hits
         if(hit->View() != view && view != geo::k3D ) continue;
         
         std::vector<TrackIDE> hitTrackIDs = this->HitToTrackID(hit);
         
         for (const auto& trackIDE : hitTrackIDs)
         {
             if (trackIDs.find(trackIDE.trackID) != trackIDs.end() &&
                 trackIDE.energyFrac             >= fMinHitEnergyFraction)
             {
                 total += hit->Integral();
                 break;
             }
         }
     }
     
     double efficiency = 0.;
     if(total > 0.) efficiency = desired/total;
     
     return efficiency;
 }

double truth::MCTruthAssociations::HitChargeCollectionPurity	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::Hit > > const &	hitVec
	)		const

Definition at line 398 of file MCTruthAssociations.cpp.

 {
     // get the list of EveIDs that correspond to the hits in this collection
     // if the EveID shows up in the input list of trackIDs, then it counts
     float total   = 0;
     float desired = 0.;
     
     // don't have to check the view in the hits collection because
     // those are assumed to be from the object we are testing and will
     // the correct view by definition then.
     for(const auto& hit : hitVec)
     {
         std::vector<TrackIDE> hitTrackIDEVec = this->HitToTrackID(hit);
         
         total += hit->Integral();
         
         for(const auto& trackIDE : hitTrackIDEVec)
         {
             if (trackIDs.find(trackIDE.trackID) != trackIDs.end())
             {
                 desired += hit->Integral();
                 break;
             }
         }
 
     }
     
     double purity = 0.;
     if(total > 0) purity = desired/total;
     
     return purity;
 }

double truth::MCTruthAssociations::HitCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::Hit > > const &	hitVec,
		std::vector< art::Ptr< recob::Hit > > const &	allHitVec,
		geo::View_t const &	view
	)		const

Definition at line 338 of file MCTruthAssociations.cpp.

 {
     // get the list of EveIDs that correspond to the hits in this collection
     // and the energy associated with the desired trackID
     float desired = 0.;
     float total   = 0.;
     
     // don't have to check the view in the hits collection because
     // those are assumed to be from the object we are testing and will
     // the correct view by definition then.
     for(const auto& hit : hitVec)
     {
         std::vector<TrackIDE> hitTrackIDs = this->HitToTrackID(hit);
         
         // don't worry about hits where the energy fraction for the chosen
         // trackID is < 0.1
         // also don't double count if this hit has more than one of the
         // desired track IDs associated with it
         for(const auto& trackIDE : hitTrackIDs)
         {
             if (trackIDs.find(trackIDE.trackID) != trackIDs.end() &&
                 trackIDE.energyFrac             >= fMinHitEnergyFraction)
             {
                 desired += 1.;
                 break;
             }
         }
     }
     
     // now figure out how many hits in the whole collection are associated with this id
     for(const auto& hit : allHitVec)
     {
         
         // check that we are looking at the appropriate view here
         // in the case of 3D objects we take all hits
         if(hit->View() != view && view != geo::k3D ) continue;
         
         std::vector<TrackIDE> hitTrackIDs = this->HitToTrackID(hit);
 
         for (const auto& trackIDE : hitTrackIDs)
         {
             if (trackIDs.find(trackIDE.trackID) != trackIDs.end() &&
                 trackIDE.energyFrac             >= fMinHitEnergyFraction)
             {
                 total += 1.;
                 break;
             }
         }
     }
     
     double efficiency = 0.;
     if(total > 0.) efficiency = desired/total;
     
     return efficiency;
 }

double truth::MCTruthAssociations::HitCollectionPurity	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::Hit > > const &	hitVec
	)		const

Definition at line 305 of file MCTruthAssociations.cpp.

 {
     // get the list of EveIDs that correspond to the hits in this collection
     // if the EveID shows up in the input list of trackIDs, then it counts
     float total   = hitVec.size();;
     float desired = 0.;
     
     // don't have to check the plane in the hits collection because
     // those are assumed to be from the object we are testing and will
     // the correct plane by definition then.
     for(const auto& hit : hitVec)
     {
         std::vector<TrackIDE> hitTrackIDEVec = this->HitToTrackID(hit.get());
         
         for(const auto& trackIDE : hitTrackIDEVec)
         {
             if (trackIDs.find(trackIDE.trackID) != trackIDs.end())
             {
                 desired += 1.;
                 break;
             }
         }
     }
     
     double purity = 0.;
     if(total > 0) purity = desired/total;
     
     return purity;
 }

std::vector< TrackIDE > truth::MCTruthAssociations::HitToEveID ( art::Ptr< recob::Hit > const & hit ) const

Definition at line 261 of file MCTruthAssociations.cpp.

 {
     std::vector<TrackIDE> trackIDEVec = this->HitToTrackID(hit.get());
     
     // Need the particle list, want the "biggest" one to make sure we have all the particles
     const MCTruthParticleList& particleList = getParticleList();
 
     // Create a map which will go between eve ids and TrackIDEs
     std::unordered_map<int, TrackIDE> idToTrackIDEMap;
     
     for(const auto& trackID : trackIDEVec)
     {
         int       eveTrackID  = particleList.EveId(trackID.trackID);
         TrackIDE& eveTrackIDE = idToTrackIDEMap[eveTrackID];
         
         eveTrackIDE.trackID       = eveTrackID;
         eveTrackIDE.energyFrac   += trackID.energyFrac;
         eveTrackIDE.energy       += trackID.energy;
         eveTrackIDE.numElectrons += trackID.numElectrons;
     }
     
     // Now create an output container and move info to it
     std::vector<TrackIDE> eveTrackIDEVec;
     
     for(const auto& eveIDEPair : idToTrackIDEMap) eveTrackIDEVec.emplace_back(eveIDEPair.second);
     
     return eveTrackIDEVec;
 }

std::vector< TrackIDE > truth::MCTruthAssociations::HitToTrackID ( const recob::Hit * hit ) const

Definition at line 180 of file MCTruthAssociations.cpp.

 {
     std::vector<TrackIDE> trackIDEs;
     
     // Apply brute force loop through all possible collections
     for(const auto& hitPartAssns : fHitPartAssnsVec)
     {
         HitToPartVecMap::const_iterator hitMatchPairItr = hitPartAssns.fHitToPartVecMap.find(hit);
     
         if (hitMatchPairItr != hitPartAssns.fHitToPartVecMap.end())
         {
             size_t nTrackIDEs(hitMatchPairItr->second.size());
             
             trackIDEs.reserve(nTrackIDEs);
                               
             for (const auto& matchPair : hitMatchPairItr->second)
             {
                 const simb::MCParticle*                 part = matchPair.first;
                 const anab::BackTrackerHitMatchingData* data = matchPair.second;
                 
                 TrackIDE trackIDE;
                 
                 trackIDE.trackID      = part->TrackId();
                 trackIDE.energyFrac   = data->ideFraction;
                 trackIDE.energy       = data->energy;
                 trackIDE.numElectrons = data->numElectrons;
                 
                 trackIDEs.emplace_back(trackIDE);
             }
             
             break;
         }
     }
     
     return trackIDEs;
 }

std::vector< TrackIDE > truth::MCTruthAssociations::HitToTrackID ( art::Ptr< recob::Hit > const & hit ) const

Definition at line 217 of file MCTruthAssociations.cpp.

 {
     return HitToTrackID(hit.get());
 }

std::vector< double > truth::MCTruthAssociations::HitToXYZ ( art::Ptr< recob::Hit > const & hit ) const

Definition at line 291 of file MCTruthAssociations.cpp.

 {
     mf::LogWarning("MCTruthAssociations") << " ** HitToXYZ currently not implemented in MCTruthAssociations, return a zero point";
     return std::vector<double>() = {0.,0.,0.};
 }

double truth::MCTruthAssociations::length ( const recob::Track * track ) const

private

Definition at line 549 of file MCTruthAssociations.cpp.

 {
     return track->Length();
 }

double truth::MCTruthAssociations::length	(	const detinfo::DetectorPropertiesData &	detProp,
		const simb::MCParticle &	part,
		double	dx,
		TVector3 &	start,
		TVector3 &	end,
		TVector3 &	startmom,
		TVector3 &	endmom,
		unsigned int	tpc = `0`,
		unsigned int	cstat = `0`
	)		const

private

Definition at line 556 of file MCTruthAssociations.cpp.

 {
     // Get fiducial volume boundary.
     double xmin = -0.1;
     double xmax = 2.*fGeometry->DetHalfWidth() + 0.1;
     double ymin = -fGeometry->DetHalfHeight() + 0.1;
     double ymax =  fGeometry->DetHalfHeight() + 0.1;
     double zmin = -0.1;
     double zmax = fGeometry->DetLength() + 0.1;
     
     double readOutWindowSize = detProp.ReadOutWindowSize();
     
     double result = 0.;
     TVector3 disp;
     int n = part.NumberTrajectoryPoints();
     bool first = true;
     
     // Loop over the complete collection of trajectory points
     for(int i = 0; i < n; ++i)
     {
         TVector3 pos = part.Position(i).Vect();
         
         // Make fiducial cuts.
         // There are two sets here:
         // 1) We check the original x,y,z position of the trajectory points and require they be
         //    within the confines of the physical TPC
         // 2) We then check the timing of the presumed hit and make sure it lies within the
         //    readout window for this simulation
         
         if(pos.X() >= xmin &&
            pos.X() <= xmax &&
            pos.Y() >= ymin &&
            pos.Y() <= ymax &&
            pos.Z() >= zmin &&
            pos.Z() <= zmax)
         {
             pos[0] += dx;
             double ticks = detProp.ConvertXToTicks(pos[0], 0, 0, 0);
             
             if(ticks >= 0. && ticks < readOutWindowSize)
             {
                 if(first)
                 {
                     start = pos;
                     startmom = part.Momentum(i).Vect();
                 }
                 else
                 {
                     disp -= pos;
                     result += disp.Mag();
                 }
                 first = false;
                 disp = pos;
                 end = pos;
                 endmom = part.Momentum(i).Vect();
             }
         }
     }
     
     return result;
 }

std::vector< const simb::MCParticle * > truth::MCTruthAssociations::MCTruthToParticles ( art::Ptr< simb::MCTruth > const & mct ) const

Definition at line 158 of file MCTruthAssociations.cpp.

 {
     std::vector<const simb::MCParticle*> ret;
     
     // I'm slightly uncertain what is going on here since I naively would think a track ID is
     // unique to an MCParticle... but this is what was done previously so copied here...
     // sim::ParticleList::value_type is a pair (track ID, particle pointer)
     for (const MCTruthParticleList::value_type& TrackIDpair : fParticleList)
     {
         if (TrackIDToMCTruth(TrackIDpair.first) == mct) ret.push_back(TrackIDpair.second);
     }
     
     return ret;
 }

const MCTruthTruthVec & truth::MCTruthAssociations::MCTruthVector ( ) const

Definition at line 173 of file MCTruthAssociations.cpp.

 {
     return fMCTruthVec;
 }

const art::Ptr< simb::MCTruth > & truth::MCTruthAssociations::ParticleToMCTruth ( const simb::MCParticle * p ) const

Definition at line 153 of file MCTruthAssociations.cpp.

 {
     return this->TrackIDToMCTruth(p->TrackId());
 }

void truth::MCTruthAssociations::setup	(	const HitParticleAssociationsVec &	partToHitAssnsVec,
		const MCParticleVec &	mcPartVec,
		const MCTruthAssns &	truthToPartAssns,
		const geo::GeometryCore &	geometry
	)

Definition at line 38 of file MCTruthAssociations.cpp.

 {
     // Keep track of input services
     fGeometry           = &geometry;
     
     fHitPartAssnsVec.clear();
     
     // Loop through the input vector of associations
     for(const HitParticleAssociations* partToHitAssns : partToHitAssnsVec)
     {
         // Note that one element of our struct is non copiable which means
         // we need to construct in place before filling
         fHitPartAssnsVec.emplace_back();
     
         HitPartAssnsStruct& hitPartAssns = fHitPartAssnsVec.back();
     
         // Clear the maps in case they were previously filled
         hitPartAssns.fHitToPartVecMap.clear();
         hitPartAssns.fPartToHitVecMap.clear();
     
         // Build out the maps between hits/particles
         for(HitParticleAssociations::const_iterator partHitItr = partToHitAssns->begin(); partHitItr != partToHitAssns->end(); ++partHitItr)
         {
             const art::Ptr<simb::MCParticle>&       mcParticle = partHitItr->first;
             const art::Ptr<recob::Hit>&             recoHit    = partHitItr->second;
             const anab::BackTrackerHitMatchingData* data       = partHitItr->data;
         
             hitPartAssns.fHitToPartVecMap[recoHit.get()].insert(PartMatchDataPair(mcParticle.get(),data));
             hitPartAssns.fPartToHitVecMap[mcParticle.get()].insert(HitMatchDataPair(recoHit.get(),data));
         }
         
         mf::LogDebug("MCTruthAssociations") << "Built maps with " << hitPartAssns.fHitToPartVecMap.size() << " hits, " << hitPartAssns.fPartToHitVecMap.size() << "\n";
     }
     
     // Note that there is only one instance of MCTruth <--> MCParticle associations so we do this external to the above loop
     fParticleList.clear();
     fMCTruthVec.clear();
     fTrackIDToMCTruthIndex.clear();
     
     for(const auto& mcParticle : mcPartVec)
     {
         fParticleList.Add(mcParticle.get());
         
         try
         {
             art::Ptr<simb::MCTruth> mcTruth = truthToPartAssns.at(mcParticle.key());
             
             // Add to the list
             if (std::find(fMCTruthVec.begin(),fMCTruthVec.end(),mcTruth) == fMCTruthVec.end())
                 fMCTruthVec.push_back(mcTruth);
             
             fTrackIDToMCTruthIndex[mcParticle->TrackId()] = mcTruth;
         }
         catch(...)
         {
             mf::LogDebug("MCTruthAssociations") << ">>>> No MCTruth found for particle: " << *mcParticle << "\n";
         }
     }
 
     // Follow former backtracker convention of resetting the eve id calculator each event...
     // Note that the calculator is stored as a unique_ptr (mutable) so memory ok
     fParticleList.AdoptEveIdCalculator(new MCTruthEmEveIdCalculator);
 
     return;
 }

std::vector< double > truth::MCTruthAssociations::SpacePointHitsToXYZ ( art::PtrVector< recob::Hit > const & hits ) const

Definition at line 298 of file MCTruthAssociations.cpp.

 {
     mf::LogWarning("MCTruthAssociations") << " ** SpacePointHitsToXYZ currently not implemented in MCTruthAssociations, return a zero point";
     return std::vector<double>() = {0.,0.,0.};
 }

const std::vector< std::vector< art::Ptr< recob::Hit > > > truth::MCTruthAssociations::TrackIDsToHits	(	std::vector< art::Ptr< recob::Hit >> const &	allHits,
		std::vector< int > const &	tkIDs
	)		const

Definition at line 223 of file MCTruthAssociations.cpp.

 {
     // returns a subset of the hits in the allhits collection that are matched
     // to MC particles listed in tkIDs
     
     // temporary vector of TrackIDs and Ptrs to hits so only one
     // loop through the (possibly large) allhits collection is needed
     std::unordered_map<int, std::vector<art::Ptr<recob::Hit>>> trackIDHitVecMap;
     
     for(const auto& hit : allHits)
     {
         std::vector<TrackIDE> trackIDEVec = this->HitToTrackID(hit.get());
         
         for(const auto trackIDE : trackIDEVec)
         {
             for(auto trackID : tkIDs)
             {
                 if(trackID == trackIDE.trackID && trackIDE.energyFrac > fMinHitEnergyFraction)
                 {
                     trackIDHitVecMap[trackID].push_back(hit);
                 }
             }
         }
     }
     
     // now build the truHits vector that will be returned to the caller
     std::vector<std::vector<art::Ptr<recob::Hit>>> truHits;
     
     for(const auto& trackHitPair : trackIDHitVecMap) truHits.emplace_back(trackHitPair.second);
     
     return truHits;
 }

const art::Ptr< simb::MCTruth > & truth::MCTruthAssociations::TrackIDToMCTruth ( int const & id ) const

Definition at line 140 of file MCTruthAssociations.cpp.

 {
     // find the entry in the MCTruth collection for this track id
     MCTruthTrackIDMap::const_iterator trackTruthItr = fTrackIDToMCTruthIndex.find(abs(id));
     
     if (trackTruthItr == fTrackIDToMCTruthIndex.end())
         throw cet::exception("MCTruthAssociations") << "attempting to find MCTruth index for "
         << "out of range value: " << id
         << "/" << fMCTruthVec.size() << "\n";
     
     return trackTruthItr->second;
 }

const simb::MCParticle * truth::MCTruthAssociations::TrackIDToMotherParticle ( int const & id ) const

Definition at line 132 of file MCTruthAssociations.cpp.

 {
     // get the mother id from the particle navigator
     // the EveId was adopted in the Rebuild method
     return this->TrackIDToParticle(fParticleList.EveId(abs(id)));
 }

const simb::MCParticle * truth::MCTruthAssociations::TrackIDToParticle ( int const & id ) const

Definition at line 113 of file MCTruthAssociations.cpp.

 {
     // Pointer to return
     const simb::MCParticle* mcParticle(0);
     
     MCTruthParticleList::const_iterator partItr = fParticleList.find(id);
     
     if (partItr != fParticleList.end()) mcParticle = partItr->second;
     
     if(!mcParticle)
     {
         mf::LogWarning("MCTruthAssociations") << "can't find particle with track id "
         << id << " in MCTruthParticleList"
         << " returning null pointer";
     }
     
     return mcParticle;
 }

Member Data Documentation

geo::GeometryCore const* truth::MCTruthAssociations::fGeometry = nullptr

private

Definition at line 179 of file MCTruthAssociations.h.

HitPartAssnsList truth::MCTruthAssociations::fHitPartAssnsVec

private

Container for the (multiple) associations.

Definition at line 169 of file MCTruthAssociations.h.

MCTruthTruthVec truth::MCTruthAssociations::fMCTruthVec

private

all the MCTruths for the event

Definition at line 171 of file MCTruthAssociations.h.

float truth::MCTruthAssociations::fMinHitEnergyFraction

private

minimum fraction of energy a track id has to contribute to a hit to be counted in purity and efficiency calculations based on hit collections

Definition at line 174 of file MCTruthAssociations.h.

MCTruthParticleList truth::MCTruthAssociations::fParticleList

private

ParticleList to map track ID to.

Definition at line 170 of file MCTruthAssociations.h.

MCTruthTrackIDMap truth::MCTruthAssociations::fTrackIDToMCTruthIndex

private

map of track ids to MCTruthList entry

Definition at line 172 of file MCTruthAssociations.h.

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

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Configuration

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation