cheat::PhotonBackTracker Class Reference

#include "old.PhotonBackTracker.h"

Inheritance diagram for cheat::PhotonBackTracker:

Classes
struct	fhiclConfig

Public Member Functions
	PhotonBackTracker (fhicl::ParameterSet const &pset, art::ActivityRegistry &reg)
	~PhotonBackTracker ()
void	reconfigure (fhicl::ParameterSet const &pset)
void	Rebuild (const art::Event &evt)
const sim::ParticleList &	ParticleList () const
void	SetEveIdCalculator (sim::EveIdCalculator *ec)
const simb::MCParticle *	TrackIDToParticle (int const &id) const
const simb::MCParticle *	TrackIDToMotherParticle (int const &id) const
std::vector< sim::SDP >	TrackIDToSimSDP (int const &id) const
const art::Ptr< simb::MCTruth > &	TrackIDToMCTruth (int const &id) const
const art::Ptr< simb::MCTruth > &	ParticleToMCTruth (const simb::MCParticle *p) const
std::vector< const simb::MCParticle * >	MCTruthToParticles (art::Ptr< simb::MCTruth > const &mct) const
const std::vector< art::Ptr< simb::MCTruth > > &	MCTruthVector () const
DEPRECATED std::vector< sim::TrackSDP >	OpHitToTrackID (art::Ptr< recob::OpHit > const &hit)
std::vector< sim::TrackSDP >	OpHitToTrackSDPs (art::Ptr< recob::OpHit > const &hit)
const std::vector< std::vector< art::Ptr< recob::OpHit > > >	TrackIDsToOpHits (std::vector< art::Ptr< recob::OpHit >> const &allhits, std::vector< int > const &tkIDs)
std::vector< sim::TrackSDP >	OpHitToEveSDPs (art::Ptr< recob::OpHit > const &hit)
std::vector< sim::TrackSDP >	OpHitToEveID (art::Ptr< recob::OpHit > const &hit)
std::vector< double >	SimSDPsToXYZ (std::vector< sim::SDP > const &sdps)
std::vector< double >	OpHitToXYZ (art::Ptr< recob::OpHit > const &hit)
double	OpHitCollectionPurity (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits)
double	OpHitCollectionEfficiency (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits, std::vector< art::Ptr< recob::OpHit > > const &allhits)
double	OpHitCollectionEfficiency (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits, std::vector< art::Ptr< recob::OpHit > > const &allhits, geo::View_t const &view)
double	OpHitChargeCollectionPurity (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits)
double	OpHitChargeCollectionEfficiency (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits, std::vector< art::Ptr< recob::OpHit > > const &allhits)
double	OpHitChargeCollectionEfficiency (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits, std::vector< art::Ptr< recob::OpHit > > const &allhits, geo::View_t const &view)
std::set< int >	GetSetOfEveIDs ()
std::set< int >	GetSetOfTrackIDs ()
std::set< int >	GetSetOfEveIDs (std::vector< art::Ptr< recob::OpHit > > const &hits)
std::set< int >	GetSetOfTrackIDs (std::vector< art::Ptr< recob::OpHit > > const &hits)
const std::vector< art::Ptr< sim::OpDetBacktrackerRecord > > &	OpDetBacktrackerRecords () const
void	ChannelToTrackSDPs (std::vector< sim::TrackSDP > &trackSDPs, int channel, const double hit_start_time, const double hit_end_time)
	PhotonBackTracker (fhicl::ParameterSet const &pset, art::ActivityRegistry &reg)
	~PhotonBackTracker ()
void	reconfigure (fhicl::ParameterSet const &pset)
void	Rebuild (const art::Event &evt)
const sim::ParticleList &	ParticleList () const
void	SetEveIdCalculator (sim::EveIdCalculator *ec)
const simb::MCParticle *	TrackIDToParticle (int const &id) const
const simb::MCParticle *	TrackIDToMotherParticle (int const &id) const
std::vector< sim::SDP >	TrackIDToSimSDP (int const &id) const
const art::Ptr< simb::MCTruth > &	TrackIDToMCTruth (int const &id) const
const art::Ptr< simb::MCTruth > &	ParticleToMCTruth (const simb::MCParticle *p) const
std::vector< const simb::MCParticle * >	MCTruthToParticles (art::Ptr< simb::MCTruth > const &mct) const
const std::vector< art::Ptr< simb::MCTruth > > &	MCTruthVector () const
DEPRECATED std::vector< sim::TrackSDP >	OpHitToTrackID (art::Ptr< recob::OpHit > const &hit)
std::vector< sim::TrackSDP >	OpHitToTrackSDPs (art::Ptr< recob::OpHit > const &hit)
const std::vector< std::vector< art::Ptr< recob::OpHit > > >	TrackIDsToOpHits (std::vector< art::Ptr< recob::OpHit >> const &allhits, std::vector< int > const &tkIDs)
std::vector< sim::TrackSDP >	OpHitToEveSDPs (art::Ptr< recob::OpHit > const &hit)
std::vector< sim::TrackSDP >	OpHitToEveID (art::Ptr< recob::OpHit > const &hit)
std::vector< double >	SimSDPsToXYZ (std::vector< sim::SDP > const &sdps)
std::vector< double >	OpHitToXYZ (art::Ptr< recob::OpHit > const &hit)
double	OpHitCollectionPurity (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits)
double	OpHitCollectionEfficiency (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits, std::vector< art::Ptr< recob::OpHit > > const &allhits)
double	OpHitCollectionEfficiency (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits, std::vector< art::Ptr< recob::OpHit > > const &allhits, geo::View_t const &view)
double	OpHitChargeCollectionPurity (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits)
double	OpHitChargeCollectionEfficiency (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits, std::vector< art::Ptr< recob::OpHit > > const &allhits)
double	OpHitChargeCollectionEfficiency (std::set< int > trackIDs, std::vector< art::Ptr< recob::OpHit > > const &hits, std::vector< art::Ptr< recob::OpHit > > const &allhits, geo::View_t const &view)
std::set< int >	GetSetOfEveIDs ()
std::set< int >	GetSetOfTrackIDs ()
std::set< int >	GetSetOfEveIDs (std::vector< art::Ptr< recob::OpHit > > const &hits)
std::set< int >	GetSetOfTrackIDs (std::vector< art::Ptr< recob::OpHit > > const &hits)
const std::vector< art::Ptr< sim::OpDetBacktrackerRecord > > &	OpDetBacktrackerRecords () const
void	ChannelToTrackSDPs (std::vector< sim::TrackSDP > &trackSDPs, int channel, const double hit_start_time, const double hit_end_time)
	PhotonBackTracker (fhiclConfig const &config, const cheat::ParticleInventory *partInv, const geo::GeometryCore *geom)
	PhotonBackTracker (fhicl::ParameterSet const &pSet, const cheat::ParticleInventory *partInv, const geo::GeometryCore *geom)
	PhotonBackTracker (PhotonBackTracker const &)=delete
template<typename Evt >
void	PrepEvent (Evt const &evt)
template<typename Evt >
const bool	CanRun (Evt const &evt)
template<typename Evt >
void	PrepOpDetBTRs (Evt const &evt)
template<typename Evt >
void	PrepOpFlashToOpHits (Evt const &evt)
const std::vector< art::Ptr< recob::OpHit > >	OpFlashToOpHits_Ps (art::Ptr< recob::OpFlash > &flash_P) const
const std::vector< double >	OpFlashToXYZ (art::Ptr< recob::OpFlash > &flash_P) const
const std::set< int >	OpFlashToTrackIds (art::Ptr< recob::OpFlash > &flash_P) const
void	ClearEvent ()
const bool	BTRsReady ()
const bool	OpFlashToOpHitsReady ()
std::vector< art::Ptr< sim::OpDetBacktrackerRecord > > const &	OpDetBTRs ()
const std::vector< const sim::SDP * >	TrackIdToSimSDPs_Ps (int const &id)
const std::vector< const sim::SDP * >	TrackIdToSimSDPs_Ps (int const &id, geo::View_t const &view)
const art::Ptr< sim::OpDetBacktrackerRecord >	FindOpDetBTR (int const &opDetNum) const
const std::vector< sim::TrackSDP >	OpDetToTrackSDPs (int const &OpDetNum, double const &opHit_start_time, double const &opHit_end_time) const
const std::vector< sim::TrackSDP >	OpHitToTrackSDPs (art::Ptr< recob::OpHit > const &opHit_P) const
const std::vector< sim::TrackSDP >	OpHitToTrackSDPs (recob::OpHit const &opHit) const
const std::vector< int >	OpHitToTrackIds (recob::OpHit const &opHit) const
const std::vector< int >	OpHitToTrackIds (art::Ptr< recob::OpHit > const &opHit) const
const std::vector< int >	OpHitToEveTrackIds (recob::OpHit const &opHit)
const std::vector< int >	OpHitToEveTrackIds (art::Ptr< recob::OpHit > const &opHit_P)
const std::vector< sim::TrackSDP >	OpHitToEveTrackSDPs (art::Ptr< recob::OpHit > const &opHit_P) const
const std::vector< sim::TrackSDP >	OpHitToEveTrackSDPs (recob::OpHit const &opHit) const
const std::vector< art::Ptr< recob::OpHit > >	TrackIdToOpHits_Ps (int const &tkId, std::vector< art::Ptr< recob::OpHit >> const &hitsIn)
const std::vector< std::vector< art::Ptr< recob::OpHit > > >	TrackIdsToOpHits_Ps (std::vector< int > const &tkIds, std::vector< art::Ptr< recob::OpHit >> const &hitsIn)
const std::vector< const sim::SDP * >	OpHitToSimSDPs_Ps (recob::OpHit const &opHit) const
const std::vector< const sim::SDP * >	OpHitToSimSDPs_Ps (art::Ptr< recob::OpHit > const &opHit_P) const
const std::vector< const sim::SDP * >	OpHitsToSimSDPs_Ps (std::vector< art::Ptr< recob::OpHit > > const &opHits_Ps) const
const std::vector< double >	SimSDPsToXYZ (std::vector< sim::SDP > const &sdps) const &
const std::vector< double >	SimSDPsToXYZ (std::vector< const sim::SDP * > const &sdps_Ps) const &
const std::vector< double >	OpHitToXYZ (art::Ptr< recob::OpHit > const &opHit)
const std::vector< double >	OpHitToXYZ (recob::OpHit const &opHit)
const std::vector< double >	OpHitsToXYZ (std::vector< art::Ptr< recob::OpHit > > const &opHits_Ps) const
const std::unordered_set< const sim::SDP * >	OpHitToEveSimSDPs_Ps (recob::OpHit const &opHit)
const std::unordered_set< const sim::SDP * >	OpHitToEveSimSDPs_Ps (art::Ptr< recob::OpHit > &opHit_P)
const std::set< int >	GetSetOfEveIds () const
const std::set< int >	GetSetOfTrackIds () const
const std::set< int >	GetSetOfEveIds (std::vector< art::Ptr< recob::OpHit > > const &opHits) const
const std::set< int >	GetSetOfEveIds (std::vector< recob::OpHit > const &opHits) const
const std::set< int >	GetSetOfTrackIds (std::vector< art::Ptr< recob::OpHit > > const &opHits) const
const std::set< int >	GetSetOfTrackIds (std::vector< recob::OpHit > const &opHits) const
const double	OpHitCollectionPurity (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit > > const &opHits)
const double	OpHitLightCollectionPurity (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit > > const &opHits)
const double	OpHitCollectionEfficiency (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit > > const &opHits, std::vector< art::Ptr< recob::OpHit > > const &opHitsIn)
const double	OpHitCollectionEfficiency (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit > > const &opHits, std::vector< art::Ptr< recob::OpHit > > const &opHitsIn, geo::View_t const &view)
const double	OpHitLightCollectionEfficiency (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit > > const &opHits, std::vector< art::Ptr< recob::OpHit > > const &opHitsIn)
const double	OpHitLightCollectionEfficiency (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit > > const &opHits, std::vector< art::Ptr< recob::OpHit > > const &opHitsIn, geo::View_t const &view)
void	OpHitToSDPs (recob::OpHit const &hit, std::vector< sim::SDP > &sdps) const
DEPRECATED void	OpHitToSimSDPs (recob::OpHit const &hit, std::vector< sim::SDP > &sdps) const
void	OpHitToSDPs (art::Ptr< recob::OpHit > const &hit, std::vector< sim::SDP > &sdps) const
DEPRECATED void	OpHitToSimSDPs (art::Ptr< recob::OpHit > const &hit, std::vector< sim::SDP > &sdps) const
void	OpHitToSDPs (recob::OpHit const &hit, std::vector< sim::SDP > &sdps) const
DEPRECATED void	OpHitToSimSDPs (recob::OpHit const &hit, std::vector< sim::SDP > &sdps) const
void	OpHitToSDPs (art::Ptr< recob::OpHit > const &hit, std::vector< sim::SDP > &sdps) const
DEPRECATED void	OpHitToSimSDPs (art::Ptr< recob::OpHit > const &hit, std::vector< sim::SDP > &sdps) const

Private Member Functions
const art::Ptr< sim::OpDetBacktrackerRecord >	FindOpDetBacktrackerRecord (int channel) const
const void	shouldThisFail () const
const art::Ptr< sim::OpDetBacktrackerRecord >	FindOpDetBacktrackerRecord (int channel) const
const void	shouldThisFail () const

Private Attributes
geo::GeometryCore const *	geom = lar::providerFrom<geo::Geometry>()
bool	have_complained
sim::ParticleList	fParticleList
	ParticleList to map track ID to sim::Particle. More...
sim::LArVoxelList	fVoxelList
std::vector< art::Ptr< simb::MCTruth > >	fMCTruthList
	all the MCTruths for the event More...
std::vector< art::Ptr< sim::OpDetBacktrackerRecord > >	cOpDetBacktrackerRecords
	all the OpDetBacktrackerRecords for the event More...
std::map< int, int >	fTrackIDToMCTruthIndex
	map of track ids to MCTruthList entry More...
std::string	fG4ModuleLabel
	label for geant4 module More...
double	fMinOpHitEnergyFraction
	minimum fraction of energy a track id has to More...
double	fDelay
const cheat::ParticleInventory *	fPartInv
const geo::GeometryCore *	fGeom
const double	fDelay
const art::InputTag	fG4ModuleLabel
const art::InputTag	fOpHitLabel
const art::InputTag	fOpFlashLabel
const double	fMinOpHitEnergyFraction
std::vector< art::Ptr< sim::OpDetBacktrackerRecord > >	priv_OpDetBTRs
std::map< art::Ptr< recob::OpFlash >, std::vector< art::Ptr< recob::OpHit > > >	fOpFlashToOpHits

Detailed Description

Definition at line 46 of file old.PhotonBackTracker.h.

Constructor & Destructor Documentation

cheat::PhotonBackTracker::PhotonBackTracker	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &	reg
	)

cheat::PhotonBackTracker::~PhotonBackTracker

(

)

Definition at line 42 of file old.PhotonBackTracker_service.cc.

References fDelay, fG4ModuleLabel, fMinOpHitEnergyFraction, fhicl::ParameterSet::get(), have_complained, and reconfigure().

  {
  }

cheat::PhotonBackTracker::PhotonBackTracker	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &	reg
	)

cheat::PhotonBackTracker::~PhotonBackTracker

(

)

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

Definition at line 35 of file PhotonBackTracker.cc.

    :fPartInv  (partInv),
    fGeom      (geom),
//    fDetClocks (detClock),
    fDelay     (config.Delay()),
    fG4ModuleLabel(config.G4ModuleLabel()),
    fOpHitLabel(config.OpHitLabel()),
    fOpFlashLabel(config.OpFlashLabel()),
    fMinOpHitEnergyFraction(config.MinOpHitEnergyFraction())
  {}

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

Definition at line 50 of file PhotonBackTracker.cc.

    :fPartInv (partInv),
    fGeom (geom),
//    fDetClocks(detClock),
    fDelay(pSet.get<double>("Delay")),
    fG4ModuleLabel(pSet.get<art::InputTag>("G4ModuleLabel", "largeant")),
    fOpHitLabel(pSet.get<art::InputTag>("OpHitLabel", "ophit")),
    fOpFlashLabel(pSet.get<art::InputTag>("OpFlashLabel", "opflash")),
    fMinOpHitEnergyFraction(pSet.get<double>("MinimumOpHitEnergyFraction", 0.1))
  {}

cheat::PhotonBackTracker::PhotonBackTracker ( PhotonBackTracker const &  )

delete

Member Function Documentation

const bool cheat::PhotonBackTracker::BTRsReady

(

)

Definition at line 70 of file PhotonBackTracker.cc.

References priv_OpDetBTRs.

Referenced by cheat::PhotonBackTrackerService::priv_OpDetBTRsReady().

  {
    return !( priv_OpDetBTRs.empty() ) ;
  }

template<typename Evt >

const bool cheat::PhotonBackTracker::CanRun

(

Evt const &

evt

)

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

void cheat::PhotonBackTracker::ChannelToTrackSDPs	(	std::vector< sim::TrackSDP > &	trackSDPs,
		int	channel,
		const double	hit_start_time,
		const double	hit_end_time
	)

void cheat::PhotonBackTracker::ChannelToTrackSDPs	(	std::vector< sim::TrackSDP > &	trackSDPs,
		int	channel,
		const double	hit_start_time,
		const double	hit_end_time
	)

Definition at line 636 of file old.PhotonBackTracker_service.cc.

References e, energy, sim::TrackSDP::energy, sim::TrackSDP::energyFrac, FindOpDetBacktrackerRecord(), geom, sim::NoParticleId, geo::GeometryCore::OpDetFromOpChannel(), shouldThisFail(), sim::TrackSDP::trackID, and sim::OpDetBacktrackerRecord::TrackIDsAndEnergies().

Referenced by GetSetOfTrackIDs(), OpDetBacktrackerRecords(), OpHitToTrackSDPs(), and TrackIDsToOpHits().

  {
    shouldThisFail();
    trackSDPs.clear();

    double totalE = 0.;

    try{
      const art::Ptr< sim::OpDetBacktrackerRecord > schannel = this->FindOpDetBacktrackerRecord( geom->OpDetFromOpChannel(channel) );

      // loop over the photons in the channel and grab those that are in time
      // with the identified opHit start and stop times
      //const detinfo::DetectorClocks* ts = lar::providerFrom<detinfo::DetectorClocksService>();
      //int start_tdc = ts->OpticalG4Time2TDC( opHit_start_time );
      //int end_tdc   = ts->OpticalG4Time2TDC( opHit_end_time   );
      //      if(start_tdc<0) start_tdc = 0;
      //      if(end_tdc<0) end_tdc = 0;
      std::vector<sim::SDP> simSDPs = schannel->TrackIDsAndEnergies(opHit_start_time, opHit_end_time);

      // first get the total energy represented by all track ids for
      // this channel and range of tdc values
      for(size_t e = 0; e < simSDPs.size(); ++e)
        totalE += simSDPs[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 < simSDPs.size(); ++e){

        if(simSDPs[e].trackID == sim::NoParticleId) continue;

        sim::TrackSDP info;
        info.trackID    = simSDPs[e].trackID;
        info.energyFrac = simSDPs[e].energy/totalE;
        info.energy     = simSDPs[e].energy;

        trackSDPs.push_back(info);

      }
    }// end try
    catch(cet::exception e){
      mf::LogWarning("PhotonBackTracker") << "caught exception \n"
        << e;
    }

    return;
  }

void cheat::PhotonBackTracker::ClearEvent

(

)

Definition at line 65 of file PhotonBackTracker.cc.

References priv_OpDetBTRs.

Referenced by cheat::PhotonBackTrackerService::priv_PrepEvent().

                                    {
    priv_OpDetBTRs.clear();
  }

const art::Ptr< sim::OpDetBacktrackerRecord > cheat::PhotonBackTracker::FindOpDetBacktrackerRecord ( int  channel ) const

private

const art::Ptr< sim::OpDetBacktrackerRecord > cheat::PhotonBackTracker::FindOpDetBacktrackerRecord ( int  channel ) const

private

Definition at line 616 of file old.PhotonBackTracker_service.cc.

References cOpDetBacktrackerRecords, and shouldThisFail().

Referenced by ChannelToTrackSDPs(), OpDetBacktrackerRecords(), and OpHitToSDPs().

  {
    shouldThisFail();
    art::Ptr< sim::OpDetBacktrackerRecord > opDet;

    for(size_t sc = 0; sc < cOpDetBacktrackerRecords.size(); ++sc){
      //This could become a bug. What if it occurs twice (shouldn't happen in correct recorts, but still, no error handeling included for the situation
      if(cOpDetBacktrackerRecords[sc]->OpDetNum() == opDetNum) opDet = cOpDetBacktrackerRecords[sc];
    }

    if(!opDet)
    {
      throw cet::exception("PhotonBackTracker2") << "No sim::OpDetBacktrackerRecord corresponding "
        << "to opDetNum: " << opDetNum << "\n";
    }

    return opDet;
  }

const art::Ptr< sim::OpDetBacktrackerRecord > cheat::PhotonBackTracker::FindOpDetBTR

(

int const &

opDetNum

)

const

Definition at line 114 of file PhotonBackTracker.cc.

References priv_OpDetBTRs.

Referenced by cheat::PhotonBackTrackerService::FindOpDetBTR(), OpDetToTrackSDPs(), and OpHitToSimSDPs_Ps().

  {
    art::Ptr< sim::OpDetBacktrackerRecord > opDet;
    for(size_t sc = 0; sc < priv_OpDetBTRs.size(); ++sc){
      //This could become a bug. What if it occurs twice (shouldn't happen in correct records, but still, no error handeling included for the situation
      if(priv_OpDetBTRs.at(sc)->OpDetNum() == opDetNum) opDet = priv_OpDetBTRs.at(sc);
    }
    if(!opDet)
    {
      throw cet::exception("PhotonBackTracker2") << "No sim:: OpDetBacktrackerRecord corresponding "
        << "to opDetNum: " << opDetNum << "\n";
    }
    return opDet;
  }

std::set< int > cheat::PhotonBackTracker::GetSetOfEveIDs

(

)

Definition at line 357 of file old.PhotonBackTracker_service.cc.

References sim::ParticleList::begin(), sim::ParticleList::end(), sim::ParticleList::EveId(), fParticleList, and shouldThisFail().

Referenced by OpHitToSimSDPs().

  {
    shouldThisFail();
    std::set<int> eveIDs;

    sim::ParticleList::const_iterator plitr = fParticleList.begin();
    while(plitr != fParticleList.end() ){
      int eveID = fParticleList.EveId((*plitr).first);
      // look to see if this eveID is already in the set
      if( eveIDs.find(eveID) == eveIDs.end() ) eveIDs.insert(eveID);
      plitr++;
    }

    return eveIDs;
  }

std::set<int> cheat::PhotonBackTracker::GetSetOfEveIDs

(

)

std::set<int> cheat::PhotonBackTracker::GetSetOfEveIDs

(

std::vector< art::Ptr< recob::OpHit > > const &

hits

)

std::set< int > cheat::PhotonBackTracker::GetSetOfEveIDs

(

std::vector< art::Ptr< recob::OpHit > > const &

hits

)

Definition at line 386 of file old.PhotonBackTracker_service.cc.

References OpHitToEveID(), and shouldThisFail().

  {
    shouldThisFail();
    std::set<int> eveIDs;

    std::vector< art::Ptr<recob::OpHit> >::const_iterator itr = opHits.begin();
    while(itr != opHits.end() ){

      // get the eve ids corresponding to this opHit
      const std::vector<sim::TrackSDP> sdps = OpHitToEveID(*itr);

      // loop over the sdps and extract the track ids
      for(size_t i = 0; i < sdps.size(); ++i) eveIDs.insert(sdps[i].trackID);

      itr++;
    }

    return eveIDs;
  }

const std::set< int > cheat::PhotonBackTracker::GetSetOfEveIds

(

)

const

Definition at line 473 of file PhotonBackTracker.cc.

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

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

  {
    //std::set<int> out = fPartInv->GetSetOfEveIds();
    return fPartInv->GetSetOfEveIds();
    //return out;
  }

const std::set< int > cheat::PhotonBackTracker::GetSetOfEveIds

(

std::vector< art::Ptr< recob::OpHit > > const &

opHits

)

const

Definition at line 487 of file PhotonBackTracker.cc.

References OpHitToEveTrackSDPs().

  {
    std::set<int> eveIds;
    for(auto const& opHit_P : opHits_Ps){
      const std::vector<sim::TrackSDP> sdps = this->OpHitToEveTrackSDPs(opHit_P);
      for(auto const& sdp : sdps){eveIds.insert(sdp.trackID);}//end sdps
    }//End for hits
    return eveIds;
  }

const std::set< int > cheat::PhotonBackTracker::GetSetOfEveIds

(

std::vector< recob::OpHit > const &

opHits

)

const

Definition at line 498 of file PhotonBackTracker.cc.

References OpHitToEveTrackSDPs().

  { /*NEW*/ /*COMPLETE*/
    std::set<int> eveIds;
    for(auto const& opHit : opHits){
      const std::vector<sim::TrackSDP> sdps = this->OpHitToEveTrackSDPs(opHit);
      for(auto const& sdp : sdps){eveIds.insert(sdp.trackID);}//end sdps
    }//End for hits
    return eveIds;
  }

std::set<int> cheat::PhotonBackTracker::GetSetOfTrackIDs

(

)

std::set< int > cheat::PhotonBackTracker::GetSetOfTrackIDs

(

)

Definition at line 374 of file old.PhotonBackTracker_service.cc.

References fParticleList, and shouldThisFail().

Referenced by OpHitToSimSDPs(), and Rebuild().

  {
    shouldThisFail();
    // fParticleList::value_type is a pair (track, particle pointer)
    std::set<int> trackIDs;
    for (const sim::ParticleList::value_type& pl: fParticleList)
      trackIDs.insert(pl.first);

    return trackIDs;
  }

std::set< int > cheat::PhotonBackTracker::GetSetOfTrackIDs

(

std::vector< art::Ptr< recob::OpHit > > const &

hits

)

Definition at line 407 of file old.PhotonBackTracker_service.cc.

References ChannelToTrackSDPs(), evd::details::end(), fDelay, and shouldThisFail().

  {
    shouldThisFail();
    std::set<int> trackIDs;

    std::vector< art::Ptr<recob::OpHit> >::const_iterator itr = opHits.begin();
    while(itr != opHits.end() ){

      std::vector<sim::TrackSDP> trackSDPs;

      // get the track ids corresponding to this opHit
      const double pTime = (*itr)->PeakTime();
      const double pWidth= (*itr)->Width();
      const double start = (pTime-pWidth)*1000.0-fDelay;
      const double end   = (pTime+pWidth)*1000.0-fDelay;
     // const double start = (*itr)->PeakTimeMinusRMS();
     // const double end   = (*itr)->PeakTimePlusRMS();

      this->ChannelToTrackSDPs(trackSDPs, (*itr)->OpChannel(), start, end);

      // loop over the sdps and extract the track ids
      for(size_t i = 0; i < trackSDPs.size(); ++i) {
  trackIDs.insert(trackSDPs[i].trackID);
      }

      itr++;
    }

    return trackIDs;
  }

std::set<int> cheat::PhotonBackTracker::GetSetOfTrackIDs

(

std::vector< art::Ptr< recob::OpHit > > const &

hits

)

const std::set< int > cheat::PhotonBackTracker::GetSetOfTrackIds

(

)

const

Definition at line 481 of file PhotonBackTracker.cc.

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

Referenced by cheat::PhotonBackTrackerService::GetSetOfTrackIds().

  {
    return fPartInv->GetSetOfTrackIds();
  }

const std::set< int > cheat::PhotonBackTracker::GetSetOfTrackIds

(

std::vector< art::Ptr< recob::OpHit > > const &

opHits

)

const

Definition at line 509 of file PhotonBackTracker.cc.

References OpHitToTrackSDPs().

  {
    std::set<int> tids;
    for( auto const& opHit : opHits){
      for(auto const& sdp : this->OpHitToTrackSDPs(opHit)) {
        tids.insert(sdp.trackID);
      }//End for TrackSDPs
    }//End for hits
    return tids;
  }

const std::set< int > cheat::PhotonBackTracker::GetSetOfTrackIds

(

std::vector< recob::OpHit > const &

opHits

)

const

Definition at line 521 of file PhotonBackTracker.cc.

References OpHitToTrackSDPs().

  { /*NEW*/ /*COMPLETE*/
    std::set<int> tids;
    for( auto const& opHit : opHits){
      for(auto const& sdp : this->OpHitToTrackSDPs(opHit)) {
        tids.insert(sdp.trackID);
      }//End for TrackSDPs
    }//End for hits
    return tids;
  }

std::vector<const simb::MCParticle*> cheat::PhotonBackTracker::MCTruthToParticles

(

art::Ptr< simb::MCTruth > const &

mct

)

const

std::vector< const simb::MCParticle * > cheat::PhotonBackTracker::MCTruthToParticles

(

art::Ptr< simb::MCTruth > const &

mct

)

const

Definition at line 247 of file old.PhotonBackTracker_service.cc.

References fParticleList, shouldThisFail(), and TrackIDToMCTruth().

Referenced by SetEveIdCalculator().

  {
    shouldThisFail();
    std::vector<const simb::MCParticle*> ret;

    // sim::ParticleList::value_type is a pair (track ID, particle pointer)
    for (const sim::ParticleList::value_type& TrackIDpair: fParticleList) {
      if( TrackIDToMCTruth(TrackIDpair.first) == mct )
        ret.push_back(TrackIDpair.second);
    }

    return ret;
  }

const std::vector< art::Ptr<simb::MCTruth> >& cheat::PhotonBackTracker::MCTruthVector ( ) const

inline

Definition at line 82 of file old.PhotonBackTracker.h.

References fMCTruthList.

{ return fMCTruthList; }

const std::vector< art::Ptr<simb::MCTruth> >& cheat::PhotonBackTracker::MCTruthVector ( ) const

inline

Definition at line 82 of file old.PhotonBackTrackerService.h.

References fMCTruthList.

{ return fMCTruthList; }

const std::vector< art::Ptr< sim::OpDetBacktrackerRecord > >& cheat::PhotonBackTracker::OpDetBacktrackerRecords ( ) const

inline

Definition at line 168 of file old.PhotonBackTrackerService.h.

References ChannelToTrackSDPs(), cOpDetBacktrackerRecords, DECLARE_ART_SERVICE, fDelay, fG4ModuleLabel, FindOpDetBacktrackerRecord(), fMCTruthList, fMinOpHitEnergyFraction, fParticleList, fTrackIDToMCTruthIndex, fVoxelList, geom, have_complained, and shouldThisFail().

{ return cOpDetBacktrackerRecords; } 

const std::vector< art::Ptr< sim::OpDetBacktrackerRecord > >& cheat::PhotonBackTracker::OpDetBacktrackerRecords ( ) const

inline

Definition at line 168 of file old.PhotonBackTracker.h.

References ChannelToTrackSDPs(), and cOpDetBacktrackerRecords.

{ return cOpDetBacktrackerRecords; } 

const std::vector< art::Ptr< sim::OpDetBacktrackerRecord > > & cheat::PhotonBackTracker::OpDetBTRs

(

)

Definition at line 82 of file PhotonBackTracker.cc.

References priv_OpDetBTRs.

Referenced by cheat::PhotonBackTrackerService::OpDetBTRs().

  {
    return priv_OpDetBTRs;
  }

const std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpDetToTrackSDPs	(	int const &	OpDetNum,
		double const &	opHit_start_time,
		double const &	opHit_end_time
	)		const

Definition at line 130 of file PhotonBackTracker.cc.

References e, energy, sim::TrackSDP::energy, sim::TrackSDP::energyFrac, FindOpDetBTR(), sim::NoParticleId, sim::TrackSDP::trackID, and sim::OpDetBacktrackerRecord::TrackIDsAndEnergies().

Referenced by cheat::PhotonBackTrackerService::OpDetToTrackSDPs(), OpHitToTrackSDPs(), and TrackIdsToOpHits_Ps().

  {
    std::vector< sim::TrackSDP > tSDPs;
    double totalE=0;
    try{
      const art::Ptr< sim::OpDetBacktrackerRecord > opDetBTR =
        this->FindOpDetBTR(OpDetNum);
      // ( fGeom->OpDetFromOpChannel(channel) );
      std::vector<sim::SDP> simSDPs =
        opDetBTR->TrackIDsAndEnergies(opHit_start_time, opHit_end_time);
      for(size_t e = 0; e < simSDPs.size(); ++e)
        totalE += simSDPs[e].energy;
      if(totalE < 1.e-5) totalE = 1.;
      for(size_t e = 0; e < simSDPs.size(); ++e){
        if(simSDPs[e].trackID == sim::NoParticleId) continue;
        sim::TrackSDP info;
        info.trackID = simSDPs[e].trackID;
        info.energyFrac = simSDPs[e].energy/totalE;
        info.energy = simSDPs[e].energy;
        tSDPs.push_back(info);
      }
    }
    catch(cet::exception e){
      mf::LogWarning("PhotonBackTracker")<<"Exception caught\n"
        <<e;
    }
    return tSDPs;
  }

const std::vector< art::Ptr< recob::OpHit > > cheat::PhotonBackTracker::OpFlashToOpHits_Ps

(

art::Ptr< recob::OpFlash > &

flash_P

)

const

Definition at line 696 of file PhotonBackTracker.cc.

References fOpFlashToOpHits.

Referenced by OpFlashToTrackIds(), and OpFlashToXYZ().

  {//There is not "non-pointer" version of this because the art::Ptr is needed to look up the assn. One could loop the Ptrs and dereference them, but I will not encourage the behavior by building the tool to do it.

    //      art::FindManyP< recob::OpHit > fmoh(std::vector<art::Ptr<recob::OpFlash>>({flash_P}), evt, fOpHitLabel.label());
    //      std::vector<art::Ptr<recob::OpHit>> const& hits_Ps = fmoh.at(0);
    std::vector<art::Ptr<recob::OpHit>> const& hits_Ps = fOpFlashToOpHits.at(flash_P);
    return hits_Ps;

  }

const bool cheat::PhotonBackTracker::OpFlashToOpHitsReady

(

)

Definition at line 76 of file PhotonBackTracker.cc.

References fOpFlashToOpHits.

Referenced by cheat::PhotonBackTrackerService::priv_OpFlashToOpHitsReady().

  {
    return !( fOpFlashToOpHits.empty() ) ;
  }

const std::set< int > cheat::PhotonBackTracker::OpFlashToTrackIds

(

art::Ptr< recob::OpFlash > &

flash_P

)

const

Definition at line 716 of file PhotonBackTracker.cc.

References OpFlashToOpHits_Ps(), and OpHitToTrackIds().

Referenced by cheat::PhotonBackTrackerService::OpFlashToOpHits_Ps(), and cheat::PhotonBackTrackerService::OpFlashToTrackIds().

                                                                                           {
    std::vector<art::Ptr<recob::OpHit> > opHits_Ps = this->OpFlashToOpHits_Ps(flash_P);
    std::set<int> ids;
    for( auto& opHit_P : opHits_Ps){
      for( const int& id : this->OpHitToTrackIds(opHit_P) ){
        ids.insert( id) ;
      } // end for ids
    }// end for opHits
    return ids;
  }// end OpFlashToTrackIds

const std::vector< double > cheat::PhotonBackTracker::OpFlashToXYZ

(

art::Ptr< recob::OpFlash > &

flash_P

)

const

Definition at line 708 of file PhotonBackTracker.cc.

References OpFlashToOpHits_Ps(), and OpHitsToXYZ().

Referenced by cheat::PhotonBackTrackerService::OpFlashToXYZ().

  {
    const std::vector< art::Ptr<recob::OpHit>> opHits_Ps = this->OpFlashToOpHits_Ps(flash_P);
    const std::vector<double> retVec = this->OpHitsToXYZ(opHits_Ps);
    return retVec;
  }

double cheat::PhotonBackTracker::OpHitChargeCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits,
		std::vector< art::Ptr< recob::OpHit > > const &	allhits
	)

Definition at line 551 of file old.PhotonBackTracker_service.cc.

References recob::OpHit::Area(), e, fMinOpHitEnergyFraction, OpHitToTrackSDPs(), and shouldThisFail().

Referenced by OpHitToSimSDPs().

  {
    shouldThisFail();
    // get the list of EveIDs that correspond to the opHits in this collection
    // and the energy associated with the desired trackID
    float desired = 0.;
    float total   = 0.;

    // don't have to check the view in the opHits collection because
    // those are assumed to be from the object we are testing and will
    // the correct view by definition then.
    for(size_t h = 0; h < opHits.size(); ++h){

      art::Ptr<recob::OpHit> opHit = opHits[h];
      std::vector<sim::TrackSDP> opHitTrackIDs = this->OpHitToTrackSDPs(opHit);

      // don't worry about opHits where the energy fraction for the chosen
      // trackID is < 0.1
      // also don't double count if this opHit has more than one of the
      // desired track IDs associated with it
      for(size_t e = 0; e < opHitTrackIDs.size(); ++e){
        if(trackIDs.find(opHitTrackIDs[e].trackID) != trackIDs.end() &&
            opHitTrackIDs[e].energyFrac             >= fMinOpHitEnergyFraction){
          desired += opHit->Area();
          break;
        }
      }
    }// end loop over opHits

    // now figure out how many opHits in the whole collection are associated with this id
    for(size_t h = 0; h < allOpHits.size(); ++h){

      art::Ptr<recob::OpHit> opHit = allOpHits[h];

      // check that we are looking at the appropriate view here
      // in the case of 3D objects we take all opHits
      //if(opHit->View() != view && view != geo::k3D ) continue;

      std::vector<sim::TrackSDP> opHitTrackIDs = this->OpHitToTrackSDPs(opHit);

      for(size_t e = 0; e < opHitTrackIDs.size(); ++e){
        // don't worry about opHits where the energy fraction for the chosen
        // trackID is < 0.1
        // also don't double count if this opHit has more than one of the
        // desired track IDs associated with it
        if(trackIDs.find(opHitTrackIDs[e].trackID) != trackIDs.end() &&
            opHitTrackIDs[e].energyFrac             >= fMinOpHitEnergyFraction){
          total += opHit->Area();
          break;
        }
      }

    }// end loop over all opHits

    double efficiency = 0.;
    if(total > 0.) efficiency = desired/total;

    return efficiency;
  }

double cheat::PhotonBackTracker::OpHitChargeCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits,
		std::vector< art::Ptr< recob::OpHit > > const &	allhits
	)

double cheat::PhotonBackTracker::OpHitChargeCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits,
		std::vector< art::Ptr< recob::OpHit > > const &	allhits,
		geo::View_t const &	view
	)

double cheat::PhotonBackTracker::OpHitChargeCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits,
		std::vector< art::Ptr< recob::OpHit > > const &	allhits,
		geo::View_t const &	view
	)

Definition at line 544 of file old.PhotonBackTracker_service.cc.

  {
    throw cet::exception("PhotonBackTracker")<<"This function is not supported. OpHits do not have type View.\n";
  }

double cheat::PhotonBackTracker::OpHitChargeCollectionPurity	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits
	)

Definition at line 465 of file old.PhotonBackTracker_service.cc.

References recob::OpHit::Area(), e, OpHitToTrackSDPs(), and shouldThisFail().

Referenced by OpHitToSimSDPs().

  {
    shouldThisFail();
    // get the list of EveIDs that correspond to the opHits in this collection
    // if the EveID shows up in the input list of trackIDs, then it counts
    float total   = 0;
    float desired = 0.;
    // don't have to check the view in the opHits collection because
    // those are assumed to be from the object we are testing and will
    // the correct view by definition then.
    for(size_t h = 0; h < opHits.size(); ++h){
      art::Ptr<recob::OpHit> opHit = opHits[h];
      std::vector<sim::TrackSDP> opHitTrackIDs = this->OpHitToTrackSDPs(opHit);
      total+=opHit->Area(); // sum up the charge in the cluster
      // don't double count if this opHit has more than one of the
      // desired track IDs associated with it
      for(size_t e = 0; e < opHitTrackIDs.size(); ++e){
        if(trackIDs.find(opHitTrackIDs[e].trackID) != trackIDs.end()){
          desired += opHit->Area();
          break;
        }
      }
    }// end loop over opHits
    double purity = 0.;
    if(total > 0) purity = desired/total;
    return purity;
  }

double cheat::PhotonBackTracker::OpHitChargeCollectionPurity	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits
	)

double cheat::PhotonBackTracker::OpHitCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits,
		std::vector< art::Ptr< recob::OpHit > > const &	allhits
	)

Definition at line 504 of file old.PhotonBackTracker_service.cc.

References e, fMinOpHitEnergyFraction, OpHitToTrackSDPs(), and shouldThisFail().

Referenced by cheat::PhotonBackTrackerService::OpHitCollectionEfficiency(), and OpHitToSimSDPs().

  {
    shouldThisFail();
    float desired = 0.;
    float total   = 0.;
    for(size_t h = 0; h < opHits.size(); ++h){
      art::Ptr<recob::OpHit> opHit = opHits[h];
      std::vector<sim::TrackSDP> opHitTrackSDPs = this->OpHitToTrackSDPs(opHit);
      // also don't double count if this opHit has more than one of the
      // desired track IDs associated with it
      for(size_t e = 0; e < opHitTrackSDP.size(); ++e){
        if(trackIDs.find(opHitTrackSDPs[e].trackID) != trackIDs.end() &&
 opHitTrackSDPs[e].energyFrac >= fMinOpHitEnergyFraction){
          desired += 1.;
          break;
        }
      }
    }// end loop over opHits
    // now figure out how many opHits in the whole collection are associated with this id
    for(size_t h = 0; h < allOpHits.size(); ++h){
      art::Ptr<recob::OpHit> opHit = allOpHits[h];
      std::vector<sim::TrackSDP> opHitTrackSDPs = this->OpHitToTrackSDPs(opHit);
      for(size_t e = 0; e < opHitTrackSDPs.size(); ++e){
        // don't worry about opHits where the energy fraction for the chosen
        // trackID is < 0.1
        // also don't double count if this opHit has more than one of the
        // desired track IDs associated with it
        if(trackIDs.find(opHitTrackSDPs[e].trackID) != trackIDs.end() &&
            opHitTrackIDs[e].energyFrac             >= fMinOpHitEnergyFraction){
          total += 1.;
          break;
        }
      }
    }// end loop over all opHits
    double efficiency = 0.;
    if(total > 0.) efficiency = desired/total;
    return efficiency;
  }

double cheat::PhotonBackTracker::OpHitCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits,
		std::vector< art::Ptr< recob::OpHit > > const &	allhits
	)

double cheat::PhotonBackTracker::OpHitCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits,
		std::vector< art::Ptr< recob::OpHit > > const &	allhits,
		geo::View_t const &	view
	)

Definition at line 496 of file old.PhotonBackTracker_service.cc.

  {
    throw cet::exception("PhotonBackTracker")<<"This function is not supported. OpHits do not have type View.\n";
  }

double cheat::PhotonBackTracker::OpHitCollectionEfficiency	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits,
		std::vector< art::Ptr< recob::OpHit > > const &	allhits,
		geo::View_t const &	view
	)

const double cheat::PhotonBackTracker::OpHitCollectionEfficiency	(	std::set< int > const &	tkIds,
		std::vector< art::Ptr< recob::OpHit > > const &	opHits,
		std::vector< art::Ptr< recob::OpHit > > const &	opHitsIn
	)

Definition at line 596 of file PhotonBackTracker.cc.

References e, fMinOpHitEnergyFraction, and OpHitToTrackSDPs().

  {
    float desired = 0.;
    float total = 0.;
    for(size_t h = 0; h < opHits.size(); ++h){
      art::Ptr<recob::OpHit> opHit = opHits[h];
      std::vector<sim::TrackSDP> opHitTrackSDPs = this->OpHitToTrackSDPs(opHit);
      // also don't double count if this opHit has more than one of the
      // desired track IDs associated with it
      for(size_t e = 0; e < opHitTrackSDPs.size(); ++e){
        if(tkIds.find(opHitTrackSDPs[e].trackID) != tkIds.end() &&
            opHitTrackSDPs[e].energyFrac >= fMinOpHitEnergyFraction){
          desired += 1.;
          break;
        }
      }
    }// end loop over opHits
    // now figure out how many opHits in the whole collection are associated with this id
    for(size_t h = 0; h < opHitsIn.size(); ++h){
      art::Ptr<recob::OpHit> opHit = opHitsIn[h];
      std::vector<sim::TrackSDP> opHitTrackSDPs = this->OpHitToTrackSDPs(opHit);
      for(size_t e = 0; e < opHitTrackSDPs.size(); ++e){
        // don't worry about opHits where the energy fraction for the chosen
        // trackID is < 0.1
        // also don't double count if this opHit has more than one of the
        // desired track IDs associated with it
        if(tkIds.find(opHitTrackSDPs[e].trackID) != tkIds.end() &&
            opHitTrackSDPs[e].energyFrac >= fMinOpHitEnergyFraction){
          total += 1.;
          break;
        }
      }
    }// end loop over all opHits
    double efficiency = 0.;
    if(total > 0.) efficiency = desired/total;
    return efficiency;
  }

const double cheat::PhotonBackTracker::OpHitCollectionEfficiency	(	std::set< int > const &	tkIds,
		std::vector< art::Ptr< recob::OpHit > > const &	opHits,
		std::vector< art::Ptr< recob::OpHit > > const &	opHitsIn,
		geo::View_t const &	view
	)

Definition at line 587 of file PhotonBackTracker.cc.

  {
    throw cet::exception("PhotonBackTracker")<<"This function is not supported. OpHits do not have type View.\n";
  }

double cheat::PhotonBackTracker::OpHitCollectionPurity	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits
	)

double cheat::PhotonBackTracker::OpHitCollectionPurity	(	std::set< int >	trackIDs,
		std::vector< art::Ptr< recob::OpHit > > const &	hits
	)

Definition at line 439 of file old.PhotonBackTracker_service.cc.

References e, OpHitToTrackSDPs(), and shouldThisFail().

Referenced by cheat::PhotonBackTrackerService::OpHitCollectionPurity(), and OpHitToSimSDPs().

  {
    shouldThisFail();
    // get the list of EveIDs that correspond to the opHits in this collection
    // if the EveID shows up in the input list of trackIDs, then it counts
    float total   = 1.*opHits.size();;
    float desired = 0.;
    for(size_t h = 0; h < opHits.size(); ++h){
      art::Ptr<recob::OpHit> opHit = opHits[h];
      std::vector<sim::TrackSDP> opHitTrackSDPs = this->OpHitToTrackSDPs(opHit);
      // don't double count if this opHit has more than one of the
      // desired track IDs associated with it
      for(size_t e = 0; e < opHitTrackSDPs.size(); ++e){
  if(trackIds.find(opHitTrackSDPs[e].trackID) != trackIds.end()){
    desired += 1.;
    break;
  }
      }
    }// end loop over opHits
    double purity = 0.;
    if(total > 0) purity = desired/total;
    return purity;
  }

const double cheat::PhotonBackTracker::OpHitCollectionPurity	(	std::set< int > const &	tkIds,
		std::vector< art::Ptr< recob::OpHit > > const &	opHits
	)

Definition at line 533 of file PhotonBackTracker.cc.

References e, and OpHitToTrackSDPs().

  {
    // get the list of EveIDs that correspond to the opHits in this collection
    // if the EveID shows up in the input list of tkIds, then it counts
    float total = 1.*opHits.size();;
    float desired = 0.;
    for(size_t h = 0; h < opHits.size(); ++h){
      art::Ptr<recob::OpHit> opHit = opHits[h];
      std::vector<sim::TrackSDP> opHitTrackSDPs = this->OpHitToTrackSDPs(opHit);
      // don't double count if this opHit has more than one of the
      // desired track IDs associated with it
      for(size_t e = 0; e < opHitTrackSDPs.size(); ++e){
        if(tkIds.find(opHitTrackSDPs[e].trackID) != tkIds.end()){
          desired += 1.;
          break;
        }
      }
    }// end loop over opHits
    double purity = 0.;
    if(total > 0) purity = desired/total;
    return purity;
  }

const double cheat::PhotonBackTracker::OpHitLightCollectionEfficiency	(	std::set< int > const &	tkIds,
		std::vector< art::Ptr< recob::OpHit > > const &	opHits,
		std::vector< art::Ptr< recob::OpHit > > const &	opHitsIn
	)

Definition at line 646 of file PhotonBackTracker.cc.

References recob::OpHit::Area(), e, fMinOpHitEnergyFraction, and OpHitToTrackSDPs().

Referenced by cheat::PhotonBackTrackerService::OpHitChargeCollectionEfficiency(), and cheat::PhotonBackTrackerService::OpHitLightCollectionEfficiency().

  {
    float desired = 0.;
    float total = 0.;

    // don't have to check the view in the opHits collection because
    // those are assumed to be from the object we are testing and will
    // the correct view by definition then.
    for(size_t h = 0; h < opHits.size(); ++h){

      art::Ptr<recob::OpHit> opHit = opHits[h];
      std::vector<sim::TrackSDP> opHitTrackIDs = this->OpHitToTrackSDPs(opHit);

      // don't worry about opHits where the energy fraction for the chosen
      // trackID is < 0.1
      // also don't double count if this opHit has more than one of the
      // desired track IDs associated with it
      for(size_t e = 0; e < opHitTrackIDs.size(); ++e){
        if(tkIds.find(opHitTrackIDs[e].trackID) != tkIds.end() &&
            opHitTrackIDs[e].energyFrac >= fMinOpHitEnergyFraction){
          desired += opHit->Area();
          break;
        }
      }
    }// end loop over opHits
    for(size_t h = 0; h < opHitsIn.size(); ++h){
      art::Ptr<recob::OpHit> opHit = opHitsIn[h];
      // check that we are looking at the appropriate view here
      // in the case of 3D objects we take all opHits
      //if(opHit->View() != view && view != geo::k3D ) continue;
      std::vector<sim::TrackSDP> opHitTrackIDs = this->OpHitToTrackSDPs(opHit);
      for(size_t e = 0; e < opHitTrackIDs.size(); ++e){
        // don't worry about opHits where the energy fraction for the chosen
        // trackID is < 0.1
        // also don't double count if this opHit has more than one of the
        // desired track IDs associated with it
        if(tkIds.find(opHitTrackIDs[e].trackID) != tkIds.end() &&
            opHitTrackIDs[e].energyFrac >= fMinOpHitEnergyFraction){
          total += opHit->Area();
          break;
        }
      }
    }// end loop over all opHits
    double efficiency = 0.;
    if(total > 0.) efficiency = desired/total;
    return efficiency;
  }

const double cheat::PhotonBackTracker::OpHitLightCollectionEfficiency	(	std::set< int > const &	tkIds,
		std::vector< art::Ptr< recob::OpHit > > const &	opHits,
		std::vector< art::Ptr< recob::OpHit > > const &	opHitsIn,
		geo::View_t const &	view
	)

Definition at line 637 of file PhotonBackTracker.cc.

  {
    throw cet::exception("PhotonBackTracker")<<"This function is not supported. OpHits do not have type View.\n";
  }

const double cheat::PhotonBackTracker::OpHitLightCollectionPurity	(	std::set< int > const &	tkIds,
		std::vector< art::Ptr< recob::OpHit > > const &	opHits
	)

Definition at line 558 of file PhotonBackTracker.cc.

References recob::OpHit::Area(), e, and OpHitToTrackSDPs().

Referenced by cheat::PhotonBackTrackerService::OpHitLightCollectionPurity().

  {
    // get the list of EveIDs that correspond to the opHits in this collection
    // if the EveID shows up in the input list of tkIds, then it counts
    float total = 0;
    float desired = 0.;
    // don't have to check the view in the opHits collection because
    // those are assumed to be from the object we are testing and will
    // the correct view by definition then.
    for(size_t h = 0; h < opHits.size(); ++h){
      art::Ptr<recob::OpHit> opHit = opHits[h];
      std::vector<sim::TrackSDP> opHitTrackIDs = this->OpHitToTrackSDPs(opHit);
      total+=opHit->Area(); // sum up the charge in the cluster
      // don't double count if this opHit has more than one of the
      // desired track IDs associated with it
      for(size_t e = 0; e < opHitTrackIDs.size(); ++e){
        if(tkIds.find(opHitTrackIDs[e].trackID) != tkIds.end()){
          desired += opHit->Area();
          break;
        }
      }
    }// end loop over opHits
    double purity = 0.;
    if(total > 0) purity = desired/total;
    return purity;
  }

const std::vector< const sim::SDP * > cheat::PhotonBackTracker::OpHitsToSimSDPs_Ps

(

std::vector< art::Ptr< recob::OpHit > > const &

opHits_Ps

)

const

Definition at line 427 of file PhotonBackTracker.cc.

References OpHitToSimSDPs_Ps().

Referenced by OpHitsToXYZ().

  {
    std::vector < const sim::SDP* > sdps_Ps;
    for ( auto opHit_P : opHits_Ps ){
      std::vector < const sim::SDP* > to_add_sdps_Ps = this->OpHitToSimSDPs_Ps(opHit_P);
      sdps_Ps.insert( sdps_Ps.end(), to_add_sdps_Ps.begin(), to_add_sdps_Ps.end() );
    }
    return sdps_Ps;
  }

const std::vector< double > cheat::PhotonBackTracker::OpHitsToXYZ

(

std::vector< art::Ptr< recob::OpHit > > const &

opHits_Ps

)

const

Definition at line 438 of file PhotonBackTracker.cc.

References OpHitsToSimSDPs_Ps(), and SimSDPsToXYZ().

Referenced by OpFlashToXYZ().

  {
      const std::vector<const sim::SDP*> SDPs_Ps = OpHitsToSimSDPs_Ps(opHits_Ps);
      return this->SimSDPsToXYZ(SDPs_Ps);
  }

std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToEveID

(

art::Ptr< recob::OpHit > const &

hit

)

Definition at line 349 of file old.PhotonBackTracker_service.cc.

References OpHitToEveSDPs().

Referenced by GetSetOfEveIDs(), and OpHitToTrackID().

  {
    mf::LogWarning("PhotonBackTracker") << "PhotonBackTracker::OpHitToEveID is being replaced with PhotonBackTracker::OpHitToEveSDPs. Please \n update your code accordingly.\n ";
    std::vector<sim::TrackSDP> eveSDPs = OpHitToEveSDPs(opHit);
    return eveSDPs;
  }

std::vector<sim::TrackSDP> cheat::PhotonBackTracker::OpHitToEveID

(

art::Ptr< recob::OpHit > const &

hit

)

std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToEveSDPs

(

art::Ptr< recob::OpHit > const &

hit

)

Definition at line 321 of file old.PhotonBackTracker_service.cc.

References sim::TrackSDP::energy, sim::TrackSDP::energyFrac, sim::ParticleList::EveId(), fParticleList, OpHitToTrackSDPs(), shouldThisFail(), and sim::TrackSDP::trackID.

Referenced by OpHitToEveID(), and OpHitToTrackID().

  {
    shouldThisFail();
    std::vector<sim::TrackSDP> trackSDPs = this->OpHitToTrackSDPs(opHit);

    // make a map of evd ID values and fraction of energy represented by
    // that eve id in this opHit
    std::map<int, float> eveIDtoEfrac;

    double totalE = 0.;
    for(size_t t = 0; t < trackSDPs.size(); ++t){
      eveIDtoEfrac[fParticleList.EveId( trackSDPs[t].trackID )] += trackSDPs[t].energy;
      totalE += trackSDPs[t].energy;
    }

    // now fill the eveSDPs vector from the map
    std::vector<sim::TrackSDP> eveSDPs;
    eveSDPs.reserve(eveIDtoEfrac.size());
    for(auto itr = eveIDtoEfrac.begin(); itr != eveIDtoEfrac.end(); itr++){
      sim::TrackSDP temp;
      temp.trackID    = (*itr).first;
      temp.energyFrac = (*itr).second/totalE;
      temp.energy     = (*itr).second;
      eveSDPs.push_back(std::move(temp));
    }

    return eveSDPs;
  }

std::vector<sim::TrackSDP> cheat::PhotonBackTracker::OpHitToEveSDPs

(

art::Ptr< recob::OpHit > const &

hit

)

const std::unordered_set< const sim::SDP * > cheat::PhotonBackTracker::OpHitToEveSimSDPs_Ps

(

recob::OpHit const &

opHit

)

Definition at line 445 of file PhotonBackTracker.cc.

References OpHitToEveTrackIds(), and TrackIdToSimSDPs_Ps().

Referenced by cheat::PhotonBackTrackerService::OpHitToEveSimSDPs_Ps().

  { /*NEW*/ /*COMPLETE*/
    const std::vector < int > ids = this->OpHitToEveTrackIds(opHit_P);
    std::unordered_set <const sim::SDP* > sdps;
    for( auto const& id : ids ){
      std::vector<const sim::SDP* > tmp_sdps = TrackIdToSimSDPs_Ps(id);
      for( const sim::SDP* tmp_sdp : tmp_sdps ){
        sdps.insert(tmp_sdp); //emplace not needed here.
      }
    }
    return sdps;
  }

const std::unordered_set< const sim::SDP * > cheat::PhotonBackTracker::OpHitToEveSimSDPs_Ps

(

art::Ptr< recob::OpHit > &

opHit_P

)

Definition at line 459 of file PhotonBackTracker.cc.

References OpHitToEveTrackIds(), and TrackIdToSimSDPs_Ps().

  { /*NEW*/ /*COMPLETE*/
    const std::vector < int > ids = this->OpHitToEveTrackIds(opHit);
    std::unordered_set <const sim::SDP* > sdps;
    for( auto const& id : ids ){
      std::vector<const sim::SDP* > tmp_sdps = TrackIdToSimSDPs_Ps(id);
      for( const sim::SDP* tmp_sdp : tmp_sdps ){
        sdps.insert(tmp_sdp); //emplace not needed here.
      }
    }
    return sdps;
  }

const std::vector< int > cheat::PhotonBackTracker::OpHitToEveTrackIds

(

recob::OpHit const &

opHit

)

Definition at line 212 of file PhotonBackTracker.cc.

References OpHitToEveTrackSDPs().

Referenced by OpHitToEveSimSDPs_Ps(), cheat::PhotonBackTrackerService::OpHitToEveTrackIds(), and OpHitToEveTrackIds().

  {/*NEW*/ /*COMPLETE*/
    std::vector< int > retVec;
    for( auto const trackSDP : this->OpHitToEveTrackSDPs(opHit) ){
      retVec.push_back( trackSDP.trackID);
    }
    return retVec;
  }

const std::vector< int > cheat::PhotonBackTracker::OpHitToEveTrackIds

(

art::Ptr< recob::OpHit > const &

opHit_P

)

Definition at line 222 of file PhotonBackTracker.cc.

References OpHitToEveTrackIds().

  {/*NEW*/ /*COMPLETE*/
    return this->OpHitToEveTrackIds(*opHit_P);
  }

const std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToEveTrackSDPs

(

art::Ptr< recob::OpHit > const &

opHit_P

)

const

Definition at line 228 of file PhotonBackTracker.cc.

Referenced by GetSetOfEveIds(), OpHitToEveTrackIds(), and cheat::PhotonBackTrackerService::OpHitToEveTrackSDPs().

  {
    return this->OpHitToEveTrackSDPs(*opHit_P);
  }

const std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToEveTrackSDPs

(

recob::OpHit const &

opHit

)

const

Definition at line 234 of file PhotonBackTracker.cc.

References sim::TrackSDP::energy, sim::TrackSDP::energyFrac, fPartInv, OpHitToTrackSDPs(), cheat::ParticleInventory::ParticleList(), and sim::TrackSDP::trackID.

  {
    std::vector<sim::TrackSDP> trackSDPs = this->OpHitToTrackSDPs(opHit);

    // make a map of evd ID values and fraction of energy represented by
    // // that eve id in this opHit
    std::map<int, float> eveIDtoEfrac;

    double totalE = 0.;
    for(size_t t = 0; t < trackSDPs.size(); ++t){
      eveIDtoEfrac[(fPartInv->ParticleList()).EveId( trackSDPs[t].trackID )] += trackSDPs[t].energy;
      totalE += trackSDPs[t].energy;
    }

    // now fill the eveSDPs vector from the map
    std::vector<sim::TrackSDP> eveSDPs;
    eveSDPs.reserve(eveIDtoEfrac.size());
    for(auto itr = eveIDtoEfrac.begin(); itr != eveIDtoEfrac.end(); itr++){
      sim::TrackSDP temp;
      temp.trackID = (*itr).first;
      temp.energyFrac = (*itr).second/totalE;
      temp.energy = (*itr).second;
      eveSDPs.push_back(std::move(temp));
    }
    return eveSDPs;
  }

void cheat::PhotonBackTracker::OpHitToSDPs	(	recob::OpHit const &	hit,
		std::vector< sim::SDP > &	sdps
	)		const

Definition at line 691 of file old.PhotonBackTracker_service.cc.

References fDelay, FindOpDetBacktrackerRecord(), geom, recob::OpHit::OpChannel(), geo::GeometryCore::OpDetFromOpChannel(), recob::OpHit::PeakTime(), shouldThisFail(), sim::OpDetBacktrackerRecord::TrackIDsAndEnergies(), and recob::OpHit::Width().

Referenced by OpHitToSDPs(), OpHitToSimSDPs(), OpHitToTrackID(), and OpHitToXYZ().

  {
    shouldThisFail();
    // Get services.
    //const detinfo::DetectorClocks* ts = lar::providerFrom<detinfo::DetectorClocksService>();

    double fPeakTime       = opHit.PeakTime();
    double fWidth          = opHit.Width();
    sim::OpDetBacktrackerRecord::timePDclock_t start_time = ((fPeakTime-fWidth)*1000.0)-fDelay;
    sim::OpDetBacktrackerRecord::timePDclock_t end_time = ((fPeakTime+fWidth)*1000.0)-fDelay;

    sdps = FindOpDetBacktrackerRecord( geom->OpDetFromOpChannel(opHit.OpChannel()) )->TrackIDsAndEnergies(start_time, end_time);

  }

void cheat::PhotonBackTracker::OpHitToSDPs	(	recob::OpHit const &	hit,
		std::vector< sim::SDP > &	sdps
	)		const

void cheat::PhotonBackTracker::OpHitToSDPs ( art::Ptr< recob::OpHit > const &  hit, std::vector< sim::SDP > &  sdps  ) const

inline

Definition at line 106 of file old.PhotonBackTrackerService.h.

References OpHitToSDPs().

                                      { OpHitToSDPs(*hit, sdps); }

void cheat::PhotonBackTracker::OpHitToSDPs ( art::Ptr< recob::OpHit > const &  hit, std::vector< sim::SDP > &  sdps  ) const

inline

Definition at line 106 of file old.PhotonBackTracker.h.

References OpHitToSDPs().

                                      { OpHitToSDPs(*hit, sdps); }

DEPRECATED void cheat::PhotonBackTracker::OpHitToSimSDPs ( recob::OpHit const &  hit, std::vector< sim::SDP > &  sdps  ) const

inline

Definition at line 103 of file old.PhotonBackTracker.h.

References OpHitToSDPs().

                                      { OpHitToSDPs( hit, sdps); }

DEPRECATED void cheat::PhotonBackTracker::OpHitToSimSDPs ( recob::OpHit const &  hit, std::vector< sim::SDP > &  sdps  ) const

inline

Definition at line 103 of file old.PhotonBackTrackerService.h.

References OpHitToSDPs().

                                      { OpHitToSDPs( hit, sdps); }

DEPRECATED void cheat::PhotonBackTracker::OpHitToSimSDPs ( art::Ptr< recob::OpHit > const &  hit, std::vector< sim::SDP > &  sdps  ) const

inline

Definition at line 109 of file old.PhotonBackTrackerService.h.

References GetSetOfEveIDs(), GetSetOfTrackIDs(), hits(), OpHitChargeCollectionEfficiency(), OpHitChargeCollectionPurity(), OpHitCollectionEfficiency(), OpHitCollectionPurity(), OpHitToSDPs(), OpHitToXYZ(), SimSDPsToXYZ(), and lar::dump::vector().

                                      { OpHitToSDPs(*hit, sdps); }

DEPRECATED void cheat::PhotonBackTracker::OpHitToSimSDPs ( art::Ptr< recob::OpHit > const &  hit, std::vector< sim::SDP > &  sdps  ) const

inline

Definition at line 109 of file old.PhotonBackTracker.h.

References GetSetOfEveIDs(), GetSetOfTrackIDs(), hits(), OpHitChargeCollectionEfficiency(), OpHitChargeCollectionPurity(), OpHitCollectionEfficiency(), OpHitCollectionPurity(), OpHitToSDPs(), OpHitToXYZ(), SimSDPsToXYZ(), and lar::dump::vector().

                                      { OpHitToSDPs(*hit, sdps); }

const std::vector< const sim::SDP * > cheat::PhotonBackTracker::OpHitToSimSDPs_Ps

(

recob::OpHit const &

opHit

)

const

Definition at line 308 of file PhotonBackTracker.cc.

References fDelay, fGeom, FindOpDetBTR(), recob::OpHit::OpChannel(), geo::GeometryCore::OpDetFromOpChannel(), recob::OpHit::PeakTime(), and recob::OpHit::Width().

Referenced by OpHitsToSimSDPs_Ps(), cheat::PhotonBackTrackerService::OpHitToSimSDPs_Ps(), OpHitToSimSDPs_Ps(), and OpHitToXYZ().

  {
    std::vector<const sim::SDP*> retVec;
    double fPeakTime = opHit.PeakTime();
    double fWidth = opHit.Width();
    sim::OpDetBacktrackerRecord::timePDclock_t start_time = ((fPeakTime- fWidth)*1000.0)-fDelay;
    sim::OpDetBacktrackerRecord::timePDclock_t end_time = ((fPeakTime+ fWidth)*1000.0)-fDelay;
    if(start_time > end_time){throw;}

    //BUG!!!fGeom->OpDetFromOpChannel(channel)
    const std::vector<std::pair<double, std::vector<sim::SDP>> >& timeSDPMap
      = (this->FindOpDetBTR(fGeom->OpDetFromOpChannel(opHit.OpChannel()) ))->timePDclockSDPsMap(); //Not guranteed to be sorted.
    //const std::vector<std::pair<double, std::vector<sim::SDP>> >& timeSDPMap = (this->FindOpDetBTR(opHit.OpChannel()))->timePDclockSDPsMap(); //Not guranteed to be sorted.

    std::vector<const std::pair<double, std::vector<sim::SDP>>*> timePDclockSDPMap_SortedPointers;
    for ( auto& pair : timeSDPMap ){ timePDclockSDPMap_SortedPointers.push_back(&pair); }
    auto pairSort = [](auto& a, auto& b) { return a->first < b->first ; } ;
    if( !std::is_sorted( timePDclockSDPMap_SortedPointers.begin(), timePDclockSDPMap_SortedPointers.end(), pairSort)){
      std::sort(timePDclockSDPMap_SortedPointers.begin(), timePDclockSDPMap_SortedPointers.end(), pairSort);
    }

    //This section is a hack to make comparisons work right.
    std::vector<sim::SDP> dummyVec;
    std::pair<double, std::vector<sim::SDP>> start_timePair = std::make_pair(start_time, dummyVec);
    std::pair<double, std::vector<sim::SDP>> end_timePair = std::make_pair(end_time, dummyVec);
    auto start_timePair_P = &start_timePair;
    auto end_timePair_P = &end_timePair;
    //First interesting iterator.
    auto mapFirst = std::lower_bound(timePDclockSDPMap_SortedPointers.begin(), timePDclockSDPMap_SortedPointers.end(), start_timePair_P, pairSort);
    //Last interesting iterator.
    auto mapLast = std::upper_bound(mapFirst, timePDclockSDPMap_SortedPointers.end(), end_timePair_P, pairSort);

    for( auto& mapitr = mapFirst; mapitr != mapLast; ++mapitr )
      for( auto& sdp : (*mapitr)->second)
        retVec.push_back(&sdp);

    return retVec;

    //sdps = FindOpDetBTR( geom->OpDetFromOpChannel(opHit. OpChannel()) )->TrackIDsAndEnergies(start_time, end_time);
    // return (this->FindOpDetBTR( fGeom->OpDetFromOpChannel(opHit.OpChannel()) ))->TrackIDsAndEnergies(start_time, end_time);

  }

const std::vector< const sim::SDP * > cheat::PhotonBackTracker::OpHitToSimSDPs_Ps

(

art::Ptr< recob::OpHit > const &

opHit_P

)

const

Definition at line 352 of file PhotonBackTracker.cc.

References OpHitToSimSDPs_Ps().

  {
    return this->OpHitToSimSDPs_Ps(*opHit_P);
  }

DEPRECATED std::vector<sim::TrackSDP> cheat::PhotonBackTracker::OpHitToTrackID ( art::Ptr< recob::OpHit > const &  hit )

inline

Definition at line 86 of file old.PhotonBackTracker.h.

References OpHitToEveID(), OpHitToEveSDPs(), OpHitToSDPs(), OpHitToTrackSDPs(), TrackIDsToOpHits(), and lar::dump::vector().

      {return OpHitToTrackSDPs(hit);}

DEPRECATED std::vector<sim::TrackSDP> cheat::PhotonBackTracker::OpHitToTrackID ( art::Ptr< recob::OpHit > const &  hit )

inline

Definition at line 86 of file old.PhotonBackTrackerService.h.

References OpHitToEveID(), OpHitToEveSDPs(), OpHitToSDPs(), OpHitToTrackSDPs(), TrackIDsToOpHits(), and lar::dump::vector().

      {return OpHitToTrackSDPs(hit);}

const std::vector< int > cheat::PhotonBackTracker::OpHitToTrackIds

(

recob::OpHit const &

opHit

)

const

Definition at line 196 of file PhotonBackTracker.cc.

References OpHitToTrackSDPs().

Referenced by OpFlashToTrackIds(), cheat::PhotonBackTrackerService::OpHitToTrackIds(), and OpHitToTrackIds().

  {
    std::vector< int > retVec;
    for( auto const trackSDP : this->OpHitToTrackSDPs(opHit) ){
      retVec.push_back( trackSDP.trackID);
    }
    return retVec;
  }

const std::vector< int > cheat::PhotonBackTracker::OpHitToTrackIds

(

art::Ptr< recob::OpHit > const &

opHit

)

const

Definition at line 206 of file PhotonBackTracker.cc.

References OpHitToTrackIds().

  {
    return this->OpHitToTrackIds(*opHit);
  }

std::vector<sim::TrackSDP> cheat::PhotonBackTracker::OpHitToTrackSDPs

(

art::Ptr< recob::OpHit > const &

hit

)

std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToTrackSDPs

(

art::Ptr< recob::OpHit > const &

hit

)

Definition at line 262 of file old.PhotonBackTracker_service.cc.

References ChannelToTrackSDPs(), evd::details::end(), fDelay, recob::OpHit::OpChannel(), recob::OpHit::PeakTime(), shouldThisFail(), and recob::OpHit::Width().

Referenced by GetSetOfTrackIds(), OpHitChargeCollectionEfficiency(), OpHitChargeCollectionPurity(), OpHitCollectionEfficiency(), OpHitCollectionPurity(), OpHitLightCollectionEfficiency(), OpHitLightCollectionPurity(), OpHitToEveSDPs(), OpHitToEveTrackSDPs(), OpHitToTrackID(), OpHitToTrackIds(), and cheat::PhotonBackTrackerService::OpHitToTrackSDPs().

  {
    shouldThisFail();
    std::vector<sim::TrackSDP> trackSDPs;
    const double pTime = opHit->PeakTime();
    const double pWidth= opHit->Width();
    const double start = (pTime-pWidth)*1000-fDelay;
    const double end   = (pTime+pWidth)*1000-fDelay;

    this->ChannelToTrackSDPs(trackSDPs, opHit->OpChannel(), start, end);

    return trackSDPs;
  }

const std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToTrackSDPs

(

art::Ptr< recob::OpHit > const &

opHit_P

)

const

Definition at line 161 of file PhotonBackTracker.cc.

References evd::details::end(), fDelay, fGeom, recob::OpHit::OpChannel(), geo::GeometryCore::OpDetFromOpChannel(), OpDetToTrackSDPs(), recob::OpHit::PeakTime(), and recob::OpHit::Width().

  {
    //auto opHit = *opHit_P;
    auto OpDetNum =  fGeom->OpDetFromOpChannel(opHit_P->OpChannel()) ;
    std::vector<sim::TrackSDP> trackSDPs;
    const double pTime = opHit_P->PeakTime();
    const double pWidth= opHit_P->Width();
    const double start = (pTime-pWidth)*1000-fDelay;
    const double end = (pTime+pWidth)*1000-fDelay;

    //this->OpDetToTrackSDPs(trackSDPs, opHit_P->OpChannel(), start, end);


    //return trackSDPs;
    //return this->OpDetToTrackSDPs( opHit_P->OpChannel(), start, end);
    return this->OpDetToTrackSDPs( OpDetNum, start, end);

  }

const std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToTrackSDPs

(

recob::OpHit const &

opHit

)

const

Definition at line 181 of file PhotonBackTracker.cc.

References evd::details::end(), fDelay, fGeom, recob::OpHit::OpChannel(), geo::GeometryCore::OpDetFromOpChannel(), OpDetToTrackSDPs(), recob::OpHit::PeakTime(), and recob::OpHit::Width().

  {
    auto OpDetNum =  fGeom->OpDetFromOpChannel(opHit.OpChannel()) ;
    std::vector<sim::TrackSDP> trackSDPs;
    const double pTime = opHit.PeakTime();
    const double pWidth= opHit.Width();
    const double start = (pTime-pWidth)*1000-fDelay;
    const double end = (pTime+pWidth)*1000-fDelay;


    return this->OpDetToTrackSDPs( OpDetNum, start, end);

  }

const std::vector< double > cheat::PhotonBackTracker::OpHitToXYZ

(

art::Ptr< recob::OpHit > const &

hit

)

Definition at line 745 of file old.PhotonBackTracker_service.cc.

References DEFINE_ART_SERVICE, OpHitToSDPs(), shouldThisFail(), and SimSDPsToXYZ().

Referenced by OpHitToSimSDPs(), cheat::PhotonBackTrackerService::OpHitToXYZ(), and OpHitToXYZ().

  {
    shouldThisFail();
    std::vector<sim::SDP> sdps;
    OpHitToSDPs(opHit, sdps);
    return SimSDPsToXYZ(sdps);
  }

std::vector<double> cheat::PhotonBackTracker::OpHitToXYZ

(

art::Ptr< recob::OpHit > const &

hit

)

const std::vector< double > cheat::PhotonBackTracker::OpHitToXYZ

(

art::Ptr< recob::OpHit > const &

opHit

)

const std::vector< double > cheat::PhotonBackTracker::OpHitToXYZ

(

recob::OpHit const &

opHit

)

Definition at line 413 of file PhotonBackTracker.cc.

References OpHitToSimSDPs_Ps(), OpHitToXYZ(), and SimSDPsToXYZ().

  {
    return SimSDPsToXYZ(this->OpHitToSimSDPs_Ps(opHit));
  }

const sim::ParticleList& cheat::PhotonBackTracker::ParticleList ( ) const

inline

Definition at line 66 of file old.PhotonBackTracker.h.

References fParticleList.

{ return fParticleList; }

const sim::ParticleList& cheat::PhotonBackTracker::ParticleList ( ) const

inline

Definition at line 66 of file old.PhotonBackTrackerService.h.

References fParticleList.

{ return fParticleList; }

const art::Ptr< simb::MCTruth > & cheat::PhotonBackTracker::ParticleToMCTruth

(

const simb::MCParticle *

p

)

const

Definition at line 240 of file old.PhotonBackTracker_service.cc.

References shouldThisFail(), simb::MCParticle::TrackId(), and TrackIDToMCTruth().

Referenced by SetEveIdCalculator().

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

const art::Ptr<simb::MCTruth>& cheat::PhotonBackTracker::ParticleToMCTruth

(

const simb::MCParticle *

p

)

const

template<typename Evt >

void cheat::PhotonBackTracker::PrepEvent

(

Evt const &

evt

)

template<typename Evt >

void cheat::PhotonBackTracker::PrepOpDetBTRs

(

Evt const &

evt

)

Referenced by cheat::PhotonBackTrackerService::priv_PrepOpDetBTRs().

template<typename Evt >

void cheat::PhotonBackTracker::PrepOpFlashToOpHits

(

Evt const &

evt

)

Referenced by cheat::PhotonBackTrackerService::priv_PrepOpFlashToOpHits().

void cheat::PhotonBackTracker::Rebuild

(

const art::Event &

evt

)

Definition at line 56 of file old.PhotonBackTracker_service.cc.

References sim::ParticleList::Add(), sim::ParticleList::AdoptEveIdCalculator(), sim::ParticleList::clear(), cOpDetBacktrackerRecords, art::Handle< T >::failedToGet(), fG4ModuleLabel, art::fill_ptr_vector(), fMCTruthList, fParticleList, fTrackIDToMCTruthIndex, art::DataViewImpl::getByLabel(), GetSetOfTrackIDs(), have_complained, art::Event::isRealData(), LOG_DEBUG, part, art::errors::ProductNotFound, and art::Handle< T >::whyFailed().

  {
    // do nothing if this is data
    if(evt.isRealData()) return;

    // get the particles from the event
    art::Handle<std::vector<simb::MCParticle>> pHandle;
    evt.getByLabel(fG4ModuleLabel, pHandle);

    // first check to see if we got called to early, that is the particles are
    // and sim channels are not made yet in a MC production job
    // if that is the case, we'll take care of it later
    if(pHandle.failedToGet()){
      mf::LogWarning("PhotonBackTracker") << "failed to get handle to simb::MCParticle from "
            << fG4ModuleLabel
            << ", return";
      return;
    }

    // Clear out anything remaining from previous calls to Rebuild
    fParticleList.clear();
    fMCTruthList .clear();
    cOpDetBacktrackerRecords .clear();
    //fVoxelList   .clear();

    art::FindOneP<simb::MCTruth> fo(pHandle, evt, fG4ModuleLabel);

    if( fo.isValid() ){
      for(size_t p = 0; p < pHandle->size(); ++p){

        simb::MCParticle *part = new simb::MCParticle(pHandle->at(p));
        fParticleList.Add(part);

        // get the simb::MCTruth associated to this sim::ParticleList
        try{
          art::Ptr<simb::MCTruth> mct = fo.at(p);
          if(fMCTruthList.size() < 1) fMCTruthList.push_back(mct);
          else{
            // check that we are not adding a simb::MCTruth twice to the collection
            // we know that all the particles for a given simb::MCTruth are put into the
            // collection of particles at the same time, so we can just check that the
            // current art::Ptr has a different id than the last one put
            if(!(mct == fMCTruthList.back())) fMCTruthList.push_back(mct);
          }
          // fill the track id to mctruth index map
          fTrackIDToMCTruthIndex[pHandle->at(p).TrackId()] = fMCTruthList.size() - 1;
        }
        catch(cet::exception &ex){
          mf::LogWarning("PhotonBackTracker") << "unable to find MCTruth from ParticleList "
          << "created in " << fG4ModuleLabel << " "
          << "any attempt to get the MCTruth objects from "
          << "the photon backtracker will fail\n"
          << "message from caught exception:\n" << ex;
        }
      }// end loop over particles to get MCTruthList
    }// end if fo.isValid()

    // grab the sim::OpDetBacktrackerRecords for this event

    /*
    try{evt.getView(fG4ModuleLabel, cOpDetBacktrackerRecords);}
    catch(art::Exception const& e){
      if(e.categoryCode() != art::errors::ProductNotFound) throw;
      if(have_complained==false){
      }
    }
    */

    art::Handle< std::vector< sim::OpDetBacktrackerRecord> > cPBTRHandle;
    //    std::vector< art::Ptr< sim::OpDetBacktrackerRecords > > cOpDetBacktrackerRecords;
    evt.getByLabel(fG4ModuleLabel, cPBTRHandle);
    if(cPBTRHandle.failedToGet()){//Failed to get products. Prepare for controlled freak out. Assuming this is because there is no OpDetBacktrackerRecords, we will not cause things to fail, but will prepare to fail if a user tries to call backtracker functionality.
      auto failMode = cPBTRHandle.whyFailed();
      if(failMode->categoryCode() != art::errors::ProductNotFound) throw;
      else if(have_complained==false){
        std::cout<<"FAILED BECAUSE "<<(*failMode)<<"\n";
        have_complained=true;
        mf::LogWarning("PhotonBackTracker")<<"Failed to get BackTrackerRecords from this event. All calls to the PhotonBackTracker will fail.\n"
          <<"This message will be generated only once per lar invokation. If this is event one, be aware the PhotonBackTracker may not work on any events from this file.\n"
          <<"Please change the log level to debug if you need more information for each event.\n"
          <<"Failed with :"<<(*failMode)<<"\n";
        mf::LogDebug("PhotonBackTracker")<<"Failed to get BackTrackerRecords from this event.\n";
      }else{
        mf::LogDebug("PhotonBackTracker")<<"Failed to get BackTrackerRecords from this event.\n";
      }
    }else{//Did not fail to get products. All is well. Run as expected.
      art::fill_ptr_vector(cOpDetBacktrackerRecords, cPBTRHandle);
    }


    // grab the voxel list for this event
    //fVoxelList = sim::SimListUtils::GetLArVoxelList(evt, fG4ModuleLabel);

    fParticleList.AdoptEveIdCalculator(new sim::EmEveIdCalculator);

    LOG_DEBUG("PhotonBackTracker") << "PhotonBackTracker has " << cOpDetBacktrackerRecords.size()
           << " sim::OpDetBacktrackerRecords and " << GetSetOfTrackIDs().size()
           << " tracks.  The particles are:\n"
           << fParticleList
           << "\n the MCTruth information is\n";
    for(size_t mc = 0; mc < fMCTruthList.size(); ++mc)
      LOG_DEBUG("PhotonBackTracker") << *(fMCTruthList.at(mc).get());

    return;
  }

void cheat::PhotonBackTracker::Rebuild

(

const art::Event &

evt

)

void cheat::PhotonBackTracker::reconfigure

(

fhicl::ParameterSet const &

pset

)

void cheat::PhotonBackTracker::reconfigure

(

fhicl::ParameterSet const &

pset

)

Referenced by ~PhotonBackTracker().

void cheat::PhotonBackTracker::SetEveIdCalculator ( sim::EveIdCalculator *  ec )

inline

Definition at line 69 of file old.PhotonBackTrackerService.h.

References sim::ParticleList::AdoptEveIdCalculator(), fParticleList, MCTruthToParticles(), ParticleToMCTruth(), TrackIDToMCTruth(), TrackIDToMotherParticle(), TrackIDToParticle(), and TrackIDToSimSDP().

{ fParticleList.AdoptEveIdCalculator(ec); }

void cheat::PhotonBackTracker::SetEveIdCalculator ( sim::EveIdCalculator *  ec )

inline

Definition at line 69 of file old.PhotonBackTracker.h.

References sim::ParticleList::AdoptEveIdCalculator(), fParticleList, MCTruthToParticles(), ParticleToMCTruth(), TrackIDToMCTruth(), TrackIDToMotherParticle(), TrackIDToParticle(), and TrackIDToSimSDP().

{ fParticleList.AdoptEveIdCalculator(ec); }

const void cheat::PhotonBackTracker::shouldThisFail ( ) const

private

Definition at line 163 of file old.PhotonBackTracker_service.cc.

References have_complained.

Referenced by ChannelToTrackSDPs(), FindOpDetBacktrackerRecord(), GetSetOfEveIDs(), GetSetOfTrackIDs(), MCTruthToParticles(), OpDetBacktrackerRecords(), OpHitChargeCollectionEfficiency(), OpHitChargeCollectionPurity(), OpHitCollectionEfficiency(), OpHitCollectionPurity(), OpHitToEveSDPs(), OpHitToSDPs(), OpHitToTrackSDPs(), OpHitToXYZ(), ParticleToMCTruth(), SimSDPsToXYZ(), TrackIDsToOpHits(), TrackIDToMCTruth(), TrackIDToMotherParticle(), TrackIDToParticle(), and TrackIDToSimSDP().

                                                    {
    //I need to revisit this and see if this check is too aggressive, as it only takes one failed event to set have_complained to true for the rest of the file.
    //I currently do believe this is okay, as have_complained only flips on ProductNotFound errors, and if that happens in one event of a file,
    // it should happen in all events of the file.
    if( have_complained==true ){
      throw cet::exception("PhotonBackTracker1") << "PhotonBackTracker methods called on a file without OpDetPhotonBacktrackerRecords. Backtracked information is not available.";
    }
  }

const void cheat::PhotonBackTracker::shouldThisFail ( ) const

private

std::vector< double > cheat::PhotonBackTracker::SimSDPsToXYZ

(

std::vector< sim::SDP > const &

sdps

)

Definition at line 708 of file old.PhotonBackTracker_service.cc.

References e, shouldThisFail(), w, weight, x, y, and z.

Referenced by OpHitsToXYZ(), OpHitToSimSDPs(), OpHitToXYZ(), and cheat::PhotonBackTrackerService::SimSDPsToXYZ().

  {
    shouldThisFail();
    std::vector<double> xyz(3, -999.);

    double x = 0.;
    double y = 0.;
    double z = 0.;
    double w = 0.;

    // loop over photons.

    for(auto const& sdp : sdps) {

      double weight = sdp.numPhotons;

      w += weight;
      x += weight * sdp.x;
      y += weight * sdp.y;
      z += weight * sdp.z;

    }// end loop over sim::SDPs

    //If the sum of the weights is still zero, then fail to return a value.
    //A hit with no contributing photons does't make sense.
    if(w < 1.e-5)
      throw cet::exception("PhotonBackTracker") << "No sim::SDPs providing non-zero number of photons"
        << " can't determine originating location from truth\n";

    xyz[0] = x/w;
    xyz[1] = y/w;
    xyz[2] = z/w;

    return xyz;
  }

std::vector<double> cheat::PhotonBackTracker::SimSDPsToXYZ

(

std::vector< sim::SDP > const &

sdps

)

const std::vector< double > cheat::PhotonBackTracker::SimSDPsToXYZ

(

std::vector< sim::SDP > const &

sdps

)

const

Definition at line 358 of file PhotonBackTracker.cc.

References e, w, weight, x, y, and z.

  {
    std::vector<double> xyz(3, -999.);
    double x = 0.;
    double y = 0.;
    double z = 0.;
    double w = 0.;
    // loop over photons.
    for(auto const& sdp : sdps) {
      double weight = sdp.numPhotons;
      w += weight;
      x += weight * sdp.x;
      y += weight * sdp.y;
      z += weight * sdp.z;
    }// end loop over sim::SDPs
    //If the sum of the weights is still zero, then fail to return a value.
    //A hit with no contributing photons does't make sense.
    if(w < 1.e-5)
      throw cet::exception("PhotonBackTracker") << "No sim::SDPs providing non-zero number of photons"
        << " can't determine originating location from truth\n";
    xyz[0] = x/w;
    xyz[1] = y/w;
    xyz[2] = z/w;
    return xyz;
  }

const std::vector< double > cheat::PhotonBackTracker::SimSDPsToXYZ

(

std::vector< const sim::SDP * > const &

sdps_Ps

)

const

Definition at line 385 of file PhotonBackTracker.cc.

References e, w, weight, x, y, and z.

  {
    std::vector<double> xyz(3, -999.);
    double x = 0.;
    double y = 0.;
    double z = 0.;
    double w = 0.;
    // loop over photons.
    for(const sim::SDP* sdp_P : sdps_Ps) {
      auto& sdp = *sdp_P;
      double weight = sdp.numPhotons;
      w += weight;
      x += weight * sdp.x;
      y += weight * sdp.y;
      z += weight * sdp.z;
    }// end loop over sim::SDPs
    //If the sum of the weights is still zero, then fail to return a value.
    //A hit with no contributing photons does't make sense.
    if(w < 1.e-5)
      throw cet::exception("PhotonBackTracker") << "No sim::SDPs providing non-zero number of photons"
        << " can't determine originating location from truth\n";
    xyz[0] = x/w;
    xyz[1] = y/w;
    xyz[2] = z/w;
    return xyz;
  }

const std::vector< std::vector< art::Ptr< recob::OpHit > > > cheat::PhotonBackTracker::TrackIDsToOpHits	(	std::vector< art::Ptr< recob::OpHit >> const &	allhits,
		std::vector< int > const &	tkIDs
	)

Definition at line 277 of file old.PhotonBackTracker_service.cc.

References ChannelToTrackSDPs(), evd::details::end(), fDelay, fMinOpHitEnergyFraction, recob::OpHit::OpChannel(), recob::OpHit::PeakTime(), shouldThisFail(), and recob::OpHit::Width().

Referenced by OpHitToTrackID().

  {
    shouldThisFail();
    // returns a subset of the opHits in the allOpHits collection that are matched
    // to MC particles listed in tkIDs

    // temporary vector of TrackIDs and Ptrs to opHits so only one
    // loop through the (possibly large) allOpHits collection is needed
    std::vector<std::pair<int, art::Ptr<recob::OpHit>>> opHitList;
    std::vector<sim::TrackSDP> tids;
    for(auto itr = allOpHits.begin(); itr != allOpHits.end(); ++itr) {
      tids.clear();
      art::Ptr<recob::OpHit> const& opHit = *itr;
      const double pTime = opHit->PeakTime(), pWidth= opHit->Width();
      const double start = (pTime-pWidth)*1000.0-fDelay, end = (pTime+pWidth)*1000.0-fDelay;
      this->ChannelToTrackSDPs(tids, opHit->OpChannel(), start, end);
      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 > fMinOpHitEnergyFraction)
              opHitList.push_back(std::make_pair(*itkid, opHit));
          }
        } // itkid
      } // itid
    } // itr

    // now build the truOpHits vector that will be returned to the caller
    std::vector<std::vector<art::Ptr<recob::OpHit>>> truOpHits;
    // temporary vector containing opHits assigned to one MC particle
    std::vector<art::Ptr<recob::OpHit>> tmpOpHits;
    for(auto itkid = tkIDs.begin(); itkid != tkIDs.end(); ++itkid) {
      tmpOpHits.clear();
      for(auto itr = opHitList.begin(); itr != opHitList.end(); ++itr) {
        if(*itkid == (*itr).first) tmpOpHits.push_back((*itr).second);
      }
      truOpHits.push_back(tmpOpHits);
    }

    return truOpHits;
  }

const std::vector<std::vector<art::Ptr<recob::OpHit> > > cheat::PhotonBackTracker::TrackIDsToOpHits	(	std::vector< art::Ptr< recob::OpHit >> const &	allhits,
		std::vector< int > const &	tkIDs
	)

const std::vector< std::vector< art::Ptr< recob::OpHit > > > cheat::PhotonBackTracker::TrackIdsToOpHits_Ps	(	std::vector< int > const &	tkIds,
		std::vector< art::Ptr< recob::OpHit >> const &	hitsIn
	)

Definition at line 274 of file PhotonBackTracker.cc.

References evd::details::end(), fDelay, fGeom, fMinOpHitEnergyFraction, recob::OpHit::OpChannel(), geo::GeometryCore::OpDetFromOpChannel(), OpDetToTrackSDPs(), recob::OpHit::PeakTime(), and recob::OpHit::Width().

Referenced by cheat::PhotonBackTrackerService::TrackIdsToOpHits_Ps(), and TrackIdToOpHits_Ps().

  {
    std::vector<std::pair<int, art::Ptr<recob::OpHit>>> opHitList;
    for(auto itr = hitsIn.begin(); itr != hitsIn.end(); ++itr) {
      art::Ptr<recob::OpHit> const& opHit = *itr;
      auto OpDetNum = fGeom->OpDetFromOpChannel(opHit->OpChannel());
      const double pTime = opHit->PeakTime(), pWidth= opHit->Width();
      const double start = (pTime-pWidth)*1000.0-fDelay, end = (pTime+ pWidth)*1000.0-fDelay;
      std::vector<sim::TrackSDP> tids = this->OpDetToTrackSDPs( OpDetNum, start, end);
      //std::vector<sim::TrackSDP> tids = this->OpDetToTrackSDPs( opHit->OpChannel(), start, end);
      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 > fMinOpHitEnergyFraction)
              opHitList.push_back(std::make_pair(*itkid, opHit));
          }
        } // itkid
      } // itid
    } // itr
    // now build the truOpHits vector that will be returned to the caller
    std::vector<std::vector<art::Ptr<recob::OpHit>>> truOpHits;
    // temporary vector containing opHits assigned to one MC particle
    std::vector<art::Ptr<recob::OpHit>> tmpOpHits;
    for(auto itkid = tkIds.begin(); itkid != tkIds.end(); ++itkid) {
      tmpOpHits.clear();
      for(auto itr = opHitList.begin(); itr != opHitList.end(); ++itr) {
        if(*itkid == (*itr).first) tmpOpHits.push_back((*itr).second);
      }
      truOpHits.push_back(tmpOpHits);
    }
    return truOpHits;
  }

const art::Ptr<simb::MCTruth>& cheat::PhotonBackTracker::TrackIDToMCTruth

(

int const &

id

)

const

const art::Ptr< simb::MCTruth > & cheat::PhotonBackTracker::TrackIDToMCTruth

(

int const &

id

)

const

Definition at line 199 of file old.PhotonBackTracker_service.cc.

References fMCTruthList, fTrackIDToMCTruthIndex, and shouldThisFail().

Referenced by MCTruthToParticles(), ParticleToMCTruth(), and SetEveIdCalculator().

  {
    shouldThisFail();
    // find the entry in the MCTruth collection for this track id
    size_t mct = fTrackIDToMCTruthIndex.find(abs(id))->second;

    if(/* mct < 0 || */ mct > fMCTruthList.size() )
      throw cet::exception("PhotonBackTracker") << "attempting to find MCTruth index for "
            << "out of range value: " << mct
            << "/" << fMCTruthList.size() << "\n";

    return fMCTruthList[mct];
  }

const simb::MCParticle * cheat::PhotonBackTracker::TrackIDToMotherParticle

(

int const &

id

)

const

Definition at line 189 of file old.PhotonBackTracker_service.cc.

References sim::ParticleList::EveId(), fParticleList, shouldThisFail(), and TrackIDToParticle().

Referenced by SetEveIdCalculator().

  {
    shouldThisFail();
    // get the mother id from the particle navigator
    // the EveId was adopted in the Rebuild method

    return this->TrackIDToParticle(fParticleList.EveId(abs(id)));
  }

const simb::MCParticle* cheat::PhotonBackTracker::TrackIDToMotherParticle

(

int const &

id

)

const

const std::vector< art::Ptr< recob::OpHit > > cheat::PhotonBackTracker::TrackIdToOpHits_Ps	(	int const &	tkId,
		std::vector< art::Ptr< recob::OpHit >> const &	hitsIn
	)

Definition at line 263 of file PhotonBackTracker.cc.

References TrackIdsToOpHits_Ps().

Referenced by cheat::PhotonBackTrackerService::TrackIdToOpHits_Ps().

  {
    //One would think we would want to have this function defined, and call this function in the std::vector<tkids> to opHits, but that would require more loops (and a higher overhead.) Instead, to provide this, we will just call the existing std::vector<tkids>ToOpHits with an input of 1.
    std::vector<int> tkidFake(1, tkId);
    //std::vector<art::Ptr<recob::OpHit>> retVec = (this->TrackIdsToOpHits_Ps(tkidFake, hitsIn)).at(0);
    // return (this->TrackIdsToOpHits_Ps(tkidFake, hitsIn));
    const std::vector<art::Ptr<recob::OpHit>> out = (this->TrackIdsToOpHits_Ps(tkidFake, hitsIn)).at(0);
    return out;
  }

const simb::MCParticle * cheat::PhotonBackTracker::TrackIDToParticle

(

int const &

id

)

const

Definition at line 173 of file old.PhotonBackTracker_service.cc.

References sim::ParticleList::end(), sim::ParticleList::find(), fParticleList, and shouldThisFail().

Referenced by SetEveIdCalculator(), and TrackIDToMotherParticle().

  {
    shouldThisFail();
    sim::ParticleList::const_iterator part_it = fParticleList.find(id);

    if(part_it == fParticleList.end()){
      mf::LogWarning("PhotonBackTracker") << "can't find particle with track id "
            << id << " in sim::ParticleList"
            << " returning null pointer";
      return 0;
    }

    return part_it->second;
  }

const simb::MCParticle* cheat::PhotonBackTracker::TrackIDToParticle

(

int const &

id

)

const

std::vector< sim::SDP > cheat::PhotonBackTracker::TrackIDToSimSDP

(

int const &

id

)

const

Definition at line 214 of file old.PhotonBackTracker_service.cc.

References cOpDetBacktrackerRecords, and shouldThisFail().

Referenced by SetEveIdCalculator().

  {
    shouldThisFail();
    std::vector<sim::SDP> sdps;

    // loop over all sim::OpDetBacktrackerRecords and fill a vector
    // of sim::SDP objects for the given track id
    for(size_t sc = 0; sc < cOpDetBacktrackerRecords.size(); ++sc){
      const auto & pdTimeSDPmap = cOpDetBacktrackerRecords[sc]->timePDclockSDPsMap();

      // loop over the SDPMAP
      for(auto mapitr = pdTimeSDPmap.begin(); mapitr != pdTimeSDPmap.end(); mapitr++){

  // loop over the vector of SDP objects.
  const std::vector<sim::SDP>& sdpvec = (*mapitr).second;
  for(size_t iv = 0; iv < sdpvec.size(); ++iv){
    if( abs(sdpvec[iv].trackID) == id) sdps.push_back(sdpvec[iv]);
  }

      } // end loop over map from sim::OpDetBacktrackerRecord
    } // end loop over sim::OpDetBacktrackerRecords

    return sdps;
  }

std::vector<sim::SDP> cheat::PhotonBackTracker::TrackIDToSimSDP

(

int const &

id

)

const

const std::vector< const sim::SDP * > cheat::PhotonBackTracker::TrackIdToSimSDPs_Ps

(

int const &

id

)

Definition at line 88 of file PhotonBackTracker.cc.

References evd::details::end(), and priv_OpDetBTRs.

Referenced by OpHitToEveSimSDPs_Ps(), and cheat::PhotonBackTrackerService::TrackIdToSimSDPs_Ps().

  {
    std::vector< const sim::SDP* > sdp_Ps;
    for(size_t odet=0; odet<priv_OpDetBTRs.size(); ++odet){
      const auto & pdTimeSDPmap = priv_OpDetBTRs[odet]->timePDclockSDPsMap();
      for(auto mapitr = pdTimeSDPmap.begin(); mapitr != pdTimeSDPmap. end(); mapitr++){
        std::vector<sim::SDP> const& sdpvec = (*mapitr).second;
        for(size_t iv = 0; iv < sdpvec.size(); ++iv){
      //    const sim::SDP* const sdp_P = &sdpvec[iv];
          if( abs(sdpvec[iv].trackID) == id) sdp_Ps.push_back(&(sdpvec[iv]));
        }
      } // end loop over map from sim::OpDetBacktrackerRecord


    }// end loop over sim::OpDetBacktrackerRecords
    return sdp_Ps;
  }

const std::vector< const sim::SDP * > cheat::PhotonBackTracker::TrackIdToSimSDPs_Ps	(	int const &	id,
		geo::View_t const &	view
	)

Definition at line 107 of file PhotonBackTracker.cc.

  {
    throw cet::exception("PhotonBackTracker")
      <<"PhotonBackTracker is not equiped to handle geo::Views.";
  }

Member Data Documentation

std::vector< art::Ptr< sim::OpDetBacktrackerRecord > > cheat::PhotonBackTracker::cOpDetBacktrackerRecords

private

all the OpDetBacktrackerRecords for the event

Definition at line 190 of file old.PhotonBackTracker.h.

Referenced by FindOpDetBacktrackerRecord(), OpDetBacktrackerRecords(), Rebuild(), and TrackIDToSimSDP().

double cheat::PhotonBackTracker::fDelay

private

Definition at line 194 of file old.PhotonBackTracker.h.

Referenced by GetSetOfTrackIDs(), OpDetBacktrackerRecords(), OpHitToSDPs(), OpHitToSimSDPs_Ps(), OpHitToTrackSDPs(), TrackIDsToOpHits(), TrackIdsToOpHits_Ps(), and ~PhotonBackTracker().

const double cheat::PhotonBackTracker::fDelay

private

Definition at line 235 of file PhotonBackTracker.h.

std::string cheat::PhotonBackTracker::fG4ModuleLabel

private

label for geant4 module

Definition at line 192 of file old.PhotonBackTracker.h.

Referenced by OpDetBacktrackerRecords(), Rebuild(), and ~PhotonBackTracker().

const art::InputTag cheat::PhotonBackTracker::fG4ModuleLabel

private

Definition at line 236 of file PhotonBackTracker.h.

const geo::GeometryCore* cheat::PhotonBackTracker::fGeom

private

Definition at line 233 of file PhotonBackTracker.h.

Referenced by OpHitToSimSDPs_Ps(), OpHitToTrackSDPs(), and TrackIdsToOpHits_Ps().

std::vector< art::Ptr< simb::MCTruth > > cheat::PhotonBackTracker::fMCTruthList

private

all the MCTruths for the event

Definition at line 189 of file old.PhotonBackTracker.h.

Referenced by MCTruthVector(), OpDetBacktrackerRecords(), Rebuild(), and TrackIDToMCTruth().

double cheat::PhotonBackTracker::fMinOpHitEnergyFraction

private

minimum fraction of energy a track id has to

Definition at line 193 of file old.PhotonBackTracker.h.

Referenced by OpDetBacktrackerRecords(), OpHitChargeCollectionEfficiency(), OpHitCollectionEfficiency(), OpHitLightCollectionEfficiency(), TrackIDsToOpHits(), TrackIdsToOpHits_Ps(), and ~PhotonBackTracker().

const double cheat::PhotonBackTracker::fMinOpHitEnergyFraction

private

Definition at line 239 of file PhotonBackTracker.h.

const art::InputTag cheat::PhotonBackTracker::fOpFlashLabel

private

Definition at line 238 of file PhotonBackTracker.h.

std::map< art::Ptr < recob::OpFlash >, std::vector < art::Ptr < recob::OpHit > > > cheat::PhotonBackTracker::fOpFlashToOpHits

private

Definition at line 241 of file PhotonBackTracker.h.

Referenced by OpFlashToOpHits_Ps(), and OpFlashToOpHitsReady().

const art::InputTag cheat::PhotonBackTracker::fOpHitLabel

private

Definition at line 237 of file PhotonBackTracker.h.

sim::ParticleList cheat::PhotonBackTracker::fParticleList

private

ParticleList to map track ID to sim::Particle.

Definition at line 185 of file old.PhotonBackTracker.h.

Referenced by GetSetOfEveIDs(), GetSetOfTrackIDs(), MCTruthToParticles(), OpDetBacktrackerRecords(), OpHitToEveSDPs(), ParticleList(), Rebuild(), SetEveIdCalculator(), TrackIDToMotherParticle(), and TrackIDToParticle().

const cheat::ParticleInventory* cheat::PhotonBackTracker::fPartInv

private

Definition at line 232 of file PhotonBackTracker.h.

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

std::map< int, int > cheat::PhotonBackTracker::fTrackIDToMCTruthIndex

private

map of track ids to MCTruthList entry

Definition at line 191 of file old.PhotonBackTracker.h.

Referenced by OpDetBacktrackerRecords(), Rebuild(), and TrackIDToMCTruth().

sim::LArVoxelList cheat::PhotonBackTracker::fVoxelList

private

List to map the position of energy depostions in voxels to the particles depositing the energy

Definition at line 186 of file old.PhotonBackTracker.h.

Referenced by OpDetBacktrackerRecords().

geo::GeometryCore const * cheat::PhotonBackTracker::geom = lar::providerFrom<geo::Geometry>()

private

Definition at line 177 of file old.PhotonBackTracker.h.

Referenced by ChannelToTrackSDPs(), OpDetBacktrackerRecords(), and OpHitToSDPs().

bool cheat::PhotonBackTracker::have_complained

private

Definition at line 183 of file old.PhotonBackTracker.h.

Referenced by OpDetBacktrackerRecords(), Rebuild(), shouldThisFail(), and ~PhotonBackTracker().

std::vector<art::Ptr<sim::OpDetBacktrackerRecord> > cheat::PhotonBackTracker::priv_OpDetBTRs

mutableprivate

Definition at line 240 of file PhotonBackTracker.h.

Referenced by BTRsReady(), ClearEvent(), FindOpDetBTR(), OpDetBTRs(), and TrackIdToSimSDPs_Ps().

---

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

• larsim/v06_53_00/source/larsim/MCCheater/old.PhotonBackTracker.h
• larsim/v06_53_00/source/larsim/MCCheater/old.PhotonBackTrackerService.h
• larsim/v06_53_00/source/larsim/MCCheater/PhotonBackTracker.h
• larsim/v06_53_00/source/larsim/MCCheater/old.PhotonBackTracker_service.cc
• larsim/v06_53_00/source/larsim/MCCheater/PhotonBackTracker.cc