Inheritance diagram for opreco::OpticalRecoAna:

Public Types
using	ModuleType = EDAnalyzer

Public Member Functions
	OpticalRecoAna (const fhicl::ParameterSet &)

void	beginJob ()

void	analyze (const art::Event &)

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

std::unique_ptr< Worker >	makeWorker (WorkerParams const &wp)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Protected Member Functions
std::string const &	processName () const

bool	wantAllEvents () const noexcept

bool	wantEvent (ScheduleID id, Event const &e) const

Handle< TriggerResults >	getTriggerResults (Event const &e) const

ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Private Member Functions
void	get_MC_particle_list (sim::ParticleList const &, std::vector< simb::MCParticle > &)

simb::Origin_t	get_MC_particle_origin (simb::MCParticle const &)

float	update_MC_particle_time (simb::MCParticle const &, bool &, geo::Geometry const &)

void	match_flashes_to_tracks (std::vector< recob::OpFlash > const &, std::vector< recob::Track > const &)

void	match_flashes_to_particles (std::vector< recob::OpFlash > const &, std::vector< simb::MCParticle > const &, float const &, geo::Geometry const &)

Private Attributes
std::string	fFlashModuleLabel

std::string	fTrackModuleLabel

float	fKineticEnergyMin

float	fPEMin

float	fTimeMatchMax

std::vector< flash_match >	fFlash_match_vector

std::vector< track_match >	fTrack_match_vector

std::vector< particle_match >	fParticle_match_vector

TH1F *	fTimeDiff

TH1F *	fTimeDiff_fine

TH1I *	fNBeamFlashes

TTree *	fMatchTree_PF

TTree *	fMatchTree_PF_NotNu

int	fRun

int	fEvent

int	fParticleID

int	fParticleMother

int	fParticleTrackID

float	fParticleTime

float	fParticleVx

float	fParticleVy

float	fParticleVz

int	fFlashID

float	fFlashTime

float	fFlashTimeWidth

float	fFlashY

float	fFlashZ

float	fFlashYWidth

float	fFlashZWidth

float	fFlashPE

int	fFlashOnBeamTime

int	fMatchIndex

int	fMatchIndex_NotNu

Detailed Description

Definition at line 44 of file OpticalRecoAna_module.cc.

Member Typedef Documentation

using art::EDAnalyzer::ModuleType = EDAnalyzer

inherited

Definition at line 22 of file EDAnalyzer.h.

Constructor & Destructor Documentation

opreco::OpticalRecoAna::OpticalRecoAna ( const fhicl::ParameterSet & )

Definition at line 111 of file OpticalRecoAna_module.cc.

References fFlash_match_vector, fFlashModuleLabel, fKineticEnergyMin, fParticle_match_vector, fPEMin, fTimeMatchMax, fTrack_match_vector, fTrackModuleLabel, and fhicl::ParameterSet::get().

                                                                   : EDAnalyzer(pset)
 {
 
   // Indicate that the Input Module comes from .fcl
   fFlashModuleLabel = pset.get<std::string>("FlashModule");
   fTrackModuleLabel = pset.get<std::string>("TrackModule");
   fKineticEnergyMin = pset.get<float>("KineticEnergyMin");
   fPEMin = pset.get<float>("PEMin");
   fTimeMatchMax = pset.get<float>("TimeMatchMax");
 
   fFlash_match_vector.clear();
   fTrack_match_vector.clear();
   fParticle_match_vector.clear();
 }

Member Function Documentation

void opreco::OpticalRecoAna::analyze ( const art::Event & evt )

Definition at line 189 of file OpticalRecoAna_module.cc.

References art::EventID::event(), fEvent, fFlash_match_vector, fFlashModuleLabel, fNBeamFlashes, fParticle_match_vector, fRun, get_MC_particle_list(), art::ProductRetriever::getByLabel(), art::Event::id(), art::Event::isRealData(), match_flashes_to_particles(), MF_LOG_INFO, cheat::ParticleInventoryService::ParticleList(), and art::EventID::run().

 {
 
   //get flag for MC
   const bool is_MC = !(evt.isRealData());
 
   fRun = evt.id().run();
   fEvent = evt.id().event();
 
   //first get out track, flash, and particle list handles
   art::Handle<std::vector<recob::OpFlash>> flash_handle;
   evt.getByLabel(fFlashModuleLabel, flash_handle);
   std::vector<recob::OpFlash> const& flash_vector(*flash_handle);
   fFlash_match_vector.resize(flash_vector.size());
 
   MF_LOG_INFO("OpticalRecoAna") << "Number of flashes is " << flash_vector.size() << std::flush;
 
   //all this for the MC matching
   if (is_MC) {
 
     art::ServiceHandle<cheat::ParticleInventoryService const> pi_serv;
     std::vector<simb::MCParticle> particle_list;
     get_MC_particle_list(pi_serv->ParticleList(), particle_list);
     fParticle_match_vector.resize(particle_list.size());
 
     mf::LogInfo("OpticalRecoAna") << "Number of MC particles is " << particle_list.size();
 
     art::ServiceHandle<opdet::OpDigiProperties const> odp;
     const float ns_per_PMT_tick =
       1e3; // already converted to microseconds//( 1e3 / odp->SampleFreq()) ; //SampleFreq is in MHz
     art::ServiceHandle<geo::Geometry const> geometry_handle;
 
     match_flashes_to_particles(flash_vector, particle_list, ns_per_PMT_tick, *geometry_handle);
     int n_flashes = 0;
     for (auto const& my_flash : flash_vector) {
       if (my_flash.OnBeamTime() == 1) n_flashes++;
     }
     fNBeamFlashes->Fill(n_flashes);
   }
 }

void opreco::OpticalRecoAna::beginJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 127 of file OpticalRecoAna_module.cc.

References fEvent, fFlashID, fFlashOnBeamTime, fFlashPE, fFlashTime, fFlashTimeWidth, fFlashY, fFlashYWidth, fFlashZ, fMatchIndex, fMatchIndex_NotNu, fMatchTree_PF, fMatchTree_PF_NotNu, fNBeamFlashes, fParticleID, fParticleMother, fParticleTime, fParticleTrackID, fParticleVx, fParticleVy, fParticleVz, fRun, fTimeDiff, and fTimeDiff_fine.

 {
   art::ServiceHandle<art::TFileService const> tfs;
   fTimeDiff = tfs->make<TH1F>(
     "htdiff",
     "Time difference between particles and flashes; t_diff (ns); flash/particle pairs",
     1e3,
     -5e6,
     5e6);
   fTimeDiff_fine = tfs->make<TH1F>(
     "htdiff_fine",
     "Time difference between particles and flashes; t_diff (ns); flash/particle pairs",
     100,
     -1000,
     1000);
   fNBeamFlashes = tfs->make<TH1I>(
     "hNBeamFlashes", "Number of flashes OnBeamTime per event; N_{Flashes}; Events", 5, 0, 5);
 
   fMatchTree_PF = tfs->make<TTree>("MatchTree_PF", "MatchTree_PF");
   fMatchTree_PF->Branch("Run", &fRun, "Run/I");
   fMatchTree_PF->Branch("Event", &fEvent, "Event/I");
   fMatchTree_PF->Branch("p_id", &fParticleID, "p_id/I");
   fMatchTree_PF->Branch("p_time", &fParticleTime, "p_time/F");
   fMatchTree_PF->Branch("p_vx", &fParticleVx, "p_vx/F");
   fMatchTree_PF->Branch("p_vy", &fParticleVy, "p_vy/F");
   fMatchTree_PF->Branch("p_vz", &fParticleVz, "p_vz/F");
   fMatchTree_PF->Branch("p_mid", &fParticleMother, "p_mid/I");
   fMatchTree_PF->Branch("p_trackid", &fParticleTrackID, "p_trackid/I");
   fMatchTree_PF->Branch("FlashID", &fFlashID, "flash_id/I");
   fMatchTree_PF->Branch("f_time", &fFlashTime, "f_time/F");
   fMatchTree_PF->Branch("f_timewidth", &fFlashTimeWidth, "f_timewidth/F");
   fMatchTree_PF->Branch("f_y", &fFlashY, "f_y/F");
   fMatchTree_PF->Branch("f_z", &fFlashZ, "f_z/F");
   fMatchTree_PF->Branch("f_ywidth", &fFlashYWidth, "f_ywidth/F");
   fMatchTree_PF->Branch("f_zwidth", &fFlashYWidth, "f_zwidth/F");
   fMatchTree_PF->Branch("f_onbeamtime", &fFlashOnBeamTime, "f_onbeamtime/I");
   fMatchTree_PF->Branch("f_pe", &fFlashPE, "f_pe/F");
   fMatchTree_PF->Branch("matchIndex", &fMatchIndex, "matchIndex/I");
 
   fMatchTree_PF_NotNu = tfs->make<TTree>("MatchTree_PF_NotNu", "MatchTree_PF_NotNu");
   fMatchTree_PF_NotNu->Branch("Run", &fRun, "Run/I");
   fMatchTree_PF_NotNu->Branch("Event", &fEvent, "Event/I");
   fMatchTree_PF_NotNu->Branch("p_id", &fParticleID, "p_id/I");
   fMatchTree_PF_NotNu->Branch("p_time", &fParticleTime, "p_time/F");
   fMatchTree_PF_NotNu->Branch("p_vx", &fParticleVx, "p_vx/F");
   fMatchTree_PF_NotNu->Branch("p_vy", &fParticleVy, "p_vy/F");
   fMatchTree_PF_NotNu->Branch("p_vz", &fParticleVz, "p_vz/F");
   fMatchTree_PF_NotNu->Branch("p_mid", &fParticleMother, "p_mid/I");
   fMatchTree_PF_NotNu->Branch("p_trackid", &fParticleTrackID, "p_trackid/I");
   fMatchTree_PF_NotNu->Branch("FlashID", &fFlashID, "flash_id/I");
   fMatchTree_PF_NotNu->Branch("f_time", &fFlashTime, "f_time/F");
   fMatchTree_PF_NotNu->Branch("f_timewidth", &fFlashTimeWidth, "f_timewidth/F");
   fMatchTree_PF_NotNu->Branch("f_y", &fFlashY, "f_y/F");
   fMatchTree_PF_NotNu->Branch("f_z", &fFlashZ, "f_z/F");
   fMatchTree_PF_NotNu->Branch("f_ywidth", &fFlashYWidth, "f_ywidth/F");
   fMatchTree_PF_NotNu->Branch("f_zwidth", &fFlashYWidth, "f_zwidth/F");
   fMatchTree_PF_NotNu->Branch("f_onbeamtime", &fFlashOnBeamTime, "f_onbeamtime/I");
   fMatchTree_PF_NotNu->Branch("f_pe", &fFlashPE, "f_pe/F");
   fMatchTree_PF_NotNu->Branch("matchIndex", &fMatchIndex_NotNu, "matchIndex/I");
 }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::consumes ( InputTag const & tag )

protectedinherited

Definition at line 61 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumes().

   {
     return collector_.consumes<T, BT>(tag);
   }

ConsumesCollector & art::ModuleBase::consumesCollector ( )

protectedinherited

Definition at line 57 of file ModuleBase.cc.

References art::ModuleBase::collector_.

   {
     return collector_;
   }

template<typename T , BranchType BT>

void art::ModuleBase::consumesMany ( )

protectedinherited

Definition at line 75 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesMany().

   {
     collector_.consumesMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::consumesView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::consumesView ( InputTag const & tag )

inherited

Definition at line 68 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesView().

   {
     return collector_.consumesView<T, BT>(tag);
   }

void art::detail::Analyzer::doBeginJob ( SharedResources const & resources )

inherited

Definition at line 25 of file Analyzer.cc.

Referenced by art::detail::Analyzer::Analyzer().

   {
     setupQueues(resources);
     ProcessingFrame const frame{ScheduleID{}};
     beginJobWithFrame(frame);
   }

bool art::detail::Analyzer::doBeginRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 68 of file Analyzer.cc.

References art::ModuleContext::scheduleID().

Referenced by art::detail::Analyzer::Analyzer().

   {
     ProcessingFrame const frame{mc.scheduleID()};
     beginRunWithFrame(std::as_const(rp).makeRun(mc), frame);
     return true;
   }

bool art::detail::Analyzer::doBeginSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 84 of file Analyzer.cc.

References art::ModuleContext::scheduleID().

Referenced by art::detail::Analyzer::Analyzer().

   {
     ProcessingFrame const frame{mc.scheduleID()};
     beginSubRunWithFrame(std::as_const(srp).makeSubRun(mc), frame);
     return true;
   }

void art::detail::Analyzer::doEndJob ( )

inherited

Definition at line 33 of file Analyzer.cc.

Referenced by art::detail::Analyzer::Analyzer().

   {
     ProcessingFrame const frame{ScheduleID{}};
     endJobWithFrame(frame);
   }

bool art::detail::Analyzer::doEndRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 76 of file Analyzer.cc.

References art::ModuleContext::scheduleID().

Referenced by art::detail::Analyzer::Analyzer().

   {
     ProcessingFrame const frame{mc.scheduleID()};
     endRunWithFrame(std::as_const(rp).makeRun(mc), frame);
     return true;
   }

bool art::detail::Analyzer::doEndSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 92 of file Analyzer.cc.

References art::ModuleContext::scheduleID().

Referenced by art::detail::Analyzer::Analyzer().

   {
     ProcessingFrame const frame{mc.scheduleID()};
     endSubRunWithFrame(std::as_const(srp).makeSubRun(mc), frame);
     return true;
   }

bool art::detail::Analyzer::doEvent	(	EventPrincipal &	ep,
		ModuleContext const &	mc,
		std::atomic< std::size_t > &	counts_run,
		std::atomic< std::size_t > &	counts_passed,
		std::atomic< std::size_t > &	counts_failed
	)

inherited

Definition at line 100 of file Analyzer.cc.

References e, and art::ModuleContext::scheduleID().

Referenced by art::detail::Analyzer::Analyzer().

   {
     auto const e = std::as_const(ep).makeEvent(mc);
     if (wantEvent(mc.scheduleID(), e)) {
       ++counts_run;
       ProcessingFrame const frame{mc.scheduleID()};
       analyzeWithFrame(e, frame);
       ++counts_passed;
     }
     return true;
   }

void art::detail::Analyzer::doRespondToCloseInputFile ( FileBlock const & fb )

inherited

Definition at line 47 of file Analyzer.cc.

Referenced by art::detail::Analyzer::Analyzer().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseInputFileWithFrame(fb, frame);
   }

void art::detail::Analyzer::doRespondToCloseOutputFiles ( FileBlock const & fb )

inherited

Definition at line 61 of file Analyzer.cc.

Referenced by art::detail::Analyzer::Analyzer().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseOutputFilesWithFrame(fb, frame);
   }

void art::detail::Analyzer::doRespondToOpenInputFile ( FileBlock const & fb )

inherited

Definition at line 40 of file Analyzer.cc.

Referenced by art::detail::Analyzer::Analyzer().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenInputFileWithFrame(fb, frame);
   }

void art::detail::Analyzer::doRespondToOpenOutputFiles ( FileBlock const & fb )

inherited

Definition at line 54 of file Analyzer.cc.

Referenced by art::detail::Analyzer::Analyzer().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenOutputFilesWithFrame(fb, frame);
   }

void opreco::OpticalRecoAna::get_MC_particle_list	(	sim::ParticleList const &	plist,
		std::vector< simb::MCParticle > &	particle_vector
	)

private

Definition at line 236 of file OpticalRecoAna_module.cc.

References util::abs(), sim::ParticleList::begin(), simb::MCParticle::E(), sim::ParticleList::end(), fKineticEnergyMin, ipart, simb::MCParticle::Mass(), and simb::MCParticle::PdgCode().

Referenced by analyze().

 {
 
   for (sim::ParticleList::const_iterator ipart = plist.begin(); ipart != plist.end(); ++ipart) {
 
     const simb::MCParticle* particle = (*ipart).second;
     //do not store if it's below our energy cut
     if (particle->E() < 0.001 * particle->Mass() + fKineticEnergyMin) continue;
 
     //check to see if it's a charged particle we expect to leave ionization
     const int pdg = std::abs(particle->PdgCode());
     if (pdg == 11      // electron
         || pdg == 13   //muon
         || pdg == 15   //tau
         || pdg == 211  //charged pion
         || pdg == 321  //charged kaon
         || pdg == 2212 //proton
         || pdg == 2214 //delta
         || pdg == 2224 //delta
         || pdg == 3222 //sigma
         || pdg == 3112 //sigma
         || pdg == 3312 //xi
         || pdg == 3334 //omega
     ) {
       particle_vector.emplace_back(*particle);
     }
   }
 }

simb::Origin_t opreco::OpticalRecoAna::get_MC_particle_origin ( simb::MCParticle const & particle )

private

Definition at line 230 of file OpticalRecoAna_module.cc.

References simb::MCParticle::TrackId(), and cheat::ParticleInventoryService::TrackIdToMCTruth_P().

Referenced by match_flashes_to_particles().

 {
   art::ServiceHandle<cheat::ParticleInventoryService const> pi_serv;
   return (pi_serv->TrackIdToMCTruth_P(particle.TrackId()))->Origin();
 }

std::array< std::vector< ProductInfo >, NumBranchTypes > const & art::ModuleBase::getConsumables ( ) const

inherited

Definition at line 43 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::getConsumables().

   {
     return collector_.getConsumables();
   }

Handle< TriggerResults > art::Observer::getTriggerResults ( Event const & e ) const

protectedinherited

Definition at line 75 of file Observer.cc.

References art::ProductRetriever::get(), and art::Observer::selectors_.

Referenced by art::OutputModule::doWriteEvent(), and art::Observer::wantAllEvents().

   {
     if (selectors_) {
       return selectors_->getOneTriggerResults(e);
     }
 
     // The following applies for cases where no SelectEvents entries
     // exist.
     Handle<TriggerResults> h;
     if (e.get(empty_process_name, h)) {
       return h;
     }
     return Handle<TriggerResults>{};
   }

std::unique_ptr< Worker > art::ModuleBase::makeWorker ( WorkerParams const & wp )

inherited

Definition at line 37 of file ModuleBase.cc.

References art::ModuleBase::doMakeWorker(), and art::NumBranchTypes.

   {
     return doMakeWorker(wp);
   }

void opreco::OpticalRecoAna::match_flashes_to_particles	(	std::vector< recob::OpFlash > const &	flash_vector,
		std::vector< simb::MCParticle > const &	particle_vector,
		float const &	ns_per_PMT_tick,
		geo::Geometry const &	geometry
	)

private

Definition at line 294 of file OpticalRecoAna_module.cc.

References util::abs(), fFlash_match_vector, fFlashID, fFlashOnBeamTime, fFlashPE, fFlashTime, fFlashTimeWidth, fFlashY, fFlashYWidth, fFlashZ, fFlashZWidth, fMatchIndex, fMatchIndex_NotNu, fMatchTree_PF, fMatchTree_PF_NotNu, fParticle_match_vector, fParticleID, fParticleMother, fParticleTime, fParticleTrackID, fParticleVx, fParticleVy, fParticleVz, fPEMin, fTimeDiff, fTimeDiff_fine, fTimeMatchMax, get_MC_particle_origin(), simb::kBeamNeutrino, recob::OpFlash::Time(), and update_MC_particle_time().

Referenced by analyze().

 {
   fMatchIndex = 0;
   fMatchIndex_NotNu = 0;
   int lastFlashID = -1;
 
   for (size_t i_particle = 0; i_particle < particle_vector.size(); i_particle++) {
 
     simb::MCParticle const& my_particle(particle_vector.at(i_particle));
     bool pass_check = false;
     const float particle_time = update_MC_particle_time(my_particle, pass_check, geometry);
     if (!pass_check) continue;
 
     for (size_t i_flash = 0; i_flash < flash_vector.size(); i_flash++) {
 
       recob::OpFlash const& my_flash(flash_vector.at(i_flash));
       if (my_flash.TotalPE() < fPEMin) continue;
 
       const float flash_time = my_flash.Time() * ns_per_PMT_tick;
 
       fTimeDiff->Fill(particle_time - flash_time);
       fTimeDiff_fine->Fill(particle_time - flash_time);
 
       fParticleID = i_particle;
       fParticleTime = particle_time;
       fParticleVx = my_particle.Vx(0);
       fParticleVy = my_particle.Vy(0);
       fParticleVz = my_particle.Vz(0);
       fParticleMother = my_particle.Mother();
       fParticleTrackID = my_particle.TrackId();
       fFlashID = i_flash;
       fFlashTime = flash_time;
       fFlashTimeWidth = my_flash.TimeWidth() * ns_per_PMT_tick;
       fFlashY = my_flash.YCenter();
       fFlashZ = my_flash.ZCenter();
       fFlashYWidth = my_flash.YWidth();
       fFlashZWidth = my_flash.ZWidth();
       fFlashPE = my_flash.TotalPE();
       fFlashOnBeamTime = my_flash.OnBeamTime();
 
       bool beam_match = ((std::abs(particle_time - flash_time) / fFlashTimeWidth) < fTimeMatchMax &&
                          get_MC_particle_origin(my_particle) == simb::kBeamNeutrino);
       bool nonbeam_match =
         ((std::abs(particle_time - flash_time) / fFlashTimeWidth) < fTimeMatchMax &&
          get_MC_particle_origin(my_particle) != simb::kBeamNeutrino);
 
       if (beam_match) {
         fMatchTree_PF->Fill();
         fMatchIndex++;
 
         fFlash_match_vector.at(i_flash).particle_indices.push_back(i_particle);
         fParticle_match_vector.at(i_particle).flash_indices.push_back(i_flash);
       }
       else if (nonbeam_match) {
         if (lastFlashID != fFlashID) {
           fMatchTree_PF_NotNu->Fill();
           fMatchIndex_NotNu++;
           lastFlashID = fFlashID;
         }
       }
 
     } //end inner loop over particles
 
   } //end loop over flashes
 
 } //end match_flashes_to_particles

void opreco::OpticalRecoAna::match_flashes_to_tracks	(	std::vector< recob::OpFlash > const &	,
		std::vector< recob::Track > const &
	)

private

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::mayConsume ( InputTag const & tag )

protectedinherited

Definition at line 82 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsume().

   {
     return collector_.mayConsume<T, BT>(tag);
   }

template<typename T , BranchType BT>

void art::ModuleBase::mayConsumeMany ( )

protectedinherited

Definition at line 96 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeMany().

   {
     collector_.mayConsumeMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::mayConsumeView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::mayConsumeView ( InputTag const & tag )

inherited

Definition at line 89 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeView().

   {
     return collector_.mayConsumeView<T, BT>(tag);
   }

ModuleDescription const & art::ModuleBase::moduleDescription ( ) const

inherited

Definition at line 13 of file ModuleBase.cc.

References art::errors::LogicError.

Referenced by art::OutputModule::doRespondToOpenInputFile(), art::OutputModule::doWriteEvent(), art::Modifier::fillProductDescriptions(), art::OutputModule::makePlugins_(), art::OutputWorker::OutputWorker(), reco::shower::LArPandoraModularShowerCreation::produce(), art::Modifier::registerProducts(), and art::OutputModule::registerProducts().

   {
     if (md_.has_value()) {
       return *md_;
     }
 
     throw Exception{errors::LogicError,
                     "There was an error while calling moduleDescription().\n"}
       << "The moduleDescription() base-class member function cannot be called\n"
          "during module construction.  To determine which module is "
          "responsible\n"
          "for calling it, find the '<module type>:<module "
          "label>@Construction'\n"
          "tag in the message prefix above.  Please contact artists@fnal.gov\n"
          "for guidance.\n";
   }

string const & art::Observer::processName ( ) const

protectedinherited

Definition at line 57 of file Observer.cc.

References art::Observer::process_name_.

Referenced by art::FileDumperOutput::printPrincipal().

   {
     return process_name_;
   }

void art::ModuleBase::setModuleDescription ( ModuleDescription const & md )

inherited

Definition at line 31 of file ModuleBase.cc.

References art::ModuleBase::md_.

   {
     md_ = md;
   }

void art::ModuleBase::sortConsumables ( std::string const & current_process_name )

inherited

Definition at line 49 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::sortConsumables().

   {
     // Now that we know we have seen all the consumes declarations,
     // sort the results for fast lookup later.
     collector_.sortConsumables(current_process_name);
   }

float opreco::OpticalRecoAna::update_MC_particle_time	(	simb::MCParticle const &	particle,
		bool &	pass_check,
		geo::Geometry const &	geometry
	)

private

Definition at line 266 of file OpticalRecoAna_module.cc.

References e, simb::MCParticle::NumberTrajectoryPoints(), geo::GeometryCore::PositionToTPC(), simb::MCParticle::T(), simb::MCParticle::Vx(), simb::MCParticle::Vy(), and simb::MCParticle::Vz().

Referenced by match_flashes_to_particles().

 {
 
   pass_check = false;
 
   const size_t numtraj = particle.NumberTrajectoryPoints();
   size_t t_iter = 0;
   while (t_iter < numtraj) {
     try {
       // check if the particle is inside a TPC
       geo::Point_t const pos{particle.Vx(t_iter), particle.Vy(t_iter), particle.Vz(t_iter)};
       geometry.PositionToTPC(pos);
     }
     catch (cet::exception& e) {
       ++t_iter;
       continue;
     }
     break;
   }
 
   if (t_iter == numtraj) return 0;
 
   pass_check = true;
   return particle.T(t_iter);
 }

bool art::Observer::wantAllEvents ( ) const

inlineprotectednoexceptinherited

Definition at line 31 of file Observer.h.

References e, art::Observer::getTriggerResults(), art::Observer::wantAllEvents_, and art::Observer::wantEvent().

     {
       return wantAllEvents_;
     }

bool art::Observer::wantEvent	(	ScheduleID	id,
		Event const &	e
	)		const

protectedinherited

Definition at line 63 of file Observer.cc.

References art::Observer::rejectors_, art::Observer::selectors_, and art::Observer::wantAllEvents_.

Referenced by art::OutputModule::doEvent(), art::OutputModule::doWriteEvent(), and art::Observer::wantAllEvents().

   {
     if (wantAllEvents_) {
       return true;
     }
     bool const select_event = selectors_ ? selectors_->matchEvent(id, e) : true;
     bool const reject_event =
       rejectors_ ? rejectors_->matchEvent(id, e) : false;
     return select_event and not reject_event;
   }