#include <BackTracker.h>

Inheritance diagram for cheat::BackTracker:

Classes
struct	fhiclConfig

Public Member Functions
	BackTracker (const fhiclConfig &config, const cheat::ParticleInventory partInv, const geo::GeometryCore geom)

	BackTracker (const fhicl::ParameterSet &pSet, const cheat::ParticleInventory partInv, const geo::GeometryCore geom)

	BackTracker (BackTracker const &)=delete

template<typename Evt >
void	PrepEvent (const Evt &evt)

template<typename Evt >
void	PrepSimChannels (const Evt &evt)

template<typename Evt >
bool	CanRun (const Evt &evt)

template<typename Evt >
std::vector< art::Ptr < recob::Hit > >	SpacePointToHits_Ps (art::Ptr< recob::SpacePoint > const &spt, const Evt &evt) const

template<typename Evt >
std::vector< double >	SpacePointToXYZ (detinfo::DetectorClocksData const &clockData, art::Ptr< recob::SpacePoint > const &spt, const Evt &evt) const

void	ClearEvent ()

bool	SimChannelsReady () const

const std::vector< art::Ptr < sim::SimChannel > > &	SimChannels () const

std::vector< const sim::IDE * >	TrackIdToSimIDEs_Ps (int const &id) const

std::vector< const sim::IDE * >	TrackIdToSimIDEs_Ps (int const &id, const geo::View_t view) const

art::Ptr< sim::SimChannel >	FindSimChannelPtr (raw::ChannelID_t channel) const
	Returns the cached `sim::SimChannel` on the specified `channel`. More...

art::Ptr< sim::SimChannel >	FindSimChannel (raw::ChannelID_t channel) const
	Returns the cached `sim::SimChannel` on the specified `channel`. More...

std::vector< sim::TrackIDE >	ChannelToTrackIDEs (detinfo::DetectorClocksData const &clockData, raw::ChannelID_t channel, const double hit_start_time, const double hit_end_time) const

std::vector< sim::TrackIDE >	HitToTrackIDEs (detinfo::DetectorClocksData const &clockData, recob::Hit const &hit) const

std::vector< sim::TrackIDE >	HitToTrackIDEs (detinfo::DetectorClocksData const &clockData, art::Ptr< recob::Hit > const &hit) const

std::vector< int >	HitToTrackIds (detinfo::DetectorClocksData const &clockData, recob::Hit const &hit) const

std::vector< sim::TrackIDE >	HitToEveTrackIDEs (detinfo::DetectorClocksData const &clockData, recob::Hit const &hit) const

std::vector< sim::TrackIDE >	HitToEveTrackIDEs (detinfo::DetectorClocksData const &clockData, art::Ptr< recob::Hit > const &hit) const

std::vector< art::Ptr < recob::Hit > >	TrackIdToHits_Ps (detinfo::DetectorClocksData const &clockData, int tkId, std::vector< art::Ptr< recob::Hit >> const &hitsIn) const

std::vector< std::vector < art::Ptr< recob::Hit > > >	TrackIdsToHits_Ps (detinfo::DetectorClocksData const &clockData, std::vector< int > const &tkIds, std::vector< art::Ptr< recob::Hit >> const &hitsIn) const

std::vector< sim::IDE >	HitToAvgSimIDEs (detinfo::DetectorClocksData const &clockData, recob::Hit const &hit) const

std::vector< sim::IDE >	HitToAvgSimIDEs (detinfo::DetectorClocksData const &clockData, art::Ptr< recob::Hit > const &hit) const

std::vector< const sim::IDE * >	HitToSimIDEs_Ps (detinfo::DetectorClocksData const &clockData, recob::Hit const &hit) const

std::vector< const sim::IDE * >	HitToSimIDEs_Ps (detinfo::DetectorClocksData const &clockData, art::Ptr< recob::Hit > const &hit) const

std::vector< double >	SimIDEsToXYZ (std::vector< sim::IDE > const &ides) const

std::vector< double >	SimIDEsToXYZ (std::vector< const sim::IDE * > const &ide_Ps) const

std::vector< double >	HitToXYZ (detinfo::DetectorClocksData const &clockData, const recob::Hit &hit) const

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

double	HitCollectionPurity (detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits) const

double	HitChargeCollectionPurity (detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits) const

double	HitCollectionEfficiency (detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits, std::vector< art::Ptr< recob::Hit >> const &allhits, geo::View_t const &view) const

double	HitChargeCollectionEfficiency (detinfo::DetectorClocksData const &clockData, std::set< int > const &trackIds, std::vector< art::Ptr< recob::Hit >> const &hits, std::vector< art::Ptr< recob::Hit >> const &allhits, geo::View_t const &view) const

std::set< int >	GetSetOfTrackIds () const

std::set< int >	GetSetOfEveIds () const

std::set< int >	GetSetOfTrackIds (detinfo::DetectorClocksData const &clockData, std::vector< art::Ptr< recob::Hit >> const &hits) const

std::set< int >	GetSetOfEveIds (detinfo::DetectorClocksData const &clockData, std::vector< art::Ptr< recob::Hit >> const &hits) const

std::vector< double >	SpacePointHitsToWeightedXYZ (detinfo::DetectorClocksData const &clockData, std::vector< art::Ptr< recob::Hit >> const &hits) const

Private Attributes
const cheat::ParticleInventory *	fPartInv

const geo::GeometryCore *	fGeom

const art::InputTag	fG4ModuleLabel

const art::InputTag	fSimChannelModuleLabel

const art::InputTag	fHitLabel

const double	fMinHitEnergyFraction

const bool	fOverrideRealData

const double	fHitTimeRMS

std::vector< art::Ptr < sim::SimChannel > >	fSimChannels

Detailed Description

Definition at line 39 of file BackTracker.h.

Constructor & Destructor Documentation

cheat::BackTracker::BackTracker	(	const fhiclConfig &	config,
		const cheat::ParticleInventory *	partInv,
		const geo::GeometryCore *	geom
	)

Definition at line 25 of file BackTracker.cc.

     : fPartInv(partInv)
     , fGeom(geom)
     , fG4ModuleLabel(config.G4ModuleLabel())
     , fSimChannelModuleLabel(config.SimChannelModuleLabel())
     , fHitLabel(config.DefaultHitModuleLabel())
     , fMinHitEnergyFraction(config.MinHitEnergyFraction())
     , fOverrideRealData(config.OverrideRealData())
     , fHitTimeRMS(config.HitTimeRMS())
   {}

cheat::BackTracker::BackTracker	(	const fhicl::ParameterSet &	pSet,
		const cheat::ParticleInventory *	partInv,
		const geo::GeometryCore *	geom
	)

Definition at line 39 of file BackTracker.cc.

     : fPartInv(partInv)
     , fGeom(geom)
     , fG4ModuleLabel(pSet.get<art::InputTag>("G4ModuleLabel", "largeant"))
     , fSimChannelModuleLabel(pSet.get<art::InputTag>("SimChannelModuleLabel", fG4ModuleLabel))
     , // -- D.R. if not provided, default behavior is to use the G4ModuleLabel
     fHitLabel(pSet.get<art::InputTag>("DefaultHitModuleLabel", "hitfd"))
     , fMinHitEnergyFraction(pSet.get<double>("MinHitEnergyFraction", 0.010))
     , fOverrideRealData(pSet.get<bool>("OverrideRealData", false))
     , fHitTimeRMS(pSet.get<double>("HitTimeRMS", 1.0))
   {}

cheat::BackTracker::BackTracker ( BackTracker const & )

delete

Member Function Documentation

template<typename Evt >

bool cheat::BackTracker::CanRun ( const Evt & evt )

inline

Definition at line 94 of file BackTracker.h.

     {
       return !evt.isRealData() || fOverrideRealData;
     }

std::vector< sim::TrackIDE > cheat::BackTracker::ChannelToTrackIDEs	(	detinfo::DetectorClocksData const &	clockData,
		raw::ChannelID_t	channel,
		const double	hit_start_time,
		const double	hit_end_time
	)		const

Definition at line 131 of file BackTracker.cc.

   {
     art::Ptr<sim::SimChannel> schannel = this->FindSimChannelPtr(channel);
     if (!schannel) return {};
 
     std::vector<sim::TrackIDE> trackIDEs;
     double totalE = 0.;
     
     // loop over the electrons in the channel and grab those that are in time
     // with the identified hit start and stop times
     int start_tdc = clockData.TPCTick2TDC(hit_start_time);
     int end_tdc = clockData.TPCTick2TDC(hit_end_time);
     if (start_tdc < 0) start_tdc = 0;
     if (end_tdc < 0) end_tdc = 0;
     std::vector<sim::IDE> simides = schannel->TrackIDsAndEnergies(start_tdc, end_tdc);
 
     // first get the total energy represented by all track ids for
     // this channel and range of tdc values
     for (size_t e = 0; e < simides.size(); ++e)
       totalE += simides[e].energy;
 
     // protect against a divide by zero below
     if (totalE < 1.e-5) totalE = 1.;
 
     // loop over the entries in the map and fill the input vectors
 
     for (size_t e = 0; e < simides.size(); ++e) {
 
       if (simides[e].trackID == sim::NoParticleId) continue;
 
       sim::TrackIDE info;
       info.trackID = simides[e].trackID;
       info.energyFrac = simides[e].energy / totalE;
       info.energy = simides[e].energy;
       info.numElectrons = simides[e].numElectrons;
 
       trackIDEs.push_back(info);
     }
 
     return trackIDEs;
   }

void cheat::BackTracker::ClearEvent ( )

Definition at line 55 of file BackTracker.cc.

   {
     fSimChannels.clear();
     //    fAllHitList.clear();
   }

art::Ptr< sim::SimChannel > cheat::BackTracker::FindSimChannel ( raw::ChannelID_t channel ) const

Returns the cached sim::SimChannel on the specified channel.

Parameters

channel ID of the TPC channel to find

Returns: art pointer to sim::SimChannel

Exceptions

cet::exception (category: "BackTracker") if no sim::SimChannel for the requested channel found

See Also: FindSimChannelPtr()

Definition at line 122 of file BackTracker.cc.

   {
     if (auto const chan = FindSimChannelPtr(channel)) return chan;
     throw cet::exception("BackTracker") << "No sim::SimChannel corresponding "
                                         << "to channel: " << channel << "\n";
   }

art::Ptr< sim::SimChannel > cheat::BackTracker::FindSimChannelPtr ( raw::ChannelID_t channel ) const

Returns the cached sim::SimChannel on the specified channel.

Parameters

channel ID of the TPC channel to find

Returns: art pointer to sim::SimChannel, or an null pointer if none

See Also: FindSimChannel()

Definition at line 108 of file BackTracker.cc.

   {
     auto ilb = std::lower_bound(fSimChannels.begin(),
                                 fSimChannels.end(),
                                 channel,
                                 [](art::Ptr<sim::SimChannel> const& a, raw::ChannelID_t channel) {
                                   return (a->Channel() < channel);
                                 });
     return ((ilb != fSimChannels.end()) && ((*ilb)->Channel() == channel))
       ? *ilb: art::Ptr<sim::SimChannel>{};
   }

std::set<int> cheat::BackTracker::GetSetOfEveIds ( ) const

inline

Definition at line 247 of file BackTracker.h.

     {
       return fPartInv->GetSetOfEveIds();
     }

std::set< int > cheat::BackTracker::GetSetOfEveIds	(	detinfo::DetectorClocksData const &	clockData,
		std::vector< art::Ptr< recob::Hit >> const &	hits
	)		const

Definition at line 551 of file BackTracker.cc.

   {
     std::set<int> eveIds;
     for (const auto& hit : hits) {
       const std::vector<sim::TrackIDE> ides = this->HitToEveTrackIDEs(clockData, hit);
       for (const auto& ide : ides) {
         eveIds.insert(ide.trackID);
       } // end ides
     }   // End for hits
     return eveIds;
   }

std::set<int> cheat::BackTracker::GetSetOfTrackIds ( ) const

inline

Definition at line 242 of file BackTracker.h.

     {
       return fPartInv->GetSetOfTrackIds();
     }

std::set< int > cheat::BackTracker::GetSetOfTrackIds	(	detinfo::DetectorClocksData const &	clockData,
		std::vector< art::Ptr< recob::Hit >> const &	hits
	)		const

Definition at line 533 of file BackTracker.cc.

   {
     std::set<int> tids;
     for (const auto& hit : hits) {
       const double start = hit->PeakTimeMinusRMS(fHitTimeRMS);
       const double end = hit->PeakTimePlusRMS(fHitTimeRMS);
       std::vector<sim::TrackIDE> trackIDEs =
         this->ChannelToTrackIDEs(clockData, hit->Channel(), start, end);
       for (const auto& ide : trackIDEs) {
         tids.insert(ide.trackID);
       } // End for TrackIDEs
     }   // End for hits
     return tids;
   } // End GetSetOfTrackIds

double cheat::BackTracker::HitChargeCollectionEfficiency	(	detinfo::DetectorClocksData const &	clockData,
		std::set< int > const &	trackIds,
		std::vector< art::Ptr< recob::Hit >> const &	hits,
		std::vector< art::Ptr< recob::Hit >> const &	allhits,
		geo::View_t const &	view
	)		const

Definition at line 497 of file BackTracker.cc.

   {
     double desired = 0., total = 0.;
     for (const auto& hit : hits) {
       std::vector<sim::TrackIDE> hitTrackIDEs = this->HitToTrackIDEs(clockData, hit);
       for (const auto& hitIDE : hitTrackIDEs) {
         if (trackIds.find(hitIDE.trackID) != trackIds.end() &&
             hitIDE.energyFrac >= fMinHitEnergyFraction) {
           desired += hit->Integral();
           break;
         } // end if hit id matches and energy sufficient.
       }   // End for IDE in HitTrackIDEs.
     }     // End for hit in hits.
 
     for (const auto& hit : allHits) {
       if (hit->View() != view && view != geo::k3D) { continue; }
       std::vector<sim::TrackIDE> hitTrackIDEs = this->HitToTrackIDEs(clockData, hit);
       for (const auto& hitIDE : hitTrackIDEs) {
         if (trackIds.find(hitIDE.trackID) != trackIds.end() &&
             hitIDE.energyFrac >= fMinHitEnergyFraction) {
           total += hit->Integral();
           break;
         } // end if hit matches
       }   // end for ide in ides
     }     // End for hit in allHits
 
     if (total > 0.) { return desired / total; }
     return 0.;
   }

double cheat::BackTracker::HitChargeCollectionPurity	(	detinfo::DetectorClocksData const &	clockData,
		std::set< int > const &	trackIds,
		std::vector< art::Ptr< recob::Hit >> const &	hits
	)		const

Definition at line 437 of file BackTracker.cc.

   {
     double totalCharge = 0., desired = 0.;
     for (const auto& hit : hits) {
       totalCharge += hit->Integral();
       std::vector<sim::TrackIDE> trackIDEs = this->HitToTrackIDEs(clockData, hit);
       for (const auto& trackIDE : trackIDEs) {
         if (trackIds.find(trackIDE.trackID) != trackIds.end()) {
           desired += hit->Integral();
           break;
         } // End if trackId in trackIds.
       }   // End for trackIDE in trackIDEs
     }     // End for Hit in Hits
     if (totalCharge > 0.0) { return (desired / totalCharge); }
     return 0.0;
   }

double cheat::BackTracker::HitCollectionEfficiency	(	detinfo::DetectorClocksData const &	clockData,
		std::set< int > const &	trackIds,
		std::vector< art::Ptr< recob::Hit >> const &	hits,
		std::vector< art::Ptr< recob::Hit >> const &	allhits,
		geo::View_t const &	view
	)		const

Definition at line 458 of file BackTracker.cc.

   {
 
     int desired = 0, total = 0;
 
     for (const auto& hit : hits) {
       std::vector<sim::TrackIDE> hitTrackIDEs = this->HitToTrackIDEs(clockData, hit);
       for (const auto& trackIDE : hitTrackIDEs) {
         if (trackIds.find(trackIDE.trackID) != trackIds.end() &&
             trackIDE.energyFrac >= fMinHitEnergyFraction) {
           ++desired;
           break;
         } // End if trackID in trackIds.
       }   // end for trackIDE in TrackIDEs
     }     // end for hit in hits
 
     for (const auto& hit : allHits) {
       if (hit->View() != view && view != geo::k3D) {
         continue;
       } // End if hit.view = view or view = geo::k3D
       std::vector<sim::TrackIDE> hitTrackIDEs = this->HitToTrackIDEs(clockData, hit);
       for (const auto& hitIDE : hitTrackIDEs) {
         if (trackIds.find(hitIDE.trackID) != trackIds.end() &&
             hitIDE.energyFrac >= fMinHitEnergyFraction) {
           ++total;
           break;
         }
       } // END for all IDEs in HitTrackIDEs.
     }   // end for hit in allHits.
     if (total >= 0) { return double(double(desired) / double(total)); }
     return 0.;
   }

double cheat::BackTracker::HitCollectionPurity	(	detinfo::DetectorClocksData const &	clockData,
		std::set< int > const &	trackIds,
		std::vector< art::Ptr< recob::Hit >> const &	hits
	)		const

Definition at line 417 of file BackTracker.cc.

   {
     int desired = 0;
     for (const auto& hit : hits) {
       std::vector<sim::TrackIDE> hitTrackIDEs = this->HitToTrackIDEs(clockData, hit);
       for (const auto& tIDE : hitTrackIDEs) {
         if (trackIds.find(tIDE.trackID) != trackIds.end()) {
           ++desired;
           break;
         } // End if TID Found
       }   // END for trackIDE in TrackIDEs
     }     // End for hit in hits
     if (hits.size() > 0) { return double(double(desired) / double(hits.size())); }
     return 0;
   }

std::vector< sim::IDE > cheat::BackTracker::HitToAvgSimIDEs	(	detinfo::DetectorClocksData const &	clockData,
		recob::Hit const &	hit
	)		const

Definition at line 305 of file BackTracker.cc.

   {
     // Get services.
 
     int start_tdc = clockData.TPCTick2TDC(hit.PeakTimeMinusRMS(fHitTimeRMS));
     int end_tdc = clockData.TPCTick2TDC(hit.PeakTimePlusRMS(fHitTimeRMS));
     if (start_tdc < 0) start_tdc = 0;
     if (end_tdc < 0) end_tdc = 0;
 
     return (this->FindSimChannel(hit.Channel()))->TrackIDsAndEnergies(start_tdc, end_tdc);
   }

std::vector<sim::IDE> cheat::BackTracker::HitToAvgSimIDEs	(	detinfo::DetectorClocksData const &	clockData,
		art::Ptr< recob::Hit > const &	hit
	)		const

inline

Definition at line 196 of file BackTracker.h.

     {
       return this->HitToAvgSimIDEs(clockData, *hit);
     }

std::vector< sim::TrackIDE > cheat::BackTracker::HitToEveTrackIDEs	(	detinfo::DetectorClocksData const &	clockData,
		recob::Hit const &	hit
	)		const

Definition at line 201 of file BackTracker.cc.

   {
     std::vector<sim::TrackIDE> eveIDEs;
     std::vector<sim::TrackIDE> trackIDEs = this->HitToTrackIDEs(clockData, hit);
     std::map<int, std::pair<double, double>> eveToEMap;
     double totalE = 0.0;
     for (const auto& trackIDE : trackIDEs) {
       auto check = eveToEMap.emplace(fPartInv->TrackIdToEveTrackId(trackIDE.trackID),
                                      std::make_pair(trackIDE.energy, trackIDE.numElectrons));
       if (check.second == false) {
         check.first->second.first += trackIDE.energy;
         check.first->second.second += trackIDE.numElectrons;
       }
       //      eveToEMap[fPartInv->TrackIdToEveTrackId(trackIDE.trackID)].first
       //      += trackIDE.energy;
       totalE += trackIDE.energy;
     } // End for trackIDEs
     eveIDEs.reserve(eveToEMap.size());
     for (const auto& eveToE : eveToEMap) {
       sim::TrackIDE eveTrackIDE_tmp;
 
       eveTrackIDE_tmp.trackID = eveToE.first;
       eveTrackIDE_tmp.energy = eveToE.second.first;
       eveTrackIDE_tmp.energyFrac = (eveTrackIDE_tmp.energy) / (totalE);
       eveTrackIDE_tmp.numElectrons = eveToE.second.second;
 
       eveIDEs.push_back(eveTrackIDE_tmp);
     } // END eveToEMap loop
     return eveIDEs;
   }

std::vector<sim::TrackIDE> cheat::BackTracker::HitToEveTrackIDEs	(	detinfo::DetectorClocksData const &	clockData,
		art::Ptr< recob::Hit > const &	hit
	)		const

inline

Definition at line 175 of file BackTracker.h.

     {
       return this->HitToEveTrackIDEs(clockData, *hit);
     }

std::vector< const sim::IDE * > cheat::BackTracker::HitToSimIDEs_Ps	(	detinfo::DetectorClocksData const &	clockData,
		recob::Hit const &	hit
	)		const

Definition at line 320 of file BackTracker.cc.

   {
     std::vector<const sim::IDE*> retVec;
     int start_tdc = clockData.TPCTick2TDC(hit.PeakTimeMinusRMS(fHitTimeRMS));
     int end_tdc = clockData.TPCTick2TDC(hit.PeakTimePlusRMS(fHitTimeRMS));
     if (start_tdc < 0) start_tdc = 0;
     if (end_tdc < 0) end_tdc = 0;
 
     if (start_tdc > end_tdc) { throw; }
 
     const std::vector<std::pair<unsigned short, std::vector<sim::IDE>>>& tdcIDEMap =
       (this->FindSimChannel(hit.Channel()))
         ->TDCIDEMap(); // This in fact does not return a std::map. It returns a
                        // vector... with no guarantee that it is sorted...
     std::vector<const std::pair<unsigned short, std::vector<sim::IDE>>*> tdcIDEMap_SortedPointers;
     for (auto& pair : tdcIDEMap) {
       tdcIDEMap_SortedPointers.push_back(&pair);
     }
 
     // This is a bunch of extra steps, due to needing a vector we can sort, and
     // needing those items in the sorted vector to be the items from the sim
     // channels (so a pointer to the IDEs inside the sim channels can be made).
     // The work around is to make a vector of pointers to IDEs inside the
     // TDCIDEMap (which is a constant reference to the fTDCIDEs in the
     // SimChannel.)
     auto pairSort = [](auto& a, auto& b) { return a->first < b->first; };
     if (!std::is_sorted(
           tdcIDEMap_SortedPointers.begin(), tdcIDEMap_SortedPointers.end(), pairSort)) {
       std::sort(tdcIDEMap_SortedPointers.begin(), tdcIDEMap_SortedPointers.end(), pairSort);
     }
 
     std::vector<sim::IDE> dummyVec; // I need something to stick in a pair to compare pair<tdcVal,
                                     // IDE>. This is an otherwise useless "hack".
     std::pair<double, std::vector<sim::IDE>> start_tdcPair =
       std::make_pair(start_tdc, dummyVec); // This pair is a "hack" to make my comparison work
                                            // for lower and upper bound.
     std::pair<double, std::vector<sim::IDE>> end_tdcPair = std::make_pair(end_tdc, dummyVec);
     auto start_tdcPair_P = &start_tdcPair;
     auto end_tdcPair_P = &end_tdcPair;
     auto mapFirst = std::lower_bound(
       tdcIDEMap_SortedPointers.begin(), tdcIDEMap_SortedPointers.end(), start_tdcPair_P, pairSort);
 
     // iterator to just after the last interesting IDE
     auto mapLast = std::upper_bound(
       tdcIDEMap_SortedPointers.begin(), tdcIDEMap_SortedPointers.end(), end_tdcPair_P, pairSort);
     for (auto& mapitr = mapFirst; mapitr != mapLast; ++mapitr) {
       for (auto& ide : (*mapitr)->second) {
         retVec.push_back(&ide);
       } // Add all interesting IDEs to the retVec
     }
     return retVec;
   }

std::vector<const sim::IDE*> cheat::BackTracker::HitToSimIDEs_Ps	(	detinfo::DetectorClocksData const &	clockData,
		art::Ptr< recob::Hit > const &	hit
	)		const

inline

Definition at line 205 of file BackTracker.h.

     {
       return this->HitToSimIDEs_Ps(clockData, *hit);
     }

std::vector< sim::TrackIDE > cheat::BackTracker::HitToTrackIDEs	(	detinfo::DetectorClocksData const &	clockData,
		recob::Hit const &	hit
	)		const

Definition at line 178 of file BackTracker.cc.

   {
     const double start = hit.PeakTimeMinusRMS(fHitTimeRMS);
     const double end = hit.PeakTimePlusRMS(fHitTimeRMS);
     return this->ChannelToTrackIDEs(clockData, hit.Channel(), start, end);
   }

std::vector<sim::TrackIDE> cheat::BackTracker::HitToTrackIDEs	(	detinfo::DetectorClocksData const &	clockData,
		art::Ptr< recob::Hit > const &	hit
	)		const

inline

Definition at line 161 of file BackTracker.h.

     {
       return this->HitToTrackIDEs(clockData, *hit);
     }

std::vector< int > cheat::BackTracker::HitToTrackIds	(	detinfo::DetectorClocksData const &	clockData,
		recob::Hit const &	hit
	)		const

Definition at line 188 of file BackTracker.cc.

   {
     std::vector<int> retVec;
     for (auto const trackIDE : this->HitToTrackIDEs(clockData, hit)) {
       retVec.push_back(trackIDE.trackID);
     }
     return retVec;
   }

std::vector< double > cheat::BackTracker::HitToXYZ	(	detinfo::DetectorClocksData const &	clockData,
		const recob::Hit &	hit
	)		const

Definition at line 409 of file BackTracker.cc.

   {
     std::vector<const sim::IDE*> ide_Ps = this->HitToSimIDEs_Ps(clockData, hit);
     return this->SimIDEsToXYZ(ide_Ps);
   }

std::vector<double> cheat::BackTracker::HitToXYZ	(	detinfo::DetectorClocksData const &	clockData,
		art::Ptr< recob::Hit > const &	hit
	)		const

inline

Definition at line 217 of file BackTracker.h.

     {
       return this->HitToXYZ(clockData, *hit);
     }

template<typename Evt >

void cheat::BackTracker::PrepEvent ( const Evt & evt )

template<typename Evt >

void cheat::BackTracker::PrepSimChannels ( const Evt & evt )

const std::vector<art::Ptr<sim::SimChannel> >& cheat::BackTracker::SimChannels ( ) const

inline

Definition at line 120 of file BackTracker.h.

     {
       return fSimChannels;
     }

bool cheat::BackTracker::SimChannelsReady ( ) const

inline

Definition at line 114 of file BackTracker.h.

     {
       return !fSimChannels.empty();
     }

std::vector< double > cheat::BackTracker::SimIDEsToXYZ ( std::vector< sim::IDE > const & ides ) const

Definition at line 376 of file BackTracker.cc.

   {
     std::vector<double> xyz(3, 0.0);
     double w = 0.0;
     for (auto const& ide : ides) {
       double weight = ide.numElectrons;
       w += weight;
       xyz[0] += (weight * ide.x);
       xyz[1] += (weight * ide.y);
       xyz[2] += (weight * ide.z);
     }
     if (w < 1.e-5)
       throw cet::exception("BackTracker") << "No sim::IDEs providing non-zero number of electrons"
                                           << " can't determine originating location from truth\n";
     xyz[0] = xyz[0] / w;
     xyz[1] = xyz[1] / w;
     xyz[2] = xyz[2] / w;
     return xyz;
   }

std::vector< double > cheat::BackTracker::SimIDEsToXYZ ( std::vector< const sim::IDE * > const & ide_Ps ) const

Definition at line 398 of file BackTracker.cc.

   {
     std::vector<sim::IDE> ides;
     for (auto ide_P : ide_Ps) {
       ides.push_back(*ide_P);
     }
     return this->SimIDEsToXYZ(ides);
   }

std::vector< double > cheat::BackTracker::SpacePointHitsToWeightedXYZ	(	detinfo::DetectorClocksData const &	clockData,
		std::vector< art::Ptr< recob::Hit >> const &	hits
	)		const

Definition at line 566 of file BackTracker.cc.

   {
     std::vector<double> xyz(3, -99999.9);
     std::vector<std::vector<std::vector<int>>> numHits(fGeom->Ncryostats());
     std::vector<std::vector<std::vector<double>>> hitWeight(fGeom->Ncryostats());
     std::vector<std::vector<std::vector<std::vector<double>>>> hitPos(fGeom->Ncryostats());
     //Do we need to resize everything...
     for (size_t c = 0; c < numHits.size(); ++c) {
       numHits[c].resize(fGeom->NTPC(c));
       hitWeight[c].resize(fGeom->NTPC(c));
       hitPos[c].resize(fGeom->NTPC(c));
       for (size_t t = 0; t < numHits[c].size(); ++t) {
         numHits[c][t].resize(fGeom->Nplanes(t, c));
         hitWeight[c][t].resize(fGeom->Nplanes(t, c));
         hitPos[c][t].resize(fGeom->Nplanes(t, c));
       }
     }
 
     for (art::PtrVector<recob::Hit>::const_iterator ihit = hits.begin(); ihit != hits.end();
          ++ihit) {
 
       const recob::Hit& hit = **ihit;
 
       // use the HitToXYZ and Geometry::PositionToTPC
       // to figure out which drift volume the hit originates from
       std::vector<double> hitOrigin = this->HitToXYZ(clockData, *ihit);
       unsigned int cstat = 0;
       unsigned int tpc = 0;
       const double worldLoc[3] = {hitOrigin[0], hitOrigin[1], hitOrigin[2]};
       fGeom->PositionToTPC(worldLoc, tpc, cstat);
 
       if (hit.WireID().Cryostat == cstat && hit.WireID().TPC == tpc) {
         ++numHits[cstat][tpc][hit.WireID().Plane];
         hitWeight[cstat][tpc][hit.WireID().Plane] = hit.Integral();
         hitPos[cstat][tpc][hit.WireID().Plane] = hitOrigin;
       }
     }
 
     // loop over the vectors we made and find the average position for the hits
     // in the future we might take a weighted average
     int nhits = 0;
     xyz[0] = 0.;
     xyz[1] = 0.;
     xyz[2] = 0.;
     for (size_t c = 0; c < numHits.size(); ++c) {
       for (size_t t = 0; t < numHits[c].size(); ++t) {
         for (size_t p = 0; p < numHits[c][t].size(); ++p) {
 
           if (numHits[c][t][p] == 1) {
             ++nhits;
             xyz[0] += hitPos[c][t][p][0];
             xyz[1] += hitPos[c][t][p][1];
             xyz[2] += hitPos[c][t][p][2];
           }
 
         } // end loop over planes
       }   // end loop over tpcs
     }     // end loop over cryostats
 
     // get the average position
     if (nhits < 1)
       throw cet::exception("BackTracker")
         << "No hits to determine originating location from truth\n";
 
     xyz[0] /= nhits;
     xyz[1] /= nhits;
     xyz[2] /= nhits;
 
     // Done.
     return xyz;
   }

template<typename Evt >

std::vector<art::Ptr<recob::Hit> > cheat::BackTracker::SpacePointToHits_Ps	(	art::Ptr< recob::SpacePoint > const &	spt,
		const Evt &	evt
	)		const

template<typename Evt >

std::vector<double> cheat::BackTracker::SpacePointToXYZ	(	detinfo::DetectorClocksData const &	clockData,
		art::Ptr< recob::SpacePoint > const &	spt,
		const Evt &	evt
	)		const

std::vector< std::vector< art::Ptr< recob::Hit > > > cheat::BackTracker::TrackIdsToHits_Ps	(	detinfo::DetectorClocksData const &	clockData,
		std::vector< int > const &	tkIds,
		std::vector< art::Ptr< recob::Hit >> const &	hitsIn
	)		const

Definition at line 262 of file BackTracker.cc.

   {
     // returns a subset of the hits in the hitsIn 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) hitsIn collection is needed
     std::vector<std::pair<int, art::Ptr<recob::Hit>>> hitList;
     std::vector<sim::TrackIDE> tids;
     for (auto itr = hitsIn.begin(); itr != hitsIn.end(); ++itr) {
       tids.clear();
       art::Ptr<recob::Hit> const& hit = *itr;
       tids = this->ChannelToTrackIDEs(
         clockData, hit->Channel(), hit->PeakTimeMinusRMS(fHitTimeRMS), hit->PeakTimePlusRMS(fHitTimeRMS));
       for (auto itid = tids.begin(); itid != tids.end(); ++itid) {
         for (auto itkid = tkIds.begin(); itkid != tkIds.end(); ++itkid) {
           if (itid->trackID == *itkid) {
             if (itid->energyFrac > fMinHitEnergyFraction)
               hitList.push_back(std::make_pair(*itkid, hit));
           }
         } // itkid
       }   // itid
     }     // itr
 
     // now build the truHits vector that will be returned to the caller
     std::vector<std::vector<art::Ptr<recob::Hit>>> truHits;
     // temporary vector containing hits assigned to one MC particle
     std::vector<art::Ptr<recob::Hit>> tmpHits;
     for (auto itkid = tkIds.begin(); itkid != tkIds.end(); ++itkid) {
       tmpHits.clear();
       for (auto itr = hitList.begin(); itr != hitList.end(); ++itr) {
         if (*itkid == (*itr).first) tmpHits.push_back((*itr).second);
       }
       truHits.push_back(tmpHits);
     }
     return truHits;
   }

std::vector< art::Ptr< recob::Hit > > cheat::BackTracker::TrackIdToHits_Ps	(	detinfo::DetectorClocksData const &	clockData,
		int	tkId,
		std::vector< art::Ptr< recob::Hit >> const &	hitsIn
	)		const

Definition at line 235 of file BackTracker.cc.

   {
     // returns a subset of the hits in the hitsIn collection that are matched
     // to the given track
 
     // temporary vector of TrackIds and Ptrs to hits so only one
     // loop through the (possibly large) hitsIn collection is needed
     std::vector<art::Ptr<recob::Hit>> hitList;
     std::vector<sim::TrackIDE> trackIDE;
     for (auto itr = hitsIn.begin(); itr != hitsIn.end(); ++itr) {
       trackIDE.clear();
       art::Ptr<recob::Hit> const& hit = *itr;
       trackIDE = this->ChannelToTrackIDEs(
         clockData, hit->Channel(), hit->PeakTimeMinusRMS(fHitTimeRMS), hit->PeakTimePlusRMS(fHitTimeRMS));
       for (auto itr_trakIDE = trackIDE.begin(); itr_trakIDE != trackIDE.end(); ++itr_trakIDE) {
         if (itr_trakIDE->trackID == tkId && itr_trakIDE->energyFrac > fMinHitEnergyFraction)
           hitList.push_back(hit);
       } // itr_trakIDE
     }   // itr
     return hitList;
   }

std::vector< const sim::IDE * > cheat::BackTracker::TrackIdToSimIDEs_Ps ( int const & id ) const

Definition at line 63 of file BackTracker.cc.

   {
     std::vector<const sim::IDE*> ideps;
     for (size_t sc = 0; sc < fSimChannels.size(); ++sc) {
       const auto& tdcidemap = fSimChannels[sc]->TDCIDEMap(); // This returns a reference.
       // loop over the IDEMAP
       for (auto mapitr = tdcidemap.begin(); mapitr != tdcidemap.end(); mapitr++) {
         // loop over the vector of IDE objects.
         const std::vector<sim::IDE>& idevec =
           (*mapitr).second; // note, mapitr.second returns the actual data from
                             // the map, not a copy
         for (size_t iv = 0; iv < idevec.size(); ++iv) {
           // const sim::IDE* const idep = &idevec[iv];
           // if( abs(idevec[iv].trackID) == id) continue;
           // ideps.push_back(idep);
           if (abs(idevec[iv].trackID) == id) ideps.push_back(&(idevec[iv]));
         } // end for index in idevec
       }   // end loop over map from sim::SimChannel
     }     // end loop over sim::SimChannels
     return ideps;
   }

std::vector< const sim::IDE * > cheat::BackTracker::TrackIdToSimIDEs_Ps	(	int const &	id,
		const geo::View_t	view
	)		const

Definition at line 87 of file BackTracker.cc.

   {
     std::vector<const sim::IDE*> ide_Ps;
     for (const art::Ptr<sim::SimChannel> sc : fSimChannels) {
       if (fGeom->View(sc->Channel()) != view) continue;
 
       // loop over the IDEMAP
       for (const auto& item : sc->TDCIDEMap()) {
 
         // loop over the vector of IDE objects.
         for (const sim::IDE& ide : item.second) {
           if (abs(ide.trackID) == id) ide_Ps.push_back(&ide);
         }
       } // end loop over map from sim::SimChannel
     }   // end loop over sim::SimChannels
 
     return ide_Ps;
   }

Member Data Documentation

const art::InputTag cheat::BackTracker::fG4ModuleLabel

private

Definition at line 264 of file BackTracker.h.

const geo::GeometryCore* cheat::BackTracker::fGeom

private

Definition at line 263 of file BackTracker.h.

const art::InputTag cheat::BackTracker::fHitLabel

private

Definition at line 266 of file BackTracker.h.

const double cheat::BackTracker::fHitTimeRMS

private

Definition at line 269 of file BackTracker.h.

const double cheat::BackTracker::fMinHitEnergyFraction

private

Definition at line 267 of file BackTracker.h.

const bool cheat::BackTracker::fOverrideRealData

private

Definition at line 268 of file BackTracker.h.

const cheat::ParticleInventory* cheat::BackTracker::fPartInv

private

Definition at line 262 of file BackTracker.h.

const art::InputTag cheat::BackTracker::fSimChannelModuleLabel

private

Definition at line 265 of file BackTracker.h.

std::vector<art::Ptr<sim::SimChannel> > cheat::BackTracker::fSimChannels

mutableprivate

Definition at line 271 of file BackTracker.h.

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

Classes

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation