#include <BackTrackerCore.h>

Inheritance diagram for gar::cheat::BackTrackerCore:

Public Member Functions
	BackTrackerCore (fhicl::ParameterSet const &pset)

	~BackTrackerCore ()

void	AdoptEveIdCalculator (sim::EveIdCalculator *ec)

bool	HasMC ()

bool	HasHits ()

bool	HasCalHits ()

bool	HasTracks ()

bool	HasClusters ()

sim::ParticleList *	GetParticleList ()

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

simb::MCParticle *	FindMother (simb::MCParticle *const p) const

simb::MCParticle *	FindEve (simb::MCParticle *const p) const

simb::MCParticle *	FindTPCEve (simb::MCParticle *const p) const

simb::MCParticle *	FindTPCEve (int const trackId) const

bool	IsForebearOf (simb::MCParticle const forebear, simb::MCParticle const afterbear) const

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

std::vector< HitIDE >	HitToHitIDEs (art::Ptr< rec::Hit > const &hit) const

std::vector< HitIDE >	HitToHitIDEs (rec::Hit const &hit) const

std::vector< art::Ptr< rec::Hit > >	ParticleToHits (simb::MCParticle *const p, std::vector< art::Ptr< rec::Hit >> const &allhits, bool checkNeutrals=false) const

std::pair< double, double >	HitPurity (simb::MCParticle *const p, std::vector< art::Ptr< rec::Hit >> const &hits, bool weightByCharge=false) const

std::pair< double, double >	HitEfficiency (simb::MCParticle *const p, std::vector< art::Ptr< rec::Hit > > const &hits, std::vector< art::Ptr< rec::Hit > > const &allhits, bool weightByCharge=false) const

std::vector< CalIDE >	CaloHitToCalIDEs (art::Ptr< rec::CaloHit > const &hit) const

std::vector< CalIDE >	CaloHitToCalIDEs (rec::CaloHit const &hit) const

std::vector< art::Ptr< rec::CaloHit > >	ParticleToCaloHits (simb::MCParticle *const p, std::vector< art::Ptr< rec::CaloHit >> const &allhits) const

std::pair< double, double >	CaloHitPurity (simb::MCParticle *const p, std::vector< art::Ptr< rec::CaloHit >> const &hits, bool weightByCharge=false) const

std::pair< double, double >	CaloHitEfficiency (simb::MCParticle *const p, std::vector< art::Ptr< rec::CaloHit >> const &hits, std::vector< art::Ptr< rec::CaloHit >> const &allhits, bool weightByCharge=false) const

std::vector< art::Ptr< rec::Hit > > const	TrackToHits (rec::Track *const t)

std::vector< art::Ptr< rec::Hit > > const	TPCClusterToHits (rec::TPCCluster *const clust)

std::vector< const rec::TPCCluster * > const	TrackToClusters (rec::Track *const t)

std::vector< std::pair< simb::MCParticle *, float > >	TrackToMCParticles (rec::Track *const t)

double	TrackToTotalEnergy (rec::Track *const t)

std::vector< art::Ptr< rec::Track > >	MCParticleToTracks (simb::MCParticle *const p, std::vector< art::Ptr< rec::Track >> const &tracks)

std::vector< art::Ptr< rec::CaloHit > > const	ClusterToCaloHits (rec::Cluster *const c)

std::vector< std::pair< simb::MCParticle *, float > >	ClusterToMCParticles (rec::Cluster *const c)

std::vector< art::Ptr< rec::Cluster > >	MCParticleToClusters (simb::MCParticle *const p, std::vector< art::Ptr< rec::Cluster >> const &clusters)

bool	ClusterCreatedMCParticle (simb::MCParticle const p, rec::Cluster const c)

bool	MCParticleCreatedCluster (simb::MCParticle const p, rec::Cluster const c)

Protected Attributes
bool	fHasMC

bool	fHasHits

bool	fHasCalHits

bool	fHasTracks

bool	fHasClusters

int	fSTFU

const detinfo::DetectorClocks *	fClocks
	Detector clock information. More...

const geo::GeometryCore *	fGeo
	pointer to the geometry More...

bool	fDisableRebuild
	for switching off backtracker's rebuild of the MCParticle tables More...

std::string	fG4ModuleLabel
	label for geant4 module More...

std::string	fRawTPCDataLabel
	label for TPC readout module More...

std::string	fRawCaloDataLabel
	label for ECAL readout module More...

std::string	fRawCaloDataECALInstance
	instance name for the ECAL raw hits More...

double	fECALtimeResolution
	time resolution for hits in ECAL, nsec. More...

double	fMinHitEnergyFraction
	min frac of ionization a track has to count in a TPC hit More...

double	fMinCaloHitEnergyFrac
	min frac of ionization a track has to count in a CaloHit More...

std::string	fTrackLabel
	label for final track producing module More...

std::string	fTPCClusterLabel
	label for TPCCluster producing module More...

double	fTrackFracMCP
	min frac of ionization in a track for matching to an MCParticle More...

std::string	fClusterLabel
	label for ECAL cluster producing module More...

std::string	fClusterECALInstance
	instance name for the ECAL clusters More...

double	fClusterFracMCP
	min frac of ionization in a cluster for matching to an MCParticle More...

sim::ParticleList	fParticleList
	Maps MCParticle::TrackId() to same MCParticle. More...

std::vector< art::Ptr< simb::MCTruth > >	fMCTruthList
	all the MCTruths for the event More...

std::unordered_map< int, int >	fTrackIDToMCTruthIndex

std::unordered_map< int, int > *	fECALTrackToTPCTrack
	results of previous FindTPCEve calls More...

double	fInverseVelocity
	inverse drift velocity More...

double	fLongDiffConst
	longitudinal diffusion constant More...

bool	fSplitEDeps
	use weights from PRFs to break true energy deposits into channel specific contributions More...

std::vector< std::vector< std::pair< const sdp::EnergyDeposit *, float const > > >	fChannelToEDepCol
	convenience collections of EnergyDeposits for each channel More...

std::unordered_map< raw::CellID_t, std::vector< const sdp::CaloDeposit * > >	fCellIDToEDepCol
	convenience collections of EnergyDeposit for each cell More...

std::unordered_map< rec::IDNumber, std::vector< art::Ptr< rec::Hit > > >	fTrackIDToHits
	Reco track ID to track's hits. More...

std::unordered_map< rec::IDNumber, std::vector< const rec::TPCCluster * > >	fTrackIDToClusters
	Reco track ID to track's clusters. More...

std::unordered_map< rec::IDNumber, std::vector< art::Ptr< rec::Hit > > >	fTPCClusterIDToHits
	Reco TPC cluster ID to cluster's hits. More...

std::unordered_map< rec::IDNumber, std::vector< art::Ptr< rec::CaloHit > > >	fClusterIDToCaloHits
	Reco ECAL cluster ID to CaloHits. More...

Private Member Functions
std::vector< HitIDE >	ChannelToHitIDEs (raw::Channel_t const &channel, double const start, double const stop) const

std::vector< CalIDE >	CellIDToCalIDEs (raw::CellID_t const &cellID, float const time) const

std::vector< simb::MCParticle * >	MCPartsInCluster (rec::Cluster *const c)

TLorentzVector	EnergyDepositToMomentum (const int &trackID, const TLorentzVector &position, size_t &startTrajIndex) const

Detailed Description

Definition at line 111 of file BackTrackerCore.h.

Constructor & Destructor Documentation

gar::cheat::BackTrackerCore::BackTrackerCore ( fhicl::ParameterSet const & pset )

explicit

Definition at line 29 of file BackTrackerCore.cxx.

           : fClocks(nullptr), fGeo(nullptr) {
 
             fClocks = gar::providerFrom<detinfo::DetectorClocksServiceGAr>();
             fGeo    = gar::providerFrom<geo::GeometryGAr>();
 
             fDisableRebuild       = pset.get<bool       >("DisableRebuild",           false);
 
             fG4ModuleLabel        = pset.get<std::string>("G4ModuleLabel",           "geant");
 
             fRawTPCDataLabel      = pset.get<std::string>("RawTPCDataLabel",         "daq");
 
             fRawCaloDataLabel         = pset.get<std::string>("RawCaloDataLabel",        "daqsipm");
             fRawCaloDataECALInstance  = pset.get<std::string>("RawCaloDataECALInstance", "ECAL"  );
             fECALtimeResolution       = pset.get<double     >("ECALtimeResolution",       1.0);
             fMinHitEnergyFraction     = pset.get<double     >("MinHitEnergyFraction",     0.1);
             fMinCaloHitEnergyFrac     = pset.get<double     >("MinCaloHitEnergyFrac",     0.1);
 
             fTrackLabel           = pset.get<std::string>("TrackLabel",              "track");
             fTPCClusterLabel      = pset.get<std::string>("TPCClusterLabel",         "tpccluster");
             fTrackFracMCP         = pset.get<double     >("TrackFracMCP",             0.8);
 
             fClusterLabel         = pset.get<std::string>("ClusterLabel",            "calocluster");
             fClusterECALInstance  = pset.get<std::string>("ClusterECALInstance",     "ECAL"  );
             fClusterFracMCP       = pset.get<double     >("ClusterFracMCP",           0.8);
 
             fSplitEDeps           = pset.get<bool       >("SplitEDeps",               true);
 
             fECALTrackToTPCTrack  = new std::unordered_map<int, int>;
             return;
         }

gar::cheat::BackTrackerCore::~BackTrackerCore ( )

Definition at line 62 of file BackTrackerCore.cxx.

62 {}

Member Function Documentation

void gar::cheat::BackTrackerCore::AdoptEveIdCalculator ( sim::EveIdCalculator * ec )

inline

Definition at line 118 of file BackTrackerCore.h.

                                                               {
                 fParticleList.AdoptEveIdCalculator(ec);
             }

std::pair< double, double > gar::cheat::BackTrackerCore::CaloHitEfficiency	(	simb::MCParticle *const	p,
		std::vector< art::Ptr< rec::CaloHit >> const &	hits,
		std::vector< art::Ptr< rec::CaloHit >> const &	allhits,
		bool	weightByCharge = `false`
	)		const

Definition at line 680 of file BackTrackerCore.cxx.

                                                                                       {
 
             if (!fHasMC || !fHasHits) {
                 throw cet::exception("BackTrackerCore::CaloHitEfficiency")
                     << "Attempting to backtrack without MC truth or gar::rec::Hit information";
             }
 
             int trackIDin = p->TrackId();
 
             float weight;
             float desired = 0.0;
             for (auto hit : hits) {
                 std::vector<CalIDE> calIDEs = this->CaloHitToCalIDEs(hit);
 
                 weight = (weightByCharge) ? hit->Energy() : 1.0;
 
                 for (auto iCalIDE : calIDEs) {
                     // Don't double count if this hit has > 1 of the desired GEANT track IDs
                     if (iCalIDE.trackID    == trackIDin &&
                         iCalIDE.energyFrac >= fMinCaloHitEnergyFrac) {
                         desired += weight;
                         break;
                     }
                 }
             } // end loop over hits
 
             // Next figure out how many hits in the whole collection are associated with this id
             float total   = 0.0;
             if (desired>0.0) {
                 for (auto hit : allhits) {
                     std::vector<CalIDE> calIDEs = this->CaloHitToCalIDEs(hit);
 
                     weight = (weightByCharge) ? hit->Energy() : 1.0;
 
                     for (auto iCalIDE : calIDEs) {
                         // Don't double count if this hit has > 1 of the desired GEANT track IDs
                         if (iCalIDE.trackID    == trackIDin &&
                             iCalIDE.energyFrac >= fMinCaloHitEnergyFrac) {
                             total += weight;
                              break;
                         }
                     }
                  } // end loop over all hits
             }
 
             double efficiency  = 0.0;
             double uncertainty = 0.0;
             if (total > 0.0) {
                 efficiency  = desired/total;
                 uncertainty = std::sqrt( desired*(total -desired)/total )/total;
             }
             return std::make_pair(efficiency,uncertainty);
         }

std::pair< double, double > gar::cheat::BackTrackerCore::CaloHitPurity	(	simb::MCParticle *const	p,
		std::vector< art::Ptr< rec::CaloHit >> const &	hits,
		bool	weightByCharge = `false`
	)		const

Definition at line 637 of file BackTrackerCore.cxx.

                                                                                    {
 
             if (!fHasMC || !fHasHits) {
                 throw cet::exception("BackTrackerCore::CaloHitPurity")
                     << "Attempting to backtrack without MC truth or gar::rec::Hit information";
             }
 
 
             int trackIDin = p->TrackId();
 
             float weight;
             float desired = 0.0;
             float total   = 0.0;
             for (auto hit : hits) {
                 std::vector<CalIDE> calIDEs = this->CaloHitToCalIDEs(hit);
 
                 weight = (weightByCharge) ? hit->Energy() : 1.0;
                 total += weight;
 
                 for (auto iCalIDE : calIDEs) {
                     // Don't double count if this hit has > 1 of the desired GEANT trackIDs
                     if (iCalIDE.trackID    == trackIDin &&
                         iCalIDE.energyFrac >= fMinCaloHitEnergyFrac) {
                         desired += weight;
                         break;
                     }
                 }
             } // end loop over hits
 
             double purity      = 0.0;
             double uncertainty = 0.0;
             if (total > 0.0) {
                 purity      = desired/total;
                 uncertainty = std::sqrt( desired*(total -desired)/total )/total;
             }
             return std::make_pair(purity,uncertainty);
         }

std::vector< CalIDE > gar::cheat::BackTrackerCore::CaloHitToCalIDEs ( art::Ptr< rec::CaloHit > const & hit ) const

Definition at line 511 of file BackTrackerCore.cxx.

                                                                              {
             if (!fHasMC || !fHasCalHits) {
                 throw cet::exception("BackTrackerCore::CaloHitToCalIDEs")
                     << "Attempting to backtrack without MC truth or gar::rec::CaloHit information";
             }
 
             // Cut on Time for this hit +/- ECAL time resolution given in BackTracker.fcl
             std::vector<CalIDE> ides;
             ides = this->CellIDToCalIDEs(hit->CellID(),hit->Time().first);
             return ides;
         }

std::vector< CalIDE > gar::cheat::BackTrackerCore::CaloHitToCalIDEs ( rec::CaloHit const & hit ) const

Definition at line 525 of file BackTrackerCore.cxx.

                                                                      {
             if (!fHasMC || !fHasCalHits) {
                 throw cet::exception("BackTrackerCore::CaloHitToCalIDEs")
                     << "Attempting to backtrack without MC truth or gar::rec::CaloHit information";
             }
 
             // Cut on Time for this hit +/- ECALtimeResolution given in BackTracker.fcl
             std::vector<CalIDE> ides;
             ides = this->CellIDToCalIDEs(hit.CellID(),hit.Time().first);
             return ides;
         }

std::vector< CalIDE > gar::cheat::BackTrackerCore::CellIDToCalIDEs	(	raw::CellID_t const &	cellID,
		float const	time
	)		const

private

Definition at line 573 of file BackTrackerCore.cxx.

                                                                  {
 
             // loop over the energy deposits in the channel and grab those in time window
 
             std::vector<CalIDE> calIDEs;
 
             std::vector<const sdp::CaloDeposit*>  cellEDeps;
             try {
                 cellEDeps = fCellIDToEDepCol.at(cell);
             }
             catch (std::out_of_range &) {
                 MF_LOG_WARNING("BackTrackerCore::CellIDToCalIDEs")
                     << "No sdp::EnergyDeposits for selected ECAL cell: " << cell
                     << ". There is no way to backtrack the given calorimeter hit,"
                     << " returning an empty vector.";
                 return calIDEs;
             }
 
             std::map<int,size_t> tidmap;  // Maps track IDs to index into calIDEs
 
             // Get the total energy produced by all track ids for this cell & time
             float start = time -fECALtimeResolution;
             float stop  = time +fECALtimeResolution;
 
             double totalEallTracks = 0.0;
             for (auto const& edep : cellEDeps) {
                 if (edep->TrackID() == sdp::NoParticleId) continue;
 
                 if ( start<=edep->Time() && edep->Time()<=stop) {
                     float energy = edep->Energy();
                     totalEallTracks += energy;
                     int tid = edep->TrackID();
                     // Chase the tid up to the parent which started in the gas.
                     // tid < 0 is possible here, but FindTPCEve calls
                     // TrackIDToParticle, which fixes that little issue.
                     simb::MCParticle* TPCEve = FindTPCEve(tid);
                     int tidTPC;
                     if (TPCEve!=nullptr) {
                         tidTPC = TPCEve->TrackId();
                     } else {
                         tidTPC = tid;
                     }
                     auto tidmapiter = tidmap.find(tidTPC);
                     if (tidmapiter == tidmap.end()) {
                         calIDEs.emplace_back(tidTPC, 0.0, energy);
                         tidmap[tidTPC] = calIDEs.size()-1;
                     } else {
                         calIDEs.at(tidmapiter->second).energyTot += energy;
                     }
                 }
             }
 
             // loop over the hitIDEs to set the fractional energy for each TrackID
             for (size_t i = 0; i < calIDEs.size(); ++i) {
                 calIDEs[i].energyFrac = calIDEs[i].energyTot / totalEallTracks;
             }
             return calIDEs;
         }

std::vector< HitIDE > gar::cheat::BackTrackerCore::ChannelToHitIDEs	(	raw::Channel_t const &	channel,
		double const	start,
		double const	stop
	)		const

private

Definition at line 298 of file BackTrackerCore.cxx.

                                                                                        {
 
             // loop over the energy deposits in the channel and grab those in time window
 
             if(start<0 || stop <0) 
                 MF_LOG_WARNING("BackTrackerCore::ChannelToHitIDEs") << "start and/or stop times are negative!";
             std::vector<HitIDE> hitIDEs;
 
             if(fChannelToEDepCol.size() < channel){
                 MF_LOG_WARNING("BackTrackerCore::ChannelToHitIDEs")
                     << "Attempting to find energy deposits for channel " << channel
                     << " while there are only " << fChannelToEDepCol.size()
                     << " channels available, returning an empty vector.";
                 return hitIDEs;
             }
 
             auto chanEDeps = fChannelToEDepCol[channel];
 
             if(chanEDeps.size() < 1){
                 MF_LOG_WARNING("BackTrackerCore::ChannelToHitIDEs")
                     << "No sdp::EnergyDeposits for selected channel: " << channel
                     << ". There is no way to backtrack the given hit, returning"
                     << " an empty vector.";
                 return hitIDEs;
             }
 
             std::map<int,size_t> tidmap;  // Maps track IDs to index into hitIDEs
 
             // first get the total energy represented by all track ids for
             // this channel and range of tdc values
             unsigned short tdc = 0;
             float chanpos[3]={0.,0.,0};
             fGeo->ChannelToPosition(channel, chanpos);
 
             // loop over all EnergyDeposits for this channel and
             // calculate a weighted average, in contributed energy, 
             // 4-position and 4-momentum
             double totalEallTracks = 0.0;
             size_t itraj=0;
             for (auto const& edepfrac : chanEDeps) {
 
                 auto edep = edepfrac.first;
                 float weight = edepfrac.second;
                 if(weight<0 || weight>1) 
                     MF_LOG_WARNING("BackTrackerCore::ChannelToHitIDEs") << "bad weight (" << weight << ")";
                 if (edep->TrackID() == sdp::NoParticleId) continue;
 
                 tdc = fClocks->TPCG4Time2TDC
                         (edep->Time() +TMath::Abs(edep->X()-chanpos[0]) *fInverseVelocity);
                 if ( (unsigned int)start <= tdc && tdc <= (unsigned int)stop) {
                     float energy = edep->Energy() * weight;
                     MF_LOG_DEBUG("BackTrackerCore::ChannelToHitIDEs") << "edep energy: " << edep->Energy() 
                                  << ", weight: " << weight << ", contributed energy: " << energy;
                     totalEallTracks += energy;
 
                     TLorentzVector simpos(edep->X(),edep->Y(),edep->Z(),edep->Time());
                     TLorentzVector simmom = EnergyDepositToMomentum(edep->TrackID(),simpos,itraj);
                     simpos *= energy;
                     simmom *= energy;
 
 
                     // EnergyDeposits can contain negative track IDs corresponding to tracks
                     // created in showers.  The absolute magnitude of the track is the track
                     // id of the parent of the EM showering process.  That is the particle
                     // to which we want to assign this energy for backtracking purposes.
                     int tid = abs( edep->TrackID() );
                     auto tidmapiter = tidmap.find(tid);
                     if (tidmapiter == tidmap.end()) {
                         hitIDEs.emplace_back(tid, 0.0, energy, simpos, simmom);
                         tidmap[tid] = hitIDEs.size()-1;
                     } else {
                         hitIDEs.at(tidmapiter->second).energyTot += energy;
                         hitIDEs.at(tidmapiter->second).position += simpos;
                         hitIDEs.at(tidmapiter->second).momentum += simmom;
                     }
                 }
             }
 
             /* DEB hits without edeps
             std::cout << "Channel " << channel << ", at (z,y) = (" << chanpos[2] << ", "
                 << chanpos[1] << ") has " << chanEDeps.size() << " edeps, and " <<
                 hitIDEs.size() << " are in-time between " << start << " and " << stop
                 << std::endl; */
 
             // loop over the hitIDEs to set the fractional energy for each TrackID
             for (size_t i = 0; i < hitIDEs.size(); ++i) {
                 hitIDEs[i].energyFrac = hitIDEs[i].energyTot / totalEallTracks;
                 hitIDEs[i].position *= 1.0/totalEallTracks;
                 hitIDEs[i].momentum *= 1.0/totalEallTracks;
             }
 
             // remove duplicate HitIDEs (not that any should be there)
             size_t nbefore = hitIDEs.size();
             std::sort(hitIDEs.begin(),hitIDEs.end());
             hitIDEs.erase(std::unique(hitIDEs.begin(),hitIDEs.end()),hitIDEs.end());
             size_t nafter = hitIDEs.size();
             if(nbefore!=nafter) 
               MF_LOG_WARNING("BackTrackerCore::ChannelToHitIDEs") << "found and removed " 
                              << nbefore-nafter << " duplicate HitIDEs (not expected for single channel)";
 
             return hitIDEs;
         }

bool gar::cheat::BackTrackerCore::ClusterCreatedMCParticle	(	simb::MCParticle *const	p,
		rec::Cluster *const	c
	)

Definition at line 1013 of file BackTrackerCore.cxx.

                                                                             {
             std::vector<simb::MCParticle*> partsIsParts = MCPartsInCluster(c);
             for (simb::MCParticle* clusPart : partsIsParts) {
                 if (IsForebearOf(clusPart,p)) return true;
             }
             return false;
         }

std::vector< art::Ptr< rec::CaloHit > > const gar::cheat::BackTrackerCore::ClusterToCaloHits ( rec::Cluster *const c )

Definition at line 919 of file BackTrackerCore.cxx.

                                                               {
 
             // Evidently, use of std::unordered_map keeps this method from being const
             std::vector<art::Ptr<gar::rec::CaloHit>> retval;
             if ( !fClusterIDToCaloHits.empty() ) {
                 retval = fClusterIDToCaloHits[ c->getIDNumber() ];
             }
             return retval;
         }

std::vector< std::pair< simb::MCParticle *, float > > gar::cheat::BackTrackerCore::ClusterToMCParticles ( rec::Cluster *const c )

Definition at line 933 of file BackTrackerCore.cxx.

                                                                  {
             // Can't be const because it uses TrackToHits
 
             std::vector<art::Ptr<gar::rec::CaloHit>> const hitCol = ClusterToCaloHits(c);
             std::vector<CalIDE> hitIDECol;
             for (auto hit : hitCol) {
                 std::vector<CalIDE> IDEsThisHit = CaloHitToCalIDEs(hit);
                 hitIDECol.insert(hitIDECol.end(), IDEsThisHit.begin(),IDEsThisHit.end());
             }
 
             // A tree is a good way to accumulate the info we need
             std::map<int,float> lClusterIdToEnergy;
             for (auto calIDE : hitIDECol) {
                 simb::MCParticle* thisTrack     = TrackIDToParticle(calIDE.trackID);
                 simb::MCParticle* incomingTrack = FindTPCEve(thisTrack);
                 int iTrackID = incomingTrack->TrackId();
                 lClusterIdToEnergy[iTrackID] += calIDE.energyFrac * calIDE.energyTot;
             }
 
             // Next, sort the map by value.
             // Declaring the type of the sorting predicate
             typedef std::function<bool(std::pair<int,float>, std::pair<int,float>)> Comparator;
             // Declaring a set that will store the pairs using above comparison logic
             std::set<std::pair<int,float>, Comparator> setOfTracks(
                 lClusterIdToEnergy.begin(), lClusterIdToEnergy.end(),
                 [](std::pair<int,float> a ,std::pair<int,float> b) {
                     return a.second > b.second;
                 }
             );
 
             // Make the returned vector.  Could have no tracks at all?
             float Etot = 0.0;
             auto iTrackSet = setOfTracks.begin();
             for (; iTrackSet!=setOfTracks.end(); ++iTrackSet) {
                 Etot += iTrackSet->second;   // Can't do this in loop on lClusterIdToEnergy
             }
 
             std::pair<simb::MCParticle*,float> emptee(nullptr,0.0);
             std::vector<std::pair<simb::MCParticle*,float>> retval(lClusterIdToEnergy.size(),emptee);
 
             std::vector<std::pair<simb::MCParticle*,float>>::iterator iRetval = retval.begin();
             iTrackSet = setOfTracks.begin();
             for (; iTrackSet != setOfTracks.end(); ++iTrackSet,++iRetval) {
                 iRetval->first   = TrackIDToParticle(iTrackSet->first);
                 iRetval->second  = iTrackSet->second / Etot;
             }
 
             return retval;
         }

TLorentzVector gar::cheat::BackTrackerCore::EnergyDepositToMomentum	(	const int &	trackID,
		const TLorentzVector &	position,
		size_t &	startTrajIndex
	)		const

private

Definition at line 1066 of file BackTrackerCore.cxx.

                                                                                             {
 
             auto const& mcp = TrackIDToParticle(trackID); // MCParticle
             float dr=FLT_MAX, dt=FLT_MAX; // spatial and temporal distance
 
             // stepping through the trajectory, the distance should decrease until
             // min dist found (could be starting point)
             for(;startTrajIndex<mcp->NumberTrajectoryPoints(); startTrajIndex++){
 
                 if(   (position - mcp->Position(startTrajIndex)).Vect().Mag() < dr &&
                   abs((position - mcp->Position(startTrajIndex)).T()) < dt) {
 
                     dr = (position - mcp->Position(startTrajIndex)).Vect().Mag();
                     dt = abs((position - mcp->Position(startTrajIndex)).T());
                 } else {
                             break;
                 }
 
             } // for trajectory points
 
             return  mcp->Momentum(startTrajIndex);
 
         } // def EnergyDepositToMomentum()

simb::MCParticle * gar::cheat::BackTrackerCore::FindEve ( simb::MCParticle *const p ) const

Definition at line 95 of file BackTrackerCore.cxx.

                                                                                {
             if (!fHasMC) {
                 throw cet::exception("BackTrackerCore::FindEve")
                     << "Attempting to backtrack without MC truth information";
             }
 
             int EveTrackId = fParticleList.EveId( p->TrackId() );
             return TrackIDToParticle(EveTrackId);
         }

simb::MCParticle* gar::cheat::BackTrackerCore::FindMother ( simb::MCParticle *const p ) const

inline

Definition at line 146 of file BackTrackerCore.h.

                                                                        {
                 // Always walk up the ParticleList in case someday somebody changes it
                 return TrackIDToParticle(p->Mother());
             }

simb::MCParticle * gar::cheat::BackTrackerCore::FindTPCEve ( simb::MCParticle *const p ) const

Definition at line 108 of file BackTrackerCore.cxx.

                                                                                   {
             if (!fHasMC) {
                 throw cet::exception("BackTrackerCore::FindTPCEve")
                     << "Attempting to backtrack without MC truth information";
             }
 
             // If I had ever been here before I would probably know just what to do / Don't you?
             int dejaVu = p->TrackId();
             if ( fECALTrackToTPCTrack->find(dejaVu) != fECALTrackToTPCTrack->end() ) {
                 return TrackIDToParticle( fECALTrackToTPCTrack->at(dejaVu) );
             }
 
             simb::MCParticle* walker  = p;
             if (walker==nullptr) return nullptr;
             while ( walker != nullptr &&
                 !fGeo->PointInGArTPC( TVector3(walker->Vx(),walker->Vy(),walker->Vz()) ) ) {
                 // Walk up the ParticleList not the event store so someday somebody can
                 // change the ParticleList and this will still work.
                 int mommaTID = fParticleList[walker->TrackId()]->Mother();
                 if (mommaTID == 0) {
                     // you are at the top of the tree
                     break;
                 }
                 simb::MCParticle* momma = TrackIDToParticle( mommaTID );
                 walker = momma;
             }
             (*fECALTrackToTPCTrack)[dejaVu] = walker->TrackId();
             return walker;
          }

simb::MCParticle * gar::cheat::BackTrackerCore::FindTPCEve ( int const trackId ) const

Definition at line 141 of file BackTrackerCore.cxx.

                                                                       {
             if (!fHasMC) {
                 throw cet::exception("BackTrackerCore::FindTPCEve")
                     << "Attempting to backtrack without MC truth information";
             }
 
             // If I had ever been here before I would probably know just what to do / Don't you?
             if ( fECALTrackToTPCTrack->find(trackID) != fECALTrackToTPCTrack->end() ) {
                 return TrackIDToParticle( fECALTrackToTPCTrack->at(trackID) );
             }
 
             // Negative track ID, as found in EnergyDeposit or CaloEnergyDeposit,
             // gets turned into positve track ID corresponding to parent of EM
             // that created that particular EnergyDeposit or CaloEnergyDeposit
             simb::MCParticle* walker  = TrackIDToParticle(trackID);
             while ( walker != nullptr &&
                 !fGeo->PointInGArTPC( TVector3(walker->Vx(),walker->Vy(),walker->Vz()) ) ) {
                 // Walk up the ParticleList not the event store so someday somebody can
                 // change the ParticleList and this will still work.
                int mommaTID = fParticleList[walker->TrackId()]->Mother();
                if (mommaTID == 0) {
                     // you are at the top of the tree
                     break;
                 }
                 simb::MCParticle* momma = TrackIDToParticle( mommaTID );
                 walker = momma;
             }
 
             (*fECALTrackToTPCTrack)[trackID] = walker->TrackId();
             return walker;
          }

sim::ParticleList* gar::cheat::BackTrackerCore::GetParticleList ( )

inline

Definition at line 137 of file BackTrackerCore.h.

                                                {
                 return &fParticleList;
             }

bool gar::cheat::BackTrackerCore::HasCalHits ( )

inline

Definition at line 125 of file BackTrackerCore.h.

125 {return fHasCalHits; }

gar::cheat::BackTrackerCore::fHasCalHits

bool fHasCalHits

Definition: BackTrackerCore.h:284

bool gar::cheat::BackTrackerCore::HasClusters ( )

inline

Definition at line 127 of file BackTrackerCore.h.

127 {return fHasClusters;}

gar::cheat::BackTrackerCore::fHasClusters

bool fHasClusters

Definition: BackTrackerCore.h:284

bool gar::cheat::BackTrackerCore::HasHits ( )

inline

Definition at line 124 of file BackTrackerCore.h.

124 {return fHasHits; }

gar::cheat::BackTrackerCore::fHasHits

bool fHasHits

Definition: BackTrackerCore.h:284

bool gar::cheat::BackTrackerCore::HasMC ( )

inline

Definition at line 123 of file BackTrackerCore.h.

123 {return fHasMC; }

gar::cheat::BackTrackerCore::fHasMC

bool fHasMC

Definition: BackTrackerCore.h:284

bool gar::cheat::BackTrackerCore::HasTracks ( )

inline

Definition at line 126 of file BackTrackerCore.h.

126 {return fHasTracks; }

gar::cheat::BackTrackerCore::fHasTracks

bool fHasTracks

Definition: BackTrackerCore.h:284

std::pair< double, double > gar::cheat::BackTrackerCore::HitEfficiency	(	simb::MCParticle *const	p,
		std::vector< art::Ptr< rec::Hit > > const &	hits,
		std::vector< art::Ptr< rec::Hit > > const &	allhits,
		bool	weightByCharge = `false`
	)		const

Definition at line 449 of file BackTrackerCore.cxx.

                                                                                   {
 
             if (!fHasMC || !fHasHits) {
                 throw cet::exception("BackTrackerCore::HitCollectionEfficiency")
                     << "Attempting to backtrack without MC truth or gar::rec::Hit information";
             }
 
             int trackIDin = p->TrackId();
 
             float weight;
             float desired = 0.0;
             for (auto hit : hits) {
                 std::vector<HitIDE> hitIDEs = this->HitToHitIDEs(hit);
 
                 weight = (weightByCharge) ? hit->Signal() : 1.0;
 
                 for (auto iHitIDE : hitIDEs) {
                     // Don't double count if this hit has > 1 of the desired GEANT track IDs
                     if (iHitIDE.trackID    == trackIDin &&
                         iHitIDE.energyFrac >= fMinHitEnergyFraction) {
                         desired += weight;
                         break;
                     }
                 }
             } // end loop over hits
 
             // Next figure out how many hits in the whole collection are associated with this id
             float total   = 0.0;
             if (desired>0) {
                 for (auto hit : allhits) {
                     std::vector<HitIDE> hitIDEs = this->HitToHitIDEs(hit);
 
                     weight = (weightByCharge) ? hit->Signal() : 1.0;
 
                     for (auto iHitIDE : hitIDEs) {
                         // Don't double count if this hit has > 1 of the desired GEANT track IDs
                         if (iHitIDE.trackID   == trackIDin &&
                            iHitIDE.energyFrac >= fMinHitEnergyFraction) {
                            total += weight;
                            break;
                         }
                     }
                 } // end loop over all hits
             }
 
             double efficiency  = 0.0;
             double uncertainty = 0.0;
             if (total > 0.0) {
                 efficiency  = desired/total;
                 uncertainty = std::sqrt( desired*(total -desired)/total )/total;
             }
             return std::make_pair(efficiency,uncertainty);
         }

std::pair< double, double > gar::cheat::BackTrackerCore::HitPurity	(	simb::MCParticle *const	p,
		std::vector< art::Ptr< rec::Hit >> const &	hits,
		bool	weightByCharge = `false`
	)		const

Definition at line 406 of file BackTrackerCore.cxx.

                                                                                {
 
             if (!fHasMC || !fHasHits) {
                 throw cet::exception("BackTrackerCore::HitCollectionPurity")
                     << "Attempting to backtrack without MC truth or gar::rec::Hit information";
             }
 
 
             int trackIDin = p->TrackId();
 
             float weight;
             float desired = 0.0;
             float total   = 0.0;
             for (auto hit : hits) {
                 std::vector<HitIDE> hitIDEs = this->HitToHitIDEs(hit);
 
                 weight = (weightByCharge) ? hit->Signal() : 1.0;
                 total += weight;
 
                 for (auto iHitIDE : hitIDEs) {
                     // Don't double count if this hit has > 1 of the desired GEANT trackIDs
                     if (iHitIDE.trackID    == trackIDin &&
                         iHitIDE.energyFrac >= fMinHitEnergyFraction) {
                         desired += weight;
                         break;
                     }
                 }
             } // end loop over hits
 
             double purity      = 0.0;
             double uncertainty = 0.0;
             if (total > 0.0) {
                 purity      = desired/total;
                 uncertainty = std::sqrt( desired*(total -desired)/total )/total;
             }
             return std::make_pair(purity,uncertainty);
         }

std::vector< HitIDE > gar::cheat::BackTrackerCore::HitToHitIDEs ( art::Ptr< rec::Hit > const & hit ) const

Definition at line 225 of file BackTrackerCore.cxx.

                                                                      {
             if (!fHasMC || !fHasHits) {
                 throw cet::exception("BackTrackerCore::HitToHitIDEs")
                     << "Attempting to backtrack without MC truth or gar::rec::Hit information";
             }
 
             // By cutting on the StartTime and EndTime for this hit, we get only the
             // IDEs for this hit; ides.size() should basically be the number of
             // MCParticles that contributed to this hit.
             std::vector<HitIDE> ides;
             ides = this->ChannelToHitIDEs(hit->Channel(),hit->StartTime(),hit->EndTime());
             return ides;
         }

std::vector< HitIDE > gar::cheat::BackTrackerCore::HitToHitIDEs ( rec::Hit const & hit ) const

Definition at line 241 of file BackTrackerCore.cxx.

                                                              {
             if (!fHasMC || !fHasHits) {
                 throw cet::exception("BackTrackerCore::HitToHitIDEs")
                     << "Attempting to backtrack without MC truth or gar::rec::Hit information";
             }
 
             // By cutting on the StartTime and EndTime for this hit, we get only the
             // IDEs for this hit; ides.size() should basically be the number of
             // MCParticles that contributed to this hit.
             std::vector<HitIDE> ides;
             ides = this->ChannelToHitIDEs(hit.Channel(),hit.StartTime(),hit.EndTime());
             return ides;
         }

bool gar::cheat::BackTrackerCore::IsForebearOf	(	simb::MCParticle *const	forebear,
		simb::MCParticle *const	afterbear
	)		const

Definition at line 176 of file BackTrackerCore.cxx.

                                                                                   {
             if (!fHasMC) {
                 throw cet::exception("BackTrackerCore::IsForebearOf")
                     << "Attempting to backtrack without MC truth information";
             }
 
             if (forebear==nullptr || afterbear==nullptr) return false;
 
             int stopper = forebear->TrackId();
             int walker  = afterbear->TrackId();
             while ( walker!=stopper ) {
                 // Walk up the ParticleList not the event store so someday somebody can
                 // change the ParticleList and this will still work.
                 int momma = fParticleList[walker]->Mother();
                 if (momma == 0) {
                     return false;
                 } else {
                     walker = momma;
                 }
             }
             return true;
          }

bool gar::cheat::BackTrackerCore::MCParticleCreatedCluster	(	simb::MCParticle *const	p,
		rec::Cluster *const	c
	)

Definition at line 1025 of file BackTrackerCore.cxx.

                                                                             {
             std::vector<simb::MCParticle*> partsIsParts = MCPartsInCluster(c);
 
             for (simb::MCParticle* clusPart : partsIsParts) {
                 if (IsForebearOf(p,clusPart)) return true;
             }
             return false;
         }

std::vector< art::Ptr< rec::Cluster > > gar::cheat::BackTrackerCore::MCParticleToClusters	(	simb::MCParticle *const	p,
		std::vector< art::Ptr< rec::Cluster >> const &	clusters
	)

Definition at line 987 of file BackTrackerCore.cxx.

                                                                             {
 
             // Can't be const because it uses ClusterToMCParticles
             std::vector<art::Ptr<rec::Cluster>> retval;
             std::vector<std::pair<simb::MCParticle*,float>> fromMatch;
             int desiredTrackId = p->TrackId();
 
             for (art::Ptr<rec::Cluster> iCluster : clusters) {
                // de-ref the art::Ptr and create a bare pointer for
                // TrackToMCParticles call, managing const-correctness as best we can
                rec::Cluster* argument = const_cast<rec::Cluster*>( &(*iCluster) );
                fromMatch = ClusterToMCParticles( argument );
                for (std::pair<simb::MCParticle*,float> matches : fromMatch) {
                    if ( matches.first->TrackId() == desiredTrackId &&
                         matches.second           >  fClusterFracMCP) {
                        retval.push_back( iCluster );
                    }
                }
             }
             return retval;
         }

std::vector< art::Ptr< rec::Track > > gar::cheat::BackTrackerCore::MCParticleToTracks	(	simb::MCParticle *const	p,
		std::vector< art::Ptr< rec::Track >> const &	tracks
	)

Definition at line 890 of file BackTrackerCore.cxx.

                                                        {
 
             // Can't be const because it uses TrackToMCParticles
             std::vector<art::Ptr<rec::Track>> retval;
             std::vector<std::pair<simb::MCParticle*,float>> fromMatch;
             int desiredTrackId = p->TrackId();
 
             for (art::Ptr<rec::Track> iTrack : tracks) {
                 // de-ref the art::Ptr and create a bare pointer for
                 // TrackToMCParticles call, managing const-correctness as best we can
                 rec::Track* argument = const_cast<rec::Track*>( &(*iTrack) );
                 fromMatch = TrackToMCParticles( argument );
                 for (std::pair<simb::MCParticle*,float> matches : fromMatch) {
                     if ( matches.first->TrackId() == desiredTrackId &&
                           matches.second           >  fTrackFracMCP) {
                         retval.push_back( iTrack );
                     }
                 }
             }
             return retval;
         }

std::vector< simb::MCParticle * > gar::cheat::BackTrackerCore::MCPartsInCluster ( rec::Cluster *const c )

private

Definition at line 1039 of file BackTrackerCore.cxx.

                                                              {
 
             std::vector<int> trackIdsInCluster;
             std::vector<art::Ptr<rec::CaloHit>> const caloHits = ClusterToCaloHits(c);
             for (art::Ptr iCaloHit : caloHits) {
                 std::vector<CalIDE> IDEsThisHit = CaloHitToCalIDEs(iCaloHit);
                 for ( CalIDE iIDE : IDEsThisHit ) trackIdsInCluster.push_back(iIDE.trackID);
             }
 
             std::sort(trackIdsInCluster.begin(),trackIdsInCluster.end());
             std::vector<int>::iterator itr =
                 std::unique(trackIdsInCluster.begin(),trackIdsInCluster.end());
             trackIdsInCluster.resize(std::distance(trackIdsInCluster.begin(),itr));
 
             std::vector<simb::MCParticle*> retval;
             for ( int trackId : trackIdsInCluster) {
                 simb::MCParticle* pahtay = TrackIDToParticle(trackId);
                 retval.push_back(pahtay);
             }
             return retval;
         }

std::vector< art::Ptr< rec::CaloHit > > gar::cheat::BackTrackerCore::ParticleToCaloHits	(	simb::MCParticle *const	p,
		std::vector< art::Ptr< rec::CaloHit >> const &	allhits
	)		const

Definition at line 541 of file BackTrackerCore.cxx.

                                                                                                 {
             // returns a subset of the CaloHits in the allhits collection that match
             // the MC particle passed as an argument
 
             if (!fHasMC || !fHasHits) {
                 throw cet::exception("BackTrackerCore::ParticleToCaloHits")
                     << "Attempting to backtrack without MC truth or gar::rec::CaloHit information";
             }
 
             std::vector<art::Ptr<rec::CaloHit>> calHitList;
             int tkID = p->TrackId();
             std::vector<CalIDE> calhids;
 
             for (auto hit : allhits) {
                 calhids.clear();
 
                 calhids = this->CellIDToCalIDEs(hit->CellID(),hit->Time().first);
 
                 for (auto const& hid : calhids) {
                     if ( hid.trackID==tkID && hid.energyFrac>fMinCaloHitEnergyFrac ) {
                         calHitList.push_back(hit);
                    }
                 }
             }
             return calHitList;
         }

std::vector< art::Ptr< rec::Hit > > gar::cheat::BackTrackerCore::ParticleToHits	(	simb::MCParticle *const	p,
		std::vector< art::Ptr< rec::Hit >> const &	allhits,
		bool	checkNeutrals = `false`
	)		const

Definition at line 259 of file BackTrackerCore.cxx.

                                                                   {
             // returns a subset of the hits in the allhits collection that match
             // the MC particle passed as an argument
 
             if (!fHasMC || !fHasHits) {
                 throw cet::exception("BackTrackerCore::ParticleToHits")
                     << "Attempting to backtrack without MC truth or gar::rec::Hit information";
             }
 
             std::vector<art::Ptr<rec::Hit>> hitList;
             int PDGpid = p->PdgCode();
             bool obviousNeutral = PDGpid==22 || PDGpid==2112 || PDGpid==111 ||
                                   abs(PDGpid)==14 || abs(PDGpid)==12;
             if (!checkNeutrals && obviousNeutral) return hitList;
 
             int tkID = p->TrackId();
             std::vector<HitIDE> hids;
 
             for (auto hit : allhits) {
                 hids.clear();
 
                 hids = this->ChannelToHitIDEs(hit->Channel(),hit->StartTime(),hit->EndTime());
 
                 for (auto const& hid : hids) {
                     if ( hid.trackID==tkID && hid.energyFrac>fMinHitEnergyFraction ) {
                         hitList.push_back(hit);
                     }
                 }
             }
 
             return hitList;
         }

art::Ptr< simb::MCTruth > const gar::cheat::BackTrackerCore::ParticleToMCTruth ( simb::MCParticle *const p ) const

Definition at line 204 of file BackTrackerCore.cxx.

                                                                         {
             if (!fHasMC) {
                 throw cet::exception("BackTrackerCore::ParticleToMCTruth")
                     << "Attempting to backtrack without MC truth information";
             }
 
             int id = p->TrackId();
             // find the entry in the MCTruth collection for this track id.
             // The std::map fTrackIDToMCTrutheIndex will not contain keys < 0
             size_t mct = fTrackIDToMCTruthIndex.find(std::abs(id))->second;
 
             if( mct > fMCTruthList.size() ) {
                 throw cet::exception("BackTrackerCore::ParticleToMCTruth")
                     << "attempting to find MCTruth index for out-of-range value: "
                     << mct << "/" << fMCTruthList.size();
             }
             return fMCTruthList[mct];
         }

std::vector< art::Ptr< rec::Hit > > const gar::cheat::BackTrackerCore::TPCClusterToHits ( rec::TPCCluster *const clust )

Definition at line 763 of file BackTrackerCore.cxx.

                                                                     {
 
             // Evidently, use of std::unordered_map keeps this method from being const
             std::vector<art::Ptr<gar::rec::Hit>> retval;
             if ( !fTPCClusterIDToHits.empty() ) {
                 retval = fTPCClusterIDToHits[ clust->getIDNumber() ];
             }
             return retval;
         }

simb::MCParticle * gar::cheat::BackTrackerCore::TrackIDToParticle ( int const & id ) const

Definition at line 69 of file BackTrackerCore.cxx.

                                                                                {
             if (!fHasMC) {
                 throw cet::exception("BackTrackerCore::TrackIDToParticle")
                     << "Attempting to backtrack without MC truth information";
             }
 
             // What to do for negative trackID?  ParticleList::find(key) does
             // std::map<int,simb::MCParticle*>.find( abs(key) ) so a track ID
             // corresponding to a radiated photon for example gets the original
             // parent of that photon.  In most parts of GArSoft, trackIDs are
             // non-negative; the exception is in the EnergyDeposit class.
             auto part_it = fParticleList.find(id);
 
             if (part_it == fParticleList.end()) {
                 MF_LOG_WARNING("BackTrackerCore::TrackIDToParticle")
                     << "can't find particle with track id " << id
                     << " in sim::ParticleList returning null pointer";
                     return nullptr;
             }
 
             return part_it->second;
         }

std::vector< const rec::TPCCluster * > const gar::cheat::BackTrackerCore::TrackToClusters ( rec::Track *const t )

Definition at line 776 of file BackTrackerCore.cxx.

                                                           {
 
             // Evidently, use of std::unordered_map keeps this method from being const
             //std::vector<art::Ptr<gar::rec::TPCCluster>> retval;
             std::vector<const gar::rec::TPCCluster*> retval;
             if ( !fTrackIDToClusters.empty() ) {
                 retval = fTrackIDToClusters[ t->getIDNumber() ];
             }
             return retval;     
         }

std::vector< art::Ptr< rec::Hit > > const gar::cheat::BackTrackerCore::TrackToHits ( rec::Track *const t )

Definition at line 742 of file BackTrackerCore.cxx.

                                                       {
 
             //std::cout << "BT:TrackToHits called, read map with " << fTrackIDToHits.size() << " entries" << std::endl;
 
             // Evidently, use of std::unordered_map keeps this method from being const
             std::vector<art::Ptr<gar::rec::Hit>> retval;
             if ( !fTrackIDToHits.empty() ) {
                 retval = fTrackIDToHits[ t->getIDNumber() ];
             }
             // useful for debugging, but reduces performance 
             /*size_t nduplicate = 0;
             for(size_t i=0; i<retval.size(); i++) {
               for(size_t j=i+1; j<retval.size(); j++) {
                 if(*retval[i]==*retval[j]) nduplicate++;
               }
             }
             if(nduplicate!=0) std::cout << nduplicate << " duplicate hits matched to track" << std::endl;*/
             return retval;
         }

std::vector< std::pair< simb::MCParticle *, float > > gar::cheat::BackTrackerCore::TrackToMCParticles ( rec::Track *const t )

Definition at line 823 of file BackTrackerCore.cxx.

                                                              {
             // Can't be const because it uses TrackToHits
 
             std::vector<art::Ptr<gar::rec::Hit>> const hitCol = TrackToHits(t);
             std::vector<HitIDE> hitIDECol;
             for (auto hit : hitCol) {
                 std::vector<HitIDE> IDEsThisHit = HitToHitIDEs(hit);
                 hitIDECol.insert(hitIDECol.end(), IDEsThisHit.begin(),IDEsThisHit.end());
             }
 
             // A tree to accumulate the found energy for each GEANT/GENIE track
             std::map<int,float> lTrackIdToEnergy;
             for (auto hitIDE : hitIDECol) {
                 lTrackIdToEnergy[hitIDE.trackID] += hitIDE.energyFrac * hitIDE.energyTot;
             }
 
             // There are still electrons in lTrackIdToEnergy that have parents in
             // lTrackIDToEnergy... these should be consolidated.  Also find total Energy
             std::map<int,float>::iterator iTrackIdTo = lTrackIdToEnergy.begin();
             for (; iTrackIdTo != lTrackIdToEnergy.end(); ++iTrackIdTo) {
                 simb::MCParticle* iPart = TrackIDToParticle(iTrackIdTo->first);
                 if ( iPart->PdgCode() == 11 && iPart->Mother()!=0 ) {
                     if ( lTrackIdToEnergy.count(iPart->Mother())==1 ) {
                         lTrackIdToEnergy[iPart->Mother()] += iTrackIdTo->second;
                         iTrackIdTo = lTrackIdToEnergy.erase(iTrackIdTo);
                         if (iTrackIdTo != lTrackIdToEnergy.begin()) --iTrackIdTo;
                     }
                 }
             }
 
             // Next, sort the map by value.  If there are two entries with the exact same
             // ionization, only one is found in resulting set!  But the digitization scale
             // for edep is eVs (single molecular ionizations) i.e. 1e-5 or less so this should
             // be negligible for tracks of interesting ionizations.
             // Declaring the type of the sorting predicate
             typedef std::function<bool(std::pair<int,float>, std::pair<int,float>)> Comparator;
             // Declaring a set that will store the pairs using above comparison logic
             std::set<std::pair<int,float>, Comparator> setOfTracks(
                 lTrackIdToEnergy.begin(), lTrackIdToEnergy.end(),
                 [](std::pair<int,float> a ,std::pair<int,float> b) {
                     return a.second > b.second;
                 }
             );
 
             // Make the returned vector
             float Etot = 0.0;
             auto iTrackSet = setOfTracks.begin();
             for (; iTrackSet!=setOfTracks.end(); ++iTrackSet) {
                 Etot += iTrackSet->second;   // Can't do this in loop on lTrackIdToEnergy
             }
 
             std::pair<simb::MCParticle*,float> emptee(nullptr,0.0);
             std::vector<std::pair<simb::MCParticle*,float>> retval(setOfTracks.size(),emptee);
             std::vector<std::pair<simb::MCParticle*,float>>::iterator iRetval = retval.begin();
             iTrackSet = setOfTracks.begin();
             for (; iTrackSet != setOfTracks.end(); ++iTrackSet,++iRetval) {
                 iRetval->first   = TrackIDToParticle(iTrackSet->first);
                 iRetval->second  = iTrackSet->second / Etot;
             }
 
             return retval;
         }

double gar::cheat::BackTrackerCore::TrackToTotalEnergy ( rec::Track *const t )

Definition at line 788 of file BackTrackerCore.cxx.

                                                                     {
 
             double etot = 0.; // total energy
             std::vector<art::Ptr<rec::Hit>> const hits = TrackToHits(t); // all of this track's hits
             std::vector<HitIDE> allIdes;
 
             // loop over hits, get IDEs, and sum up energy deposits
             for(auto const& hit : hits) {
                 std::vector<HitIDE> ides = HitToHitIDEs(hit);
                 allIdes.insert(allIdes.end(),ides.begin(),ides.end());
 
             }// for hits
 
             /*size_t pretotal = allIdes.size();
 
             // remove duplicate HitIdes
             // comment out for now since we could have meaningful duplicate HitIDEs 
             // e.g. a common sdp::EnergyDeposit split evenly among channels
             std::sort(allIdes.begin(),allIdes.end());
             allIdes.erase( std::unique(allIdes.begin(),allIdes.end()), allIdes.end());
             size_t posttotal = allIdes.size();
 
             if(pretotal!=posttotal) std::cout << "removed " << pretotal-posttotal << " duplicated IDEs" << std::endl;*/
 
             for(auto const& ide : allIdes) {
                 etot += ide.energyTot;
             }// for ides
 
             return etot;
         }

Member Data Documentation

std::unordered_map<raw::CellID_t,std::vector<const sdp::CaloDeposit*> > gar::cheat::BackTrackerCore::fCellIDToEDepCol

protected

convenience collections of EnergyDeposit for each cell

Definition at line 320 of file BackTrackerCore.h.

std::vector<std::vector<std::pair<const sdp::EnergyDeposit*, float const> > > gar::cheat::BackTrackerCore::fChannelToEDepCol

protected

convenience collections of EnergyDeposits for each channel

Definition at line 316 of file BackTrackerCore.h.

const detinfo::DetectorClocks* gar::cheat::BackTrackerCore::fClocks

protected

Detector clock information.

Definition at line 287 of file BackTrackerCore.h.

std::string gar::cheat::BackTrackerCore::fClusterECALInstance

protected

instance name for the ECAL clusters

Definition at line 302 of file BackTrackerCore.h.

double gar::cheat::BackTrackerCore::fClusterFracMCP

protected

min frac of ionization in a cluster for matching to an MCParticle

Definition at line 303 of file BackTrackerCore.h.

std::unordered_map< rec::IDNumber, std::vector<art::Ptr<rec::CaloHit> > > gar::cheat::BackTrackerCore::fClusterIDToCaloHits

protected

Reco ECAL cluster ID to CaloHits.

Definition at line 336 of file BackTrackerCore.h.

std::string gar::cheat::BackTrackerCore::fClusterLabel

protected

label for ECAL cluster producing module

Definition at line 301 of file BackTrackerCore.h.

bool gar::cheat::BackTrackerCore::fDisableRebuild

protected

for switching off backtracker's rebuild of the MCParticle tables

Definition at line 290 of file BackTrackerCore.h.

double gar::cheat::BackTrackerCore::fECALtimeResolution

protected

time resolution for hits in ECAL, nsec.

Definition at line 295 of file BackTrackerCore.h.

std::unordered_map<int, int>* gar::cheat::BackTrackerCore::fECALTrackToTPCTrack

protected

results of previous FindTPCEve calls

Definition at line 309 of file BackTrackerCore.h.

std::string gar::cheat::BackTrackerCore::fG4ModuleLabel

protected

label for geant4 module

Definition at line 291 of file BackTrackerCore.h.

const geo::GeometryCore* gar::cheat::BackTrackerCore::fGeo

protected

pointer to the geometry

Definition at line 288 of file BackTrackerCore.h.

bool gar::cheat::BackTrackerCore::fHasCalHits

protected

Definition at line 284 of file BackTrackerCore.h.

bool gar::cheat::BackTrackerCore::fHasClusters

protected

Definition at line 284 of file BackTrackerCore.h.

bool gar::cheat::BackTrackerCore::fHasHits

protected

Definition at line 284 of file BackTrackerCore.h.

bool gar::cheat::BackTrackerCore::fHasMC

protected

Definition at line 284 of file BackTrackerCore.h.

bool gar::cheat::BackTrackerCore::fHasTracks

protected

Definition at line 284 of file BackTrackerCore.h.

double gar::cheat::BackTrackerCore::fInverseVelocity

protected

inverse drift velocity

Definition at line 311 of file BackTrackerCore.h.

double gar::cheat::BackTrackerCore::fLongDiffConst

protected

longitudinal diffusion constant

Definition at line 312 of file BackTrackerCore.h.

std::vector<art::Ptr<simb::MCTruth> > gar::cheat::BackTrackerCore::fMCTruthList

protected

all the MCTruths for the event

Definition at line 306 of file BackTrackerCore.h.

double gar::cheat::BackTrackerCore::fMinCaloHitEnergyFrac

protected

min frac of ionization a track has to count in a CaloHit

Definition at line 297 of file BackTrackerCore.h.

double gar::cheat::BackTrackerCore::fMinHitEnergyFraction

protected

min frac of ionization a track has to count in a TPC hit

Definition at line 296 of file BackTrackerCore.h.

sim::ParticleList gar::cheat::BackTrackerCore::fParticleList

protected

Maps MCParticle::TrackId() to same MCParticle.

Definition at line 305 of file BackTrackerCore.h.

std::string gar::cheat::BackTrackerCore::fRawCaloDataECALInstance

protected

instance name for the ECAL raw hits

Definition at line 294 of file BackTrackerCore.h.

std::string gar::cheat::BackTrackerCore::fRawCaloDataLabel

protected

label for ECAL readout module

Definition at line 293 of file BackTrackerCore.h.

std::string gar::cheat::BackTrackerCore::fRawTPCDataLabel

protected

label for TPC readout module

Definition at line 292 of file BackTrackerCore.h.

bool gar::cheat::BackTrackerCore::fSplitEDeps

protected

use weights from PRFs to break true energy deposits into channel specific contributions

Definition at line 313 of file BackTrackerCore.h.

int gar::cheat::BackTrackerCore::fSTFU

protected

Definition at line 285 of file BackTrackerCore.h.

std::unordered_map< rec::IDNumber, std::vector<art::Ptr<rec::Hit> > > gar::cheat::BackTrackerCore::fTPCClusterIDToHits

protected

Reco TPC cluster ID to cluster's hits.

Definition at line 333 of file BackTrackerCore.h.

std::string gar::cheat::BackTrackerCore::fTPCClusterLabel

protected

label for TPCCluster producing module

Definition at line 299 of file BackTrackerCore.h.

double gar::cheat::BackTrackerCore::fTrackFracMCP

protected

min frac of ionization in a track for matching to an MCParticle

Definition at line 300 of file BackTrackerCore.h.

std::unordered_map< rec::IDNumber, std::vector<const rec::TPCCluster*> > gar::cheat::BackTrackerCore::fTrackIDToClusters

protected

Reco track ID to track's clusters.

Definition at line 328 of file BackTrackerCore.h.

std::unordered_map< rec::IDNumber, std::vector<art::Ptr<rec::Hit> > > gar::cheat::BackTrackerCore::fTrackIDToHits

protected

Reco track ID to track's hits.

Definition at line 324 of file BackTrackerCore.h.

std::unordered_map<int, int> gar::cheat::BackTrackerCore::fTrackIDToMCTruthIndex

protected

map of track ids to MCTruthList entry. Track Ids from MCParticle table in event store (no track ID <0)

Definition at line 307 of file BackTrackerCore.h.

std::string gar::cheat::BackTrackerCore::fTrackLabel

protected

label for final track producing module

Definition at line 298 of file BackTrackerCore.h.

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

garsoft/MCCheater/BackTrackerCore.h
garsoft/MCCheater/BackTrackerCore.cxx

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation