#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, const detinfo::DetectorClocks *detClock)

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

	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 >
const std::vector< art::Ptr< recob::Hit > >	SpacePointToHits_Ps (art::Ptr< recob::SpacePoint > const &spt, const Evt &evt) const

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

void	ClearEvent ()

bool	SimChannelsReady () const

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

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

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

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

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

const std::vector< sim::TrackIDE >	HitToTrackIDEs (recob::Hit const &hit) const

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

const std::vector< int >	HitToTrackIds (recob::Hit const &hit) const

const std::vector< sim::TrackIDE >	HitToEveTrackIDEs (recob::Hit const &hit) const

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

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

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

const std::vector< sim::IDE >	HitToAvgSimIDEs (recob::Hit const &hit) const

const std::vector< sim::IDE >	HitToAvgSimIDEs (art::Ptr< recob::Hit > hit) const

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

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

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

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

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

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

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

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

const double	HitCollectionEfficiency (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

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

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

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

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

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

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

Private Attributes
const cheat::ParticleInventory *	fPartInv

const geo::GeometryCore *	fGeom

const detinfo::DetectorClocks *	fDetClocks

const art::InputTag	fG4ModuleLabel

const art::InputTag	fHitLabel

const double	fMinHitEnergyFraction

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

Detailed Description

Definition at line 38 of file BackTracker.h.

Constructor & Destructor Documentation

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

Definition at line 29 of file BackTracker.cc.

     :fPartInv  (partInv),
      fGeom     (geom),
      fDetClocks(detClock),
      fG4ModuleLabel(config.G4ModuleLabel()),
      fHitLabel(config.DefaultHitModuleLabel()),
      fMinHitEnergyFraction(config.MinHitEnergyFraction())
   {
   }

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

Definition at line 40 of file BackTracker.cc.

     :fPartInv  (partInv),
      fGeom     (geom),
      fDetClocks(detClock),
      fG4ModuleLabel       (pSet.get<art::InputTag>("G4ModuleLabel", "largeant")),
      fHitLabel            (pSet.get<art::InputTag>("DefaultHitModuleLabel", "hitfd")),
      fMinHitEnergyFraction(pSet.get<double>       ("MinHitEnergyFraction", 0.010))
   {
   }

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

delete

Member Function Documentation

template<typename Evt >

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

inline

Definition at line 71 of file BackTracker.h.

References ClearEvent(), SpacePointToHits_Ps(), and SpacePointToXYZ().

Referenced by cheat::BackTrackerService::priv_CanRun().

71 { return !(evt.isRealData());}

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

Definition at line 112 of file BackTracker.cc.

References e, energy, sim::TrackIDE::energy, sim::TrackIDE::energyFrac, fDetClocks, FindSimChannel(), sim::NoParticleId, detinfo::DetectorClocks::TPCTick2TDC(), sim::TrackIDE::trackID, and sim::SimChannel::TrackIDsAndEnergies().

Referenced by cheat::BackTrackerService::ChannelToTrackIDEs(), GetSetOfTrackIds(), HitToTrackIDEs(), SimChannels(), TrackIdsToHits_Ps(), and TrackIdToHits_Ps().

                                                                                                                                                     {
     std::vector< sim::TrackIDE > trackIDEs;
     double totalE=0.;
     try{
       art::Ptr<sim::SimChannel> schannel = this->FindSimChannel(channel);
 
       // 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 = fDetClocks->TPCTick2TDC( hit_start_time );
       int end_tdc   = fDetClocks->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;
 
         trackIDEs.push_back(info);
 
       }
     }// end try
     catch(cet::exception e){
       mf::LogWarning("BackTracker") << "caught exception \n"
         << e;
     }
 
     return trackIDEs;
 
   }

void cheat::BackTracker::ClearEvent ( )

Definition at line 51 of file BackTracker.cc.

References fSimChannels.

Referenced by CanRun(), and cheat::BackTrackerService::priv_PrepEvent().

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

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

Definition at line 99 of file BackTracker.cc.

References fSimChannels.

Referenced by ChannelToTrackIDEs(), cheat::BackTrackerService::FindSimChannel(), HitToAvgSimIDEs(), HitToSimIDEs_Ps(), and SimChannels().

                                                                                {
     art::Ptr<sim::SimChannel> chan;
     auto ilb = std::lower_bound(fSimChannels.begin(),fSimChannels.end(),channel,[](art::Ptr<sim::SimChannel> a, raw::    ChannelID_t channel) {return(a->Channel()<channel);});
     if (ilb != fSimChannels.end())
       if ( (*ilb)->Channel() == channel) {chan = *ilb;}
     if(!chan)
       throw cet::exception("BackTracker") << "No sim::SimChannel corresponding "
         << "to channel: " << channel << "\n";
     return chan;
   }

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

inline

Definition at line 148 of file BackTracker.h.

References fPartInv, cheat::ParticleInventory::GetSetOfEveIds(), GetSetOfTrackIds(), hits(), SpacePointHitsToWeightedXYZ(), and lar::dump::vector().

Referenced by cheat::BackTrackerService::GetSetOfEveIds().

148 { return fPartInv->GetSetOfEveIds();}

cheat::BackTracker::fPartInv

const cheat::ParticleInventory * fPartInv

Definition: BackTracker.h:156

cheat::ParticleInventory::GetSetOfEveIds

std::set< int > GetSetOfEveIds() const

Definition: ParticleInventory.cc:113

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

Definition at line 485 of file BackTracker.cc.

References hits(), and HitToEveTrackIDEs().

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

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

inline

Definition at line 147 of file BackTracker.h.

References fPartInv, and cheat::ParticleInventory::GetSetOfTrackIds().

Referenced by GetSetOfEveIds(), and cheat::BackTrackerService::GetSetOfTrackIds().

147 { return fPartInv->GetSetOfTrackIds();}

cheat::ParticleInventory::GetSetOfTrackIds

std::set< int > GetSetOfTrackIds() const

Definition: ParticleInventory.cc:104

cheat::BackTracker::fPartInv

const cheat::ParticleInventory * fPartInv

Definition: BackTracker.h:156

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

Definition at line 471 of file BackTracker.cc.

References ChannelToTrackIDEs(), evd::details::end(), and hits().

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

const double cheat::BackTracker::HitChargeCollectionEfficiency	(	std::set< int >	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 438 of file BackTracker.cc.

References fMinHitEnergyFraction, hits(), HitToTrackIDEs(), and geo::k3D.

Referenced by cheat::BackTrackerService::HitChargeCollectionEfficiency(), and HitToXYZ().

                                   {
     double desired=0.,total=0.;
     for( const auto& hit : hits){
       std::vector<sim::TrackIDE> hitTrackIDEs = this->HitToTrackIDEs(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(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.;
 
   }

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

Definition at line 389 of file BackTracker.cc.

References hits(), and HitToTrackIDEs().

Referenced by cheat::BackTrackerService::HitChargeCollectionPurity(), and HitToXYZ().

                                                                                                                                        {
     double totalCharge=0.,desired=0.;
     for(const auto& hit : hits){
       totalCharge+=hit->Integral();
       std::vector<sim::TrackIDE> trackIDEs= this->HitToTrackIDEs(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;
   }

const double cheat::BackTracker::HitCollectionEfficiency	(	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 406 of file BackTracker.cc.

References fMinHitEnergyFraction, hits(), HitToTrackIDEs(), and geo::k3D.

Referenced by cheat::BackTrackerService::HitCollectionEfficiency(), and HitToXYZ().

                                    {
 
     int desired=0,total=0;
 
     for( const auto& hit : hits){
       std::vector<sim::TrackIDE> hitTrackIDEs = this->HitToTrackIDEs(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(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.;
   }

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

Definition at line 373 of file BackTracker.cc.

References hits(), and HitToTrackIDEs().

Referenced by cheat::BackTrackerService::HitCollectionPurity(), and HitToXYZ().

                                                                                                                              {
     int desired =0;
     for( const auto& hit : hits ){
       std::vector<sim::TrackIDE> hitTrackIDEs=this->HitToTrackIDEs(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;
   }

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

Definition at line 263 of file BackTracker.cc.

References recob::Hit::Channel(), fDetClocks, FindSimChannel(), recob::Hit::PeakTimeMinusRMS(), recob::Hit::PeakTimePlusRMS(), and detinfo::DetectorClocks::TPCTick2TDC().

Referenced by cheat::BackTrackerService::HitToAvgSimIDEs(), and HitToEveTrackIDEs().

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

const std::vector< sim::IDE > cheat::BackTracker::HitToAvgSimIDEs ( art::Ptr< recob::Hit > hit ) const

inline

Definition at line 123 of file BackTracker.h.

References HitToAvgSimIDEs(), and HitToSimIDEs_Ps().

Referenced by HitToAvgSimIDEs().

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

cheat::BackTracker::HitToAvgSimIDEs

const std::vector< sim::IDE > HitToAvgSimIDEs(recob::Hit const &hit) const

Definition: BackTracker.cc:263

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

Definition at line 181 of file BackTracker.cc.

References sim::TrackIDE::energy, sim::TrackIDE::energyFrac, fPartInv, HitToTrackIDEs(), sim::TrackIDE::trackID, and cheat::ParticleInventory::TrackIdToEveTrackId().

Referenced by GetSetOfEveIds(), cheat::BackTrackerService::HitToEveTrackIDEs(), and HitToTrackIDEs().

                                                                                        {
     std::vector<sim::TrackIDE> eveIDEs;
     std::vector<sim::TrackIDE> trackIDEs = this->HitToTrackIDEs(hit);
     std::map<int, double> eveToEMap;
     double totalE=0.0;
     for (const auto& trackIDE : trackIDEs){
       eveToEMap[fPartInv->TrackIdToEveTrackId(trackIDE.trackID)] += 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;
       eveTrackIDE_tmp.energyFrac = (eveTrackIDE_tmp.energy)/(totalE);
       eveIDEs.push_back(eveTrackIDE_tmp);
     }//END eveToEMap loop
     return eveIDEs;
   }

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

inline

Definition at line 110 of file BackTracker.h.

References HitToAvgSimIDEs(), HitToEveTrackIDEs(), TrackIdsToHits_Ps(), TrackIdToHits_Ps(), and lar::dump::vector().

Referenced by HitToEveTrackIDEs().

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

cheat::BackTracker::HitToEveTrackIDEs

const std::vector< sim::TrackIDE > HitToEveTrackIDEs(recob::Hit const &hit) const

Definition: BackTracker.cc:181

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

Definition at line 275 of file BackTracker.cc.

References recob::Hit::Channel(), fDetClocks, FindSimChannel(), recob::Hit::PeakTimeMinusRMS(), recob::Hit::PeakTimePlusRMS(), and detinfo::DetectorClocks::TPCTick2TDC().

Referenced by HitToAvgSimIDEs(), cheat::BackTrackerService::HitToSimIDEs_Ps(), and HitToXYZ().

                                                                                          {
     std::vector< const sim::IDE* > retVec;
 //    const auto start_tdc = hit.PeakTimeMinusRMS();
 //    const auto end_tdc = hit.PeakTimePlusRMS();
     int start_tdc = fDetClocks->TPCTick2TDC( hit.PeakTimeMinusRMS() );
     int end_tdc   = fDetClocks->TPCTick2TDC( hit.PeakTimePlusRMS()   );
     if(start_tdc<0) start_tdc = 0;
     if(end_tdc<0) end_tdc = 0;
 
     if(start_tdc > end_tdc){throw;}
     
 /*    auto sc = this->FindSimChannel(hit.Channel());
     auto tdcidemap = sc->TDCIDEMap();
     auto& tdcidemapref = sc->TDCIDEMap();*/
 
     const std::vector< std::pair<unsigned short, std::vector<sim::IDE>> >& tdcIDEMap = (this->FindSimChannel(hit.Channel()))->TDCIDEMap(); //This in fact does not return a 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);
     }
 
     //Sort a vector of pointers to the TDCIDEs
     /*
     auto pairSort = [](auto& a, auto& b) { return a.first < b.first ; } ;
     if( !std::is_sorted( tdcIDEMap.begin(), tdcIDEMap.end(), pairSort)) {
       std::cout<<"AlreadySorted\n";
    //   std::sort (tdcIDEMap.begin(), tdcIDEMap.end(), pairSort);
     }else{
       throw;
     }*/
 
     //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);
     //const std::vector<std::pair<unsigned short, std::vector<sim::IDE> > >::iterator  //iterator to the first interesting IDE
     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);
       //mapFirst = std::lower_bound(tdcIDEMap.begin(), tdcIDEMap.end(), start_tdcPair, pairSort);
     //const std::vector<std::pair<unsigned short, std::vector<sim::IDE> > >::iterator  //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);
         //std::cout<<"Dumping Selected IDEs from tdcIDEMap:\nTrackID: "<<ide.trackID<<"\nnumElectrons: "<<ide.numElectrons<<"\nenergy: "<<ide.energy<<"\nXYZ: "<<ide.x<<" "<<ide.y<<" "<<ide.z<<"\n";
       } //Add all interesting IDEs to the retVec
     }
 /*    for( auto ide : retVec){
         std::cout<<"Dumping Selected IDEs from retVec:\nTrackID: "<<ide->trackID<<"\nnumElectrons: "<<ide->numElectrons<<"\nenergy: "<<ide->energy<<"\nXYZ: "<<ide->x<<" "<<ide->y<<" "<<ide->z<<"\n";
     }*/
     return retVec;
   }

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

inline

Definition at line 126 of file BackTracker.h.

References HitToSimIDEs_Ps(), HitToXYZ(), and SimIDEsToXYZ().

Referenced by HitToSimIDEs_Ps().

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

cheat::BackTracker::HitToSimIDEs_Ps

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

Definition: BackTracker.cc:275

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

Definition at line 161 of file BackTracker.cc.

References recob::Hit::Channel(), ChannelToTrackIDEs(), evd::details::end(), recob::Hit::PeakTimeMinusRMS(), and recob::Hit::PeakTimePlusRMS().

Referenced by HitChargeCollectionEfficiency(), HitChargeCollectionPurity(), HitCollectionEfficiency(), HitCollectionPurity(), HitToEveTrackIDEs(), cheat::BackTrackerService::HitToTrackIDEs(), HitToTrackIds(), and SimChannels().

                                                                                        {
     std::vector<  sim::TrackIDE > trackIDEs;
     const double start = hit.PeakTimeMinusRMS();
     const double end   = hit.PeakTimePlusRMS();
     trackIDEs = this->ChannelToTrackIDEs(hit.Channel(), start, end);
     return trackIDEs;
   }

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

inline

Definition at line 104 of file BackTracker.h.

References HitToEveTrackIDEs(), HitToTrackIDEs(), and HitToTrackIds().

Referenced by HitToTrackIDEs().

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

cheat::BackTracker::HitToTrackIDEs

const std::vector< sim::TrackIDE > HitToTrackIDEs(recob::Hit const &hit) const

Definition: BackTracker.cc:161

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

Definition at line 171 of file BackTracker.cc.

References HitToTrackIDEs().

Referenced by HitToTrackIDEs(), and cheat::BackTrackerService::HitToTrackIds().

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

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

Definition at line 367 of file BackTracker.cc.

References HitToSimIDEs_Ps(), and SimIDEsToXYZ().

Referenced by HitToSimIDEs_Ps(), cheat::BackTrackerService::HitToXYZ(), and SpacePointHitsToWeightedXYZ().

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

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

inline

Definition at line 135 of file BackTracker.h.

References HitChargeCollectionEfficiency(), HitChargeCollectionPurity(), HitCollectionEfficiency(), HitCollectionPurity(), hits(), HitToXYZ(), and lar::dump::vector().

Referenced by HitToXYZ().

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

cheat::BackTracker::HitToXYZ

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

Definition: BackTracker.cc:367

template<typename Evt >

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

template<typename Evt >

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

Referenced by cheat::BackTrackerService::priv_PrepSimChannels().

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

inline

Definition at line 89 of file BackTracker.h.

References ChannelToTrackIDEs(), FindSimChannel(), fSimChannels, HitToTrackIDEs(), and TrackIdToSimIDEs_Ps().

Referenced by cheat::BackTrackerService::SimChannels().

89 { return fSimChannels; }

cheat::BackTracker::fSimChannels

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

Definition: BackTracker.h:164

bool cheat::BackTracker::SimChannelsReady ( ) const

inline

Definition at line 86 of file BackTracker.h.

References fSimChannels.

Referenced by cheat::BackTrackerService::priv_SimChannelsReady().

86 { return !( fSimChannels.empty() ); }

cheat::BackTracker::fSimChannels

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

Definition: BackTracker.h:164

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

Definition at line 338 of file BackTracker.cc.

References e, w, and weight.

Referenced by HitToSimIDEs_Ps(), HitToXYZ(), cheat::BackTrackerService::SimIDEsToXYZ(), and SimIDEsToXYZ().

   {
     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;
   }

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

Definition at line 359 of file BackTracker.cc.

References SimIDEsToXYZ().

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

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

Definition at line 496 of file BackTracker.cc.

References geo::CryostatID::Cryostat, fGeom, hits(), HitToXYZ(), recob::Hit::Integral(), geo::GeometryCore::Ncryostats(), geo::GeometryCore::Nplanes(), geo::GeometryCore::NTPC(), geo::PlaneID::Plane, geo::GeometryCore::PositionToTPC(), geo::TPCID::TPC, and recob::Hit::WireID().

Referenced by GetSetOfEveIds(), and cheat::BackTrackerService::SpacePointHitsToWeightedXYZ().

                                                                                                                  {
     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(*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 >

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

Referenced by CanRun(), and cheat::BackTrackerService::SpacePointToHits_Ps().

template<typename Evt >

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

Referenced by CanRun(), and cheat::BackTrackerService::SpacePointToXYZ().

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

Definition at line 225 of file BackTracker.cc.

References recob::Hit::Channel(), ChannelToTrackIDEs(), fMinHitEnergyFraction, recob::Hit::PeakTimeMinusRMS(), and recob::Hit::PeakTimePlusRMS().

Referenced by HitToEveTrackIDEs(), and cheat::BackTrackerService::TrackIdsToHits_Ps().

                                                                                                                                                              {
     // 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( hit->Channel(), hit->PeakTimeMinusRMS(), hit->PeakTimePlusRMS());
       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	(	const int &	tkId,
		std::vector< art::Ptr< recob::Hit > > const &	hitsIn
	)		const

Definition at line 202 of file BackTracker.cc.

References recob::Hit::Channel(), ChannelToTrackIDEs(), fMinHitEnergyFraction, recob::Hit::PeakTimeMinusRMS(), and recob::Hit::PeakTimePlusRMS().

Referenced by HitToEveTrackIDEs(), and cheat::BackTrackerService::TrackIdToHits_Ps().

                                                                                                                                   {
     // 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( hit->Channel(), hit->PeakTimeMinusRMS(), hit->PeakTimePlusRMS());
       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;
   }

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

Definition at line 57 of file BackTracker.cc.

References fSimChannels.

Referenced by SimChannels(), and cheat::BackTrackerService::TrackIdToSimIDEs_Ps().

                                                                                         {
     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;
   }

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

Definition at line 78 of file BackTracker.cc.

References fGeom, fSimChannels, sim::IDE::trackID, and geo::GeometryCore::View().

   {  
     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 detinfo::DetectorClocks* cheat::BackTracker::fDetClocks

private

Definition at line 158 of file BackTracker.h.

Referenced by ChannelToTrackIDEs(), HitToAvgSimIDEs(), and HitToSimIDEs_Ps().

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

private

Definition at line 159 of file BackTracker.h.

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

private

Definition at line 157 of file BackTracker.h.

Referenced by SpacePointHitsToWeightedXYZ(), and TrackIdToSimIDEs_Ps().

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

private

Definition at line 160 of file BackTracker.h.

const double cheat::BackTracker::fMinHitEnergyFraction

private

Definition at line 161 of file BackTracker.h.

Referenced by HitChargeCollectionEfficiency(), HitCollectionEfficiency(), TrackIdsToHits_Ps(), and TrackIdToHits_Ps().

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

private

Definition at line 156 of file BackTracker.h.

Referenced by GetSetOfEveIds(), GetSetOfTrackIds(), and HitToEveTrackIDEs().

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

mutableprivate

Definition at line 164 of file BackTracker.h.

Referenced by ClearEvent(), FindSimChannel(), SimChannels(), SimChannelsReady(), and TrackIdToSimIDEs_Ps().

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

larsim/v06_53_00/source/larsim/MCCheater/BackTracker.h
larsim/v06_53_00/source/larsim/MCCheater/BackTracker.cc

Classes

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation