cheat::PhotonBackTrackerService Class Reference

#include "PhotonBackTrackerService.h"

Inheritance diagram for cheat::PhotonBackTrackerService:

Classes
struct	fhiclConfig

Public Types
using	provider_type = PhotonBackTracker

Public Member Functions
const provider_type *	provider () const
	PhotonBackTrackerService (fhicl::ParameterSet const &pSet, art::ActivityRegistry &reg)
	PhotonBackTrackerService (fhiclConfig const &config, art::ActivityRegistry &reg)
void	Rebuild (art::Event const &evt)
std::vector< art::Ptr< sim::OpDetBacktrackerRecord > > const &	OpDetBTRs ()
double	GetDelay ()
std::vector< const sim::SDP * >	TrackIdToSimSDPs_Ps (int id)
art::Ptr< sim::OpDetBacktrackerRecord >	FindOpDetBTR (int opDetNum)
std::vector< sim::TrackSDP >	OpDetToTrackSDPs (int OpDetNum, double opHit_start_time, double opHit_end_time)
std::vector< sim::TrackSDP >	OpHitToTrackSDPs (art::Ptr< recob::OpHit > const &opHit_P)
std::vector< sim::TrackSDP >	OpHitToTrackSDPs (recob::OpHit const &opHit)
std::vector< int >	OpHitToTrackIds (recob::OpHit const &opHit)
std::vector< int >	OpHitToTrackIds (art::Ptr< recob::OpHit > const &opHit_P)
std::vector< int >	OpHitToEveTrackIds (recob::OpHit const &opHit)
std::vector< int >	OpHitToEveTrackIds (art::Ptr< recob::OpHit > const &opHit_P)
std::vector< sim::TrackSDP >	OpHitToEveTrackSDPs (art::Ptr< recob::OpHit > const &opHit_P)
std::vector< sim::TrackSDP >	OpHitToEveTrackSDPs (recob::OpHit const &opHit)
std::vector< art::Ptr< recob::OpHit > >	TrackIdToOpHits_Ps (int tkId, std::vector< art::Ptr< recob::OpHit >> const &hitsIn)
std::vector< std::vector< art::Ptr< recob::OpHit > > >	TrackIdsToOpHits_Ps (std::vector< int > const &tkIds, std::vector< art::Ptr< recob::OpHit >> const &hitsIn)
std::vector< const sim::SDP * >	OpHitToSimSDPs_Ps (recob::OpHit const &opHit)
std::vector< const sim::SDP * >	OpHitToSimSDPs_Ps (art::Ptr< recob::OpHit > const &opHit_P)
std::unordered_set< const sim::SDP * >	OpHitToEveSimSDPs_Ps (recob::OpHit const &opHit)
std::unordered_set< const sim::SDP * >	OpHitToEveSimSDPs_Ps (art::Ptr< recob::OpHit > &opHit_P)
std::vector< double >	SimSDPsToXYZ (std::vector< sim::SDP > const &sdps) const &
std::vector< double >	SimSDPsToXYZ (std::vector< const sim::SDP * > const &sdps_Ps)
std::vector< double >	OpHitToXYZ (recob::OpHit const &opHit)
std::vector< double >	OpHitToXYZ (art::Ptr< recob::OpHit > const &opHit_P)
std::set< int >	GetSetOfEveIds ()
std::set< int >	GetSetOfTrackIds ()
std::set< int >	GetSetOfEveIds (std::vector< art::Ptr< recob::OpHit >> const &opHits_Ps)
std::set< int >	GetSetOfEveIds (const std::vector< recob::OpHit > &opHits)
std::set< int >	GetSetOfTrackIds (std::vector< art::Ptr< recob::OpHit >> const &opHits_Ps)
std::set< int >	GetSetOfTrackIds (std::vector< recob::OpHit > const &opHits)
double	OpHitCollectionPurity (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit >> const &opHits_Ps)
double	OpHitLightCollectionPurity (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit >> const &opHits_Ps)
double	OpHitCollectionEfficiency (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit >> const &opHits_Ps, std::vector< art::Ptr< recob::OpHit >> const &opHitsIn_Ps)
double	OpHitLightCollectionEfficiency (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit >> const &opHits_Ps, std::vector< art::Ptr< recob::OpHit >> const &opHitsIn_Ps)
double	OpHitChargeCollectionEfficiency (std::set< int > const &tkIds, std::vector< art::Ptr< recob::OpHit >> const &opHits_Ps, std::vector< art::Ptr< recob::OpHit >> const &opHitsIn_Ps)
std::set< int >	OpFlashToTrackIds (art::Ptr< recob::OpFlash > &flash_P) const
std::vector< art::Ptr< recob::OpHit > >	OpFlashToOpHits_Ps (art::Ptr< recob::OpFlash > &flash_P)
std::vector< double >	OpFlashToXYZ (art::Ptr< recob::OpFlash > &flash_P)

Private Member Functions
void	priv_PrepEvent (art::Event const &evt, art::ScheduleContext)
void	priv_PrepFailed ()
void	priv_PrepOpDetBTRs (art::Event const &evt)
void	priv_PrepOpFlashToOpHits (art::Event const &evt)
bool	priv_CanRun (art::Event const &evt)
bool	priv_OpDetBTRsReady ()
bool	priv_OpFlashToOpHitsReady ()
void	reconfigure (fhicl::ParameterSet const &pset)
void	reconfigure (fhicl::ParameterSet const &pset)
void	Rebuild (const art::Event &evt)
const sim::ParticleList &	ParticleList () const
const sim::ParticleList &	ParticleList () const
void	SetEveIdCalculator (sim::EveIdCalculator *ec)
void	SetEveIdCalculator (sim::EveIdCalculator *ec)
const simb::MCParticle *	TrackIDToParticle (int const &id) const
const simb::MCParticle *	TrackIDToParticle (int const &id) const
const simb::MCParticle *	TrackIDToMotherParticle (int const &id) const
const simb::MCParticle *	TrackIDToMotherParticle (int const &id) const
std::vector< sim::SDP >	TrackIDToSimSDP (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 > &	TrackIDToMCTruth (int const &id) const
const art::Ptr< simb::MCTruth > &	ParticleToMCTruth (const simb::MCParticle *p) 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
std::vector< const simb::MCParticle * >	MCTruthToParticles (art::Ptr< simb::MCTruth > const &mct) const
const std::vector< art::Ptr< simb::MCTruth > > &	MCTruthVector () const
const std::vector< art::Ptr< simb::MCTruth > > &	MCTruthVector () const
DEPRECATED std::vector< sim::TrackSDP >	OpHitToTrackID (art::Ptr< recob::OpHit > const &hit)
DEPRECATED std::vector< sim::TrackSDP >	OpHitToTrackID (art::Ptr< recob::OpHit > const &hit)
std::vector< sim::TrackSDP >	OpHitToTrackSDPs (art::Ptr< recob::OpHit > const &opHit_P) const
std::vector< sim::TrackSDP >	OpHitToTrackSDPs (recob::OpHit const &opHit) const
const std::vector< std::vector< art::Ptr< recob::OpHit > > >	TrackIDsToOpHits (std::vector< art::Ptr< recob::OpHit >> const &allhits, std::vector< int > const &tkIDs)
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 >	OpHitToEveSDPs (art::Ptr< recob::OpHit > const &hit)
std::vector< sim::TrackSDP >	OpHitToEveID (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 >	SimSDPsToXYZ (std::vector< const sim::SDP * > const &sdps_Ps) const &
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	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 >	GetSetOfEveIDs (std::vector< art::Ptr< recob::OpHit >> const &hits)
std::set< int >	GetSetOfEveIDs ()
std::set< int >	GetSetOfEveIDs (std::vector< art::Ptr< recob::OpHit >> const &hits)
std::set< int >	GetSetOfTrackIDs ()
std::set< int >	GetSetOfTrackIDs (std::vector< art::Ptr< recob::OpHit >> const &hits)
std::set< int >	GetSetOfTrackIDs ()
std::set< int >	GetSetOfTrackIDs (std::vector< art::Ptr< recob::OpHit >> const &hits)
const std::vector< art::Ptr< sim::OpDetBacktrackerRecord > > &	OpDetBacktrackerRecords () const
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)
void	ChannelToTrackSDPs (std::vector< sim::TrackSDP > &trackSDPs, int channel, const double hit_start_time, const double hit_end_time)
template<typename Evt >
void	PrepEvent (Evt const &evt)
template<typename Evt >
bool	CanRun (Evt const &evt)
template<typename Evt >
void	PrepOpDetBTRs (Evt const &evt)
template<typename Evt >
void	PrepOpFlashToOpHits (Evt const &evt)
std::vector< art::Ptr< recob::OpHit > >	OpFlashToOpHits_Ps (art::Ptr< recob::OpFlash > &flash_P) const
std::vector< double >	OpFlashToXYZ (art::Ptr< recob::OpFlash > &flash_P) const
double	GetDelay () const
void	ClearEvent ()
bool	BTRsReady () const
bool	OpFlashToOpHitsReady () const
std::vector< art::Ptr< sim::OpDetBacktrackerRecord > > const &	OpDetBTRs () const
std::vector< const sim::SDP * >	TrackIdToSimSDPs_Ps (int id) const
art::Ptr< sim::OpDetBacktrackerRecord >	FindOpDetBTR (int opDetNum) const
std::vector< sim::TrackSDP >	OpDetToTrackSDPs (int OpDetNum, double opHit_start_time, double opHit_end_time) const
std::vector< int >	OpHitToTrackIds (recob::OpHit const &opHit) const
std::vector< int >	OpHitToTrackIds (art::Ptr< recob::OpHit > const &opHit) const
std::vector< sim::TrackSDP >	OpHitToEveTrackSDPs (art::Ptr< recob::OpHit > const &opHit_P) const
std::vector< sim::TrackSDP >	OpHitToEveTrackSDPs (recob::OpHit const &opHit) const
std::vector< art::Ptr< recob::OpHit > >	TrackIdToOpHits_Ps (int 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
std::vector< const sim::SDP * >	OpHitToSimSDPs_Ps (art::Ptr< recob::OpHit > const &opHit_P) const
std::vector< const sim::SDP * >	OpHitsToSimSDPs_Ps (std::vector< art::Ptr< recob::OpHit >> const &opHits_Ps) const
std::vector< double >	OpHitsToXYZ (std::vector< art::Ptr< recob::OpHit >> const &opHits_Ps) const
std::set< int >	GetSetOfEveIds () const
std::set< int >	GetSetOfEveIds (std::vector< art::Ptr< recob::OpHit >> const &opHits) const
std::set< int >	GetSetOfEveIds (std::vector< recob::OpHit > const &opHits) const
std::set< int >	GetSetOfTrackIds () const
std::set< int >	GetSetOfTrackIds (std::vector< art::Ptr< recob::OpHit >> const &opHits) const
std::set< int >	GetSetOfTrackIds (std::vector< recob::OpHit > const &opHits) const
void	OpHitToSDPs (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 (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
void	OpHitToSDPs (art::Ptr< recob::OpHit > const &hit, std::vector< sim::SDP > &sdps) const
DEPRECATED void	OpHitToSimSDPs (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

Detailed Description

Definition at line 35 of file PhotonBackTrackerService.h.

Member Typedef Documentation

using cheat::PhotonBackTrackerService::provider_type = PhotonBackTracker

Definition at line 44 of file PhotonBackTrackerService.h.

Constructor & Destructor Documentation

cheat::PhotonBackTrackerService::PhotonBackTrackerService	(	fhicl::ParameterSet const &	pSet,
		art::ActivityRegistry &	reg
	)

Definition at line 26 of file PhotonBackTrackerService.cc.

References priv_PrepEvent(), and art::ActivityRegistry::sPreProcessEvent.

    : PhotonBackTracker(pSet.get<fhicl::ParameterSet>("PhotonBackTracker"),
                        lar::providerFrom<cheat::ParticleInventoryService>(),
                        &art::ServiceHandle<geo::WireReadout const>()->Get())
  {
    reg.sPreProcessEvent.watch(this, &PhotonBackTrackerService::priv_PrepEvent);
  }

cheat::PhotonBackTrackerService::PhotonBackTrackerService	(	fhiclConfig const &	config,
		art::ActivityRegistry &	reg
	)

Definition at line 36 of file PhotonBackTrackerService.cc.

References priv_PrepEvent(), and art::ActivityRegistry::sPreProcessEvent.

    : PhotonBackTracker(config.PhotonBackTrackerTable(),
                        lar::providerFrom<cheat::ParticleInventoryService>(),
                        &art::ServiceHandle<geo::WireReadout const>()->Get())
  {
    reg.sPreProcessEvent.watch(this, &PhotonBackTrackerService::priv_PrepEvent);
  }

Member Function Documentation

bool cheat::PhotonBackTracker::BTRsReady ( ) const

inherited

Definition at line 74 of file PhotonBackTracker.cc.

  {
    return !priv_OpDetBTRs.empty();
  }

template<typename Evt >

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

inherited

Referenced by priv_CanRun().

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

inherited

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

inherited

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

References e, sim::TrackSDP::energy, energy, sim::TrackSDP::energyFrac, cheat::PhotonBackTracker::FindOpDetBacktrackerRecord(), cheat::PhotonBackTracker::geom, sim::NoParticleId, cheat::PhotonBackTracker::shouldThisFail(), sim::TrackSDP::trackID, and sim::OpDetBacktrackerRecord::TrackIDsAndEnergies().

Referenced by cheat::PhotonBackTracker::GetSetOfTrackIDs(), cheat::PhotonBackTracker::OpDetBacktrackerRecords(), cheat::PhotonBackTracker::OpHitToTrackSDPs(), and cheat::PhotonBackTracker::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 ( )

inherited

Definition at line 67 of file PhotonBackTracker.cc.

Referenced by priv_PrepEvent().

  {
    priv_OpDetBTRs.clear();
    priv_OpFlashToOpHits.clear();
  }

art::Ptr< sim::OpDetBacktrackerRecord > cheat::PhotonBackTrackerService::FindOpDetBTR

(

int

opDetNum

)

Definition at line 133 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::FindOpDetBTR().

  {
    return PhotonBackTracker::FindOpDetBTR(opDetNum);
  }

art::Ptr< sim::OpDetBacktrackerRecord > cheat::PhotonBackTracker::FindOpDetBTR ( int  opDetNum ) const

inherited

Definition at line 108 of file PhotonBackTracker.cc.

References sc.

Referenced by FindOpDetBTR().

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

double cheat::PhotonBackTrackerService::GetDelay

(

)

Definition at line 121 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::GetDelay().

  {
    return PhotonBackTracker::GetDelay();
  }

double cheat::PhotonBackTracker::GetDelay ( ) const

inherited

Definition at line 61 of file PhotonBackTracker.cc.

Referenced by GetDelay().

  {
    return fDelay;
  }

std::set< int > cheat::PhotonBackTrackerService::GetSetOfEveIds

(

)

Definition at line 271 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::GetSetOfEveIds().

  {
    return PhotonBackTracker::GetSetOfEveIds();
  }

std::set< int > cheat::PhotonBackTrackerService::GetSetOfEveIds

(

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

opHits_Ps

)

Definition at line 283 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::GetSetOfEveIds().

  {
    return PhotonBackTracker::GetSetOfEveIds(opHits_Ps);
  }

std::set< int > cheat::PhotonBackTrackerService::GetSetOfEveIds

(

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

opHits

)

Definition at line 289 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::GetSetOfEveIds().

  {
    return PhotonBackTracker::GetSetOfEveIds(opHits);
  }

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

inherited

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

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

Referenced by cheat::PhotonBackTracker::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 ( )

inherited

std::set< int > cheat::PhotonBackTracker::GetSetOfEveIDs ( std::vector< art::Ptr< recob::OpHit >> const &  hits )

inherited

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

References cheat::PhotonBackTracker::OpHitToEveID(), and cheat::PhotonBackTracker::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;
  }

std::set<int> cheat::PhotonBackTracker::GetSetOfEveIDs ( std::vector< art::Ptr< recob::OpHit >> const &  hits )

inherited

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

inherited

Definition at line 468 of file PhotonBackTracker.cc.

Referenced by GetSetOfEveIds().

  {
    return fPartInv->GetSetOfEveIds();
  }

std::set< int > cheat::PhotonBackTracker::GetSetOfEveIds ( std::vector< art::Ptr< recob::OpHit >> const &  opHits ) const

inherited

Definition at line 480 of file PhotonBackTracker.cc.

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

std::set< int > cheat::PhotonBackTracker::GetSetOfEveIds ( std::vector< recob::OpHit > const &  opHits ) const

inherited

Definition at line 494 of file PhotonBackTracker.cc.

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

std::set< int > cheat::PhotonBackTrackerService::GetSetOfTrackIds

(

)

Definition at line 277 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::GetSetOfTrackIds().

  {
    return PhotonBackTracker::GetSetOfTrackIds();
  }

std::set< int > cheat::PhotonBackTrackerService::GetSetOfTrackIds

(

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

opHits_Ps

)

Definition at line 295 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::GetSetOfTrackIds().

  {
    return PhotonBackTracker::GetSetOfTrackIds(opHits_Ps);
  }

std::set< int > cheat::PhotonBackTrackerService::GetSetOfTrackIds

(

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

opHits

)

Definition at line 301 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::GetSetOfTrackIds().

  {
    return PhotonBackTracker::GetSetOfTrackIds(opHits);
  }

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

inherited

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

References cheat::PhotonBackTracker::fParticleList, and cheat::PhotonBackTracker::shouldThisFail().

Referenced by cheat::PhotonBackTracker::OpHitToSimSDPs(), and cheat::PhotonBackTracker::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 ( )

inherited

std::set< int > cheat::PhotonBackTracker::GetSetOfTrackIDs ( std::vector< art::Ptr< recob::OpHit >> const &  hits )

inherited

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

References cheat::PhotonBackTracker::ChannelToTrackSDPs(), util::end(), cheat::PhotonBackTracker::fDelay, and cheat::PhotonBackTracker::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 )

inherited

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

inherited

Definition at line 474 of file PhotonBackTracker.cc.

Referenced by GetSetOfTrackIds().

  {
    return fPartInv->GetSetOfTrackIds();
  }

std::set< int > cheat::PhotonBackTracker::GetSetOfTrackIds ( std::vector< art::Ptr< recob::OpHit >> const &  opHits ) const

inherited

Definition at line 507 of file PhotonBackTracker.cc.

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

std::set< int > cheat::PhotonBackTracker::GetSetOfTrackIds ( std::vector< recob::OpHit > const &  opHits ) const

inherited

Definition at line 520 of file PhotonBackTracker.cc.

  {
    std::set<int> tids;
    for (auto const& opHit : opHits) {
      for (auto const& sdp : 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

inherited

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

References cheat::PhotonBackTracker::fParticleList, cheat::PhotonBackTracker::shouldThisFail(), and cheat::PhotonBackTracker::TrackIDToMCTruth().

Referenced by cheat::PhotonBackTracker::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;
  }

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

inherited

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

inlineinherited

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

References cheat::PhotonBackTracker::fMCTruthList.

{ return fMCTruthList; }

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

inlineinherited

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

References cheat::PhotonBackTracker::fMCTruthList.

{ return fMCTruthList; }

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

inlineinherited

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

References cheat::PhotonBackTracker::ChannelToTrackSDPs(), and cheat::PhotonBackTracker::cOpDetBacktrackerRecords.

    {
      return cOpDetBacktrackerRecords;
    }

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

inlineinherited

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

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

    {
      return cOpDetBacktrackerRecords;
    }

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

(

)

Definition at line 115 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpDetBTRs().

  {
    return PhotonBackTracker::OpDetBTRs();
  }

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

inherited

Definition at line 86 of file PhotonBackTracker.cc.

Referenced by OpDetBTRs().

  {
    return priv_OpDetBTRs;
  }

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

Definition at line 139 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpDetToTrackSDPs().

  {
    return PhotonBackTracker::OpDetToTrackSDPs(OpDetNum, opHit_start_time, opHit_end_time);
  }

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

inherited

Definition at line 124 of file PhotonBackTracker.cc.

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

Referenced by OpDetToTrackSDPs().

  {
    std::vector<sim::TrackSDP> tSDPs;
    double totalE = 0;
    try {
      const art::Ptr<sim::OpDetBacktrackerRecord> opDetBTR = FindOpDetBTR(OpDetNum);
      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 = std::abs(simSDPs[e].trackID);
        info.energyFrac = simSDPs[e].energy / totalE;
        info.energy = simSDPs[e].energy;
        tSDPs.push_back(info);
      }
    }
    catch (cet::exception const& e) {
      // This needs to go. Make it specific if there is a really an exception we would
      // like to catch.
      mf::LogWarning("PhotonBackTracker") << "Exception caught\n" << e;
    }
    return tSDPs;
  }

std::vector< art::Ptr< recob::OpHit > > cheat::PhotonBackTrackerService::OpFlashToOpHits_Ps

(

art::Ptr< recob::OpFlash > &

flash_P

)

Definition at line 347 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpFlashToOpHits_Ps().

  {
    return PhotonBackTracker::OpFlashToOpHits_Ps(flash_P);
  }

std::vector< art::Ptr< recob::OpHit > > cheat::PhotonBackTracker::OpFlashToOpHits_Ps ( art::Ptr< recob::OpFlash > &  flash_P ) const

inherited

Definition at line 674 of file PhotonBackTracker.cc.

Referenced by OpFlashToOpHits_Ps().

  {
    // 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.
    return priv_OpFlashToOpHits.at(flash_P);
  }

bool cheat::PhotonBackTracker::OpFlashToOpHitsReady ( ) const

inherited

Definition at line 80 of file PhotonBackTracker.cc.

  {
    return !priv_OpFlashToOpHits.empty();
  }

std::set< int > cheat::PhotonBackTrackerService::OpFlashToTrackIds

(

art::Ptr< recob::OpFlash > &

flash_P

)

const

Definition at line 341 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpFlashToTrackIds().

  {
    return PhotonBackTracker::OpFlashToTrackIds(flash_P);
  }

std::vector< double > cheat::PhotonBackTrackerService::OpFlashToXYZ

(

art::Ptr< recob::OpFlash > &

flash_P

)

Definition at line 354 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpFlashToXYZ().

  {
    return PhotonBackTracker::OpFlashToXYZ(flash_P);
  }

std::vector< double > cheat::PhotonBackTracker::OpFlashToXYZ ( art::Ptr< recob::OpFlash > &  flash_P ) const

inherited

Definition at line 684 of file PhotonBackTracker.cc.

Referenced by OpFlashToXYZ().

  {
    return OpHitsToXYZ(OpFlashToOpHits_Ps(flash_P));
  }

double cheat::PhotonBackTrackerService::OpHitChargeCollectionEfficiency ( std::set< int > const &  tkIds, std::vector< art::Ptr< recob::OpHit >> const &  opHits_Ps, std::vector< art::Ptr< recob::OpHit >> const &  opHitsIn_Ps  )

inline

Definition at line 101 of file PhotonBackTrackerService.h.

    {
      return PhotonBackTracker::OpHitLightCollectionEfficiency(tkIds, opHits_Ps, opHitsIn_Ps);
    } //Exists only temporarily. Is deprecated.

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

inherited

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

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

Referenced by cheat::PhotonBackTracker::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, geo::View_t const &  view  )

inherited

Definition at line 566 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  )

inherited

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

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

Referenced by cheat::PhotonBackTracker::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  )

inherited

double cheat::PhotonBackTrackerService::OpHitCollectionEfficiency	(	std::set< int > const &	tkIds,
		std::vector< art::Ptr< recob::OpHit >> const &	opHits_Ps,
		std::vector< art::Ptr< recob::OpHit >> const &	opHitsIn_Ps
	)

Definition at line 323 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitCollectionEfficiency().

  {
    return PhotonBackTracker::OpHitCollectionEfficiency(tkIds, opHits_Ps, opHitsIn_Ps);
  }

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

inherited

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

References e, cheat::PhotonBackTracker::fMinOpHitEnergyFraction, cheat::PhotonBackTracker::OpHitToTrackSDPs(), and cheat::PhotonBackTracker::shouldThisFail().

Referenced by OpHitCollectionEfficiency(), and cheat::PhotonBackTracker::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, geo::View_t const &  view  )

inherited

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

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

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

Definition at line 307 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitCollectionPurity().

  {
    return PhotonBackTracker::OpHitCollectionPurity(tkIds, opHits_Ps);
  }

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

inherited

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

References e, cheat::PhotonBackTracker::OpHitToTrackSDPs(), and cheat::PhotonBackTracker::shouldThisFail().

Referenced by OpHitCollectionPurity(), and cheat::PhotonBackTracker::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;
  }

double cheat::PhotonBackTrackerService::OpHitLightCollectionEfficiency	(	std::set< int > const &	tkIds,
		std::vector< art::Ptr< recob::OpHit >> const &	opHits_Ps,
		std::vector< art::Ptr< recob::OpHit >> const &	opHitsIn_Ps
	)

Definition at line 332 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitLightCollectionEfficiency().

  {
    return PhotonBackTracker::OpHitLightCollectionEfficiency(tkIds, opHits_Ps, opHitsIn_Ps);
  }

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

Definition at line 315 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitLightCollectionPurity().

  {
    return PhotonBackTracker::OpHitLightCollectionPurity(tkIds, opHits_Ps);
  }

std::vector< const sim::SDP * > cheat::PhotonBackTracker::OpHitsToSimSDPs_Ps ( std::vector< art::Ptr< recob::OpHit >> const &  opHits_Ps ) const

inherited

Definition at line 418 of file PhotonBackTracker.cc.

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

std::vector< double > cheat::PhotonBackTracker::OpHitsToXYZ ( std::vector< art::Ptr< recob::OpHit >> const &  opHits_Ps ) const

inherited

Definition at line 430 of file PhotonBackTracker.cc.

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

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

inherited

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

References cheat::PhotonBackTracker::OpHitToEveSDPs().

Referenced by cheat::PhotonBackTracker::GetSetOfEveIDs(), and cheat::PhotonBackTracker::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 )

inherited

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

inherited

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

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

Referenced by cheat::PhotonBackTracker::OpHitToEveID(), and cheat::PhotonBackTracker::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 )

inherited

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

(

recob::OpHit const &

opHit

)

Definition at line 231 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToEveSimSDPs_Ps().

  {
    return PhotonBackTracker::OpHitToEveSimSDPs_Ps(opHit);
  }

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

(

art::Ptr< recob::OpHit > &

opHit_P

)

Definition at line 238 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToEveSimSDPs_Ps().

  {
    return PhotonBackTracker::OpHitToEveSimSDPs_Ps(opHit_P);
  }

std::vector< int > cheat::PhotonBackTrackerService::OpHitToEveTrackIds

(

recob::OpHit const &

opHit

)

Definition at line 174 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToEveTrackIds().

  {
    return PhotonBackTracker::OpHitToEveTrackIds(opHit);
  }

std::vector< int > cheat::PhotonBackTrackerService::OpHitToEveTrackIds

(

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

opHit_P

)

Definition at line 180 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToEveTrackIds().

  {
    return PhotonBackTracker::OpHitToEveTrackIds(opHit_P);
  }

std::vector< sim::TrackSDP > cheat::PhotonBackTrackerService::OpHitToEveTrackSDPs

(

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

opHit_P

)

Definition at line 187 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToEveTrackSDPs().

  {
    return PhotonBackTracker::OpHitToEveTrackSDPs(opHit_P);
  }

std::vector< sim::TrackSDP > cheat::PhotonBackTrackerService::OpHitToEveTrackSDPs

(

recob::OpHit const &

opHit

)

Definition at line 194 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToEveTrackSDPs().

  {
    return PhotonBackTracker::OpHitToEveTrackSDPs(opHit);
  }

std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToEveTrackSDPs ( art::Ptr< recob::OpHit > const &  opHit_P ) const

inherited

Definition at line 210 of file PhotonBackTracker.cc.

Referenced by OpHitToEveTrackSDPs().

  {
    return OpHitToEveTrackSDPs(*opHit_P);
  }

std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToEveTrackSDPs ( recob::OpHit const &  opHit ) const

inherited

Definition at line 217 of file PhotonBackTracker.cc.

References sim::TrackSDP::energy, sim::TrackSDP::energyFrac, and sim::TrackSDP::trackID.

  {
    std::vector<sim::TrackSDP> trackSDPs = 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

inherited

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

References cheat::PhotonBackTracker::fDelay, cheat::PhotonBackTracker::FindOpDetBacktrackerRecord(), cheat::PhotonBackTracker::geom, recob::OpHit::OpChannel(), recob::OpHit::PeakTime(), cheat::PhotonBackTracker::shouldThisFail(), sim::OpDetBacktrackerRecord::TrackIDsAndEnergies(), and recob::OpHit::Width().

Referenced by cheat::PhotonBackTracker::OpHitToSDPs(), cheat::PhotonBackTracker::OpHitToSimSDPs(), cheat::PhotonBackTracker::OpHitToTrackID(), and cheat::PhotonBackTracker::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

inherited

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

inlineinherited

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

References cheat::PhotonBackTracker::OpHitToSDPs().

    {
      OpHitToSDPs(*hit, sdps);
    }

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

inlineinherited

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

References cheat::PhotonBackTracker::OpHitToSDPs().

    {
      OpHitToSDPs(*hit, sdps);
    }

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

inlineinherited

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

References cheat::PhotonBackTracker::OpHitToSDPs().

    {
      OpHitToSDPs(hit, sdps);
    }

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

inlineinherited

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

References cheat::PhotonBackTracker::OpHitToSDPs().

    {
      OpHitToSDPs(hit, sdps);
    }

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

inlineinherited

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

References cheat::PhotonBackTracker::GetSetOfEveIDs(), cheat::PhotonBackTracker::GetSetOfTrackIDs(), hits(), cheat::PhotonBackTracker::OpHitChargeCollectionEfficiency(), cheat::PhotonBackTracker::OpHitChargeCollectionPurity(), cheat::PhotonBackTracker::OpHitCollectionEfficiency(), cheat::PhotonBackTracker::OpHitCollectionPurity(), cheat::PhotonBackTracker::OpHitToSDPs(), cheat::PhotonBackTracker::OpHitToXYZ(), cheat::PhotonBackTracker::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

inlineinherited

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

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

    {
      OpHitToSDPs(*hit, sdps);
    }

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

(

recob::OpHit const &

opHit

)

Definition at line 217 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToSimSDPs_Ps().

  {
    return PhotonBackTracker::OpHitToSimSDPs_Ps(opHit);
  }

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

(

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

opHit_P

)

Definition at line 224 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToSimSDPs_Ps().

  {
    return PhotonBackTracker::OpHitToSimSDPs_Ps(opHit_P);
  }

std::vector< const sim::SDP * > cheat::PhotonBackTracker::OpHitToSimSDPs_Ps ( recob::OpHit const &  opHit ) const

inherited

Definition at line 293 of file PhotonBackTracker.cc.

References recob::OpHit::OpChannel(), recob::OpHit::PeakTime(), and recob::OpHit::Width().

Referenced by OpHitToSimSDPs_Ps().

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

    auto const& timeSDPMap = FindOpDetBTR(fWireReadoutGeom->OpDetFromOpChannel(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;
  }

std::vector< const sim::SDP * > cheat::PhotonBackTracker::OpHitToSimSDPs_Ps ( art::Ptr< recob::OpHit > const &  opHit_P ) const

inherited

Definition at line 341 of file PhotonBackTracker.cc.

  {
    return OpHitToSimSDPs_Ps(*opHit_P);
  }

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

inlineinherited

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

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

    {
      return OpHitToTrackSDPs(hit);
    }

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

inlineinherited

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

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

    {
      return OpHitToTrackSDPs(hit);
    }

std::vector< int > cheat::PhotonBackTrackerService::OpHitToTrackIds

(

recob::OpHit const &

opHit

)

Definition at line 161 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToTrackIds().

  {
    return PhotonBackTracker::OpHitToTrackIds(opHit);
  }

std::vector< int > cheat::PhotonBackTrackerService::OpHitToTrackIds

(

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

opHit_P

)

Definition at line 167 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToTrackIds().

  {
    return PhotonBackTracker::OpHitToTrackIds(opHit_P);
  }

std::vector< int > cheat::PhotonBackTracker::OpHitToTrackIds ( recob::OpHit const &  opHit ) const

inherited

Definition at line 178 of file PhotonBackTracker.cc.

Referenced by OpHitToTrackIds().

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

std::vector< int > cheat::PhotonBackTracker::OpHitToTrackIds ( art::Ptr< recob::OpHit > const &  opHit ) const

inherited

Definition at line 188 of file PhotonBackTracker.cc.

  {
    return OpHitToTrackIds(*opHit);
  }

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

(

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

opHit_P

)

Definition at line 148 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToTrackSDPs().

  {
    return PhotonBackTracker::OpHitToTrackSDPs(opHit_P);
  }

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

(

recob::OpHit const &

opHit

)

Definition at line 155 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToTrackSDPs().

  {
    return PhotonBackTracker::OpHitToTrackSDPs(opHit);
  }

std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToTrackSDPs ( art::Ptr< recob::OpHit > const &  opHit_P ) const

inherited

Definition at line 155 of file PhotonBackTracker.cc.

References util::end(), recob::OpHit::OpChannel(), recob::OpHit::PeakTime(), and recob::OpHit::Width().

  {
    auto OpDetNum = fWireReadoutGeom->OpDetFromOpChannel(opHit_P->OpChannel());
    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;
    return OpDetToTrackSDPs(OpDetNum, start, end);
  }

std::vector< sim::TrackSDP > cheat::PhotonBackTracker::OpHitToTrackSDPs ( recob::OpHit const &  opHit ) const

inherited

Definition at line 167 of file PhotonBackTracker.cc.

References util::end(), recob::OpHit::OpChannel(), recob::OpHit::PeakTime(), and recob::OpHit::Width().

  {
    auto OpDetNum = fWireReadoutGeom->OpDetFromOpChannel(opHit.OpChannel());
    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 OpDetToTrackSDPs(OpDetNum, start, end);
  }

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

(

recob::OpHit const &

opHit

)

Definition at line 259 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToXYZ().

  {
    return PhotonBackTracker::OpHitToXYZ(opHit);
  }

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

(

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

opHit_P

)

Definition at line 265 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::OpHitToXYZ().

  {
    return PhotonBackTracker::OpHitToXYZ(opHit_P);
  }

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

inlineinherited

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

References cheat::PhotonBackTracker::fParticleList.

{ return fParticleList; }

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

inlineinherited

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

References cheat::PhotonBackTracker::fParticleList.

{ return fParticleList; }

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

inherited

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

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

Referenced by cheat::PhotonBackTracker::SetEveIdCalculator().

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

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

inherited

template<typename Evt >

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

inherited

template<typename Evt >

void cheat::PhotonBackTracker::PrepOpDetBTRs ( Evt const &  evt )

inherited

Referenced by priv_PrepOpDetBTRs().

template<typename Evt >

void cheat::PhotonBackTracker::PrepOpFlashToOpHits ( Evt const &  evt )

inherited

Referenced by priv_PrepOpFlashToOpHits().

bool cheat::PhotonBackTrackerService::priv_CanRun ( art::Event const &  evt )

private

Definition at line 65 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::CanRun().

Referenced by priv_PrepEvent(), priv_PrepOpDetBTRs(), and priv_PrepOpFlashToOpHits().

  {
    return PhotonBackTracker::CanRun(evt);
  }

bool cheat::PhotonBackTrackerService::priv_OpDetBTRsReady ( )

inlineprivate

Definition at line 120 of file PhotonBackTrackerService.h.

Referenced by priv_PrepOpDetBTRs().

{ return PhotonBackTracker::BTRsReady(); }

bool cheat::PhotonBackTrackerService::priv_OpFlashToOpHitsReady ( )

inlineprivate

Definition at line 121 of file PhotonBackTrackerService.h.

References DECLARE_ART_SERVICE, and art::LEGACY.

Referenced by priv_PrepOpFlashToOpHits().

{ return PhotonBackTracker::OpFlashToOpHitsReady(); }

void cheat::PhotonBackTrackerService::priv_PrepEvent ( art::Event const &  evt, art::ScheduleContext    )

private

Definition at line 56 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::ClearEvent(), priv_CanRun(), priv_PrepOpDetBTRs(), and priv_PrepOpFlashToOpHits().

Referenced by PhotonBackTrackerService(), and Rebuild().

  {
    PhotonBackTracker::ClearEvent();
    if (!priv_CanRun(evt)) { return; }
    priv_PrepOpDetBTRs(evt);
    priv_PrepOpFlashToOpHits(evt);
  }

void cheat::PhotonBackTrackerService::priv_PrepFailed ( )

private

Definition at line 71 of file PhotonBackTrackerService.cc.

Referenced by priv_PrepOpDetBTRs(), and priv_PrepOpFlashToOpHits().

  {
    throw cet::exception("PhotonBackTrackerService")
      << "The called Prep Fucntion failed. This is most likely due "
      << "to a PhotonBackTracker fucntion being used on a file that "
      << "is real data.";
  }

void cheat::PhotonBackTrackerService::priv_PrepOpDetBTRs ( art::Event const &  evt )

private

Definition at line 80 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::PrepOpDetBTRs(), priv_CanRun(), priv_OpDetBTRsReady(), and priv_PrepFailed().

Referenced by priv_PrepEvent().

  {
    if (!priv_CanRun(evt)) { priv_PrepFailed(); }
    if (priv_OpDetBTRsReady()) { return; }
    try {
      PhotonBackTracker::PrepOpDetBTRs(evt);
    }
    catch (cet::exception const&) {
      //This needs to go. Make it specific if there is a really an exception we would like to catch.
      mf::LogWarning("PhotonBackTrackerService")
        << "Rebuild failed to get the OpDetBTRs. This is expected when "
        << "running on a generation or simulation step.";
    }
  }

void cheat::PhotonBackTrackerService::priv_PrepOpFlashToOpHits ( art::Event const &  evt )

private

Definition at line 95 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::PrepOpFlashToOpHits(), priv_CanRun(), priv_OpFlashToOpHitsReady(), and priv_PrepFailed().

Referenced by priv_PrepEvent().

  {
    if (!priv_CanRun(evt)) { priv_PrepFailed(); }
    if (priv_OpFlashToOpHitsReady()) { return; }
    try {
      PhotonBackTracker::PrepOpFlashToOpHits(evt);
    }
    catch (cet::exception const&) {
      // This needs to go. Make it specific if there is a really an exception we would like to catch.
      mf::LogWarning("PhotonBackTrackerService")
        << "Rebuild failed to get the OpFlashToOpHits. This is expected when "
        << "running on a generation or simulation stage.";
    }
  }

const provider_type* cheat::PhotonBackTrackerService::provider ( ) const

inline

Definition at line 45 of file PhotonBackTrackerService.h.

References tca::evt, and lar::dump::vector().

{ return static_cast<provider_type const*>(this); }

void cheat::PhotonBackTrackerService::Rebuild

(

art::Event const &

evt

)

Definition at line 50 of file PhotonBackTrackerService.cc.

References art::ScheduleContext::invalid(), and priv_PrepEvent().

Referenced by cheat::PhotonBackTrackerLoader::produce().

  {
    priv_PrepEvent(evt, art::ScheduleContext::invalid());
  }

void cheat::PhotonBackTracker::Rebuild ( const art::Event &  evt )

inherited

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

References sim::ParticleList::Add(), sim::ParticleList::AdoptEveIdCalculator(), sim::ParticleList::clear(), cheat::PhotonBackTracker::cOpDetBacktrackerRecords, art::Handle< T >::failedToGet(), cheat::PhotonBackTracker::fG4ModuleLabel, art::fill_ptr_vector(), cheat::PhotonBackTracker::fMCTruthList, cheat::PhotonBackTracker::fParticleList, cheat::PhotonBackTracker::fTrackIDToMCTruthIndex, art::ProductRetriever::getByLabel(), cheat::PhotonBackTracker::GetSetOfTrackIDs(), cheat::PhotonBackTracker::have_complained, art::Event::isRealData(), MF_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);

    MF_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)
      MF_LOG_DEBUG("PhotonBackTracker") << *(fMCTruthList.at(mc).get());

    return;
  }

void cheat::PhotonBackTracker::reconfigure ( fhicl::ParameterSet const &  pset )

inherited

Referenced by cheat::PhotonBackTracker::~PhotonBackTracker().

void cheat::PhotonBackTracker::reconfigure ( fhicl::ParameterSet const &  pset )

inherited

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

inlineinherited

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

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

{ fParticleList.AdoptEveIdCalculator(ec); }

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

inlineinherited

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

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

{ fParticleList.AdoptEveIdCalculator(ec); }

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

(

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

sdps

)

const

Definition at line 245 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::SimSDPsToXYZ().

  {
    return PhotonBackTracker::SimSDPsToXYZ(sdps);
  }

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

(

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

sdps_Ps

)

Definition at line 252 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::SimSDPsToXYZ().

  {
    return PhotonBackTracker::SimSDPsToXYZ(sdps_Ps);
  }

std::vector< double > cheat::PhotonBackTracker::SimSDPsToXYZ ( std::vector< sim::SDP > const &  sdps )

inherited

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

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

Referenced by cheat::PhotonBackTracker::OpHitToSimSDPs(), cheat::PhotonBackTracker::OpHitToXYZ(), and 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< const sim::SDP * > const &  sdps_Ps ) const

inherited

Definition at line 376 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  )

inherited

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

References cheat::PhotonBackTracker::ChannelToTrackSDPs(), util::end(), cheat::PhotonBackTracker::fDelay, cheat::PhotonBackTracker::fMinOpHitEnergyFraction, recob::OpHit::OpChannel(), recob::OpHit::PeakTime(), cheat::PhotonBackTracker::shouldThisFail(), and recob::OpHit::Width().

Referenced by cheat::PhotonBackTracker::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  )

inherited

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

Definition at line 209 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::TrackIdsToOpHits_Ps().

  {
    return PhotonBackTracker::TrackIdsToOpHits_Ps(tkIds, hitsIn);
  }

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  ) const

inherited

Definition at line 259 of file PhotonBackTracker.cc.

References util::end(), recob::OpHit::OpChannel(), recob::OpHit::PeakTime(), and recob::OpHit::Width().

Referenced by TrackIdsToOpHits_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 = fWireReadoutGeom->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 = OpDetToTrackSDPs(OpDetNum, start, end);
      for (auto itid = tids.begin(); itid != tids.end(); ++itid) {
        for (auto itkid = tkIds.begin(); itkid != tkIds.end(); ++itkid) {
          if (itid->trackID == *itkid and 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

inherited

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

References util::abs(), cheat::PhotonBackTracker::fMCTruthList, cheat::PhotonBackTracker::fTrackIDToMCTruthIndex, and cheat::PhotonBackTracker::shouldThisFail().

Referenced by cheat::PhotonBackTracker::MCTruthToParticles(), cheat::PhotonBackTracker::ParticleToMCTruth(), and cheat::PhotonBackTracker::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 art::Ptr<simb::MCTruth>& cheat::PhotonBackTracker::TrackIDToMCTruth ( int const &  id ) const

inherited

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

inherited

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

inherited

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

References util::abs(), sim::ParticleList::EveId(), cheat::PhotonBackTracker::fParticleList, cheat::PhotonBackTracker::shouldThisFail(), and cheat::PhotonBackTracker::TrackIDToParticle().

Referenced by cheat::PhotonBackTracker::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)));
  }

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

Definition at line 201 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::TrackIdToOpHits_Ps().

  {
    return PhotonBackTracker::TrackIdToOpHits_Ps(tkId, hitsIn);
  }

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

inherited

Definition at line 246 of file PhotonBackTracker.cc.

Referenced by 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);
    return TrackIdsToOpHits_Ps(tkidFake, hitsIn).at(0);
  }

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

inherited

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

inherited

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

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

Referenced by cheat::PhotonBackTracker::SetEveIdCalculator(), and cheat::PhotonBackTracker::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;
  }

std::vector< sim::SDP > cheat::PhotonBackTracker::TrackIDToSimSDP ( int const &  id ) const

inherited

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

References util::abs(), cheat::PhotonBackTracker::cOpDetBacktrackerRecords, sc, and cheat::PhotonBackTracker::shouldThisFail().

Referenced by cheat::PhotonBackTracker::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

inherited

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

(

int

id

)

Definition at line 127 of file PhotonBackTrackerService.cc.

References cheat::PhotonBackTracker::TrackIdToSimSDPs_Ps().

  {
    return PhotonBackTracker::TrackIdToSimSDPs_Ps(id);
  }

std::vector< const sim::SDP * > cheat::PhotonBackTracker::TrackIdToSimSDPs_Ps ( int  id ) const

inherited

Definition at line 92 of file PhotonBackTracker.cc.

References util::abs().

Referenced by 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) {
          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;
  }

---

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

• larsim/v10_02_02/source/larsim/MCCheater/PhotonBackTrackerService.h
• larsim/v10_02_02/source/larsim/MCCheater/PhotonBackTrackerService.cc