Inheritance diagram for opreco::OpticalRecoAna:

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

void	beginJob ()

void	analyze (const art::Event &)

Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDAnalyzer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept

	Analyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	Analyzer (Table< Config > const &config)

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)

Public Member Functions inherited from art::Observer
	~Observer () noexcept

	Observer (Observer const &)=delete

	Observer (Observer &&)=delete

Observer &	operator= (Observer const &)=delete

Observer &	operator= (Observer &&)=delete

void	registerProducts (ProductDescriptions &, ModuleDescription const &)

void	fillDescriptions (ModuleDescription const &)

fhicl::ParameterSetID	selectorConfig () const

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

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)

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

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

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	compare_track_and_flash (recob::Track const &, recob::OpFlash const &, bool &)

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

void	compare_particle_and_flash (simb::MCParticle const &, recob::OpFlash const &, bool &, float const &, geo::Geometry const &)

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

void	compare_particle_and_track (simb::MCParticle const &, recob::Track const &, bool &, geo::Geometry const &)

void	FillMatchTree_PF (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

Additional Inherited Members
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >

using	ModuleType = EDAnalyzer

Protected Member Functions inherited from art::Observer
std::string const &	processName () const

bool	wantAllEvents () const noexcept

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

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

	Observer (fhicl::ParameterSet const &config)

	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)

Protected Member Functions inherited from art::ModuleBase
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 ()

Detailed Description

Definition at line 44 of file OpticalRecoAna_module.cc.

Constructor & Destructor Documentation

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

Definition at line 137 of file OpticalRecoAna_module.cc.

                                                                  : 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 209 of file OpticalRecoAna_module.cc.

 {
 
   //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;
 
   //art::Handle< std::vector<recob::Track> > track_handle;
   //evt.getByLabel(fTrackModuleLabel, track_handle);
   //std::vector<recob::Track> const& track_vector(*track_handle);
   //fTrack_match_vector.resize(track_vector.size());
 
   //MF_LOG_INFO ("OpticalRecoAna")
   //<< "Number of tracks is " << track_vector.size() << std::flush;
 
   //match_flashes_to_tracks(flash_vector, track_vector);
 
   //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);
     /*
     FillMatchTree_PF(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);
 
     //check_flash_matches();
 
     //match_tracks_to_particles(track_handle,particle_list);
 
   }
 
 }

void opreco::OpticalRecoAna::beginJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 155 of file OpticalRecoAna_module.cc.

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

void opreco::OpticalRecoAna::compare_particle_and_flash	(	simb::MCParticle const &	particle,
		recob::OpFlash const &	flash,
		bool &	matching,
		float const &	ns_per_PMT_tick,
		geo::Geometry const &	geometry
	)

private

Definition at line 502 of file OpticalRecoAna_module.cc.

506 {

507 }

void opreco::OpticalRecoAna::compare_particle_and_track	(	simb::MCParticle const &	particle,
		recob::Track const &	track,
		bool &	matching,
		geo::Geometry const &	geometry
	)

private

Definition at line 535 of file OpticalRecoAna_module.cc.

538 {

539 }

void opreco::OpticalRecoAna::compare_track_and_flash	(	recob::Track const &	track,
		recob::OpFlash const &	flash,
		bool &	matching
	)

private

Definition at line 374 of file OpticalRecoAna_module.cc.

376 {

377 }

void opreco::OpticalRecoAna::FillMatchTree_PF	(	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 460 of file OpticalRecoAna_module.cc.

                                                                           {
 
     for(size_t i_flash=0; i_flash < flash_vector.size(); i_flash++){
 
       recob::OpFlash const& my_flash( flash_vector.at(i_flash) );
       const float flash_time = my_flash.Time()*ns_per_PMT_tick;
 
       for(auto i_particle : fFlash_match_vector.at(i_flash).particle_indices){
 
         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(my_particle.Mother()==0 && my_particle.TrackId()>1e4){
 
           fParticleID = i_particle;
           fParticleTime = particle_time;
           fParticleVx = my_particle.Vx(0);
           fParticleVy = my_particle.Vy(0);
           fParticleVz = my_particle.Vz(0);
           fFlashID = i_flash;
           fFlashTime = flash_time;
           fFlashY = my_flash.YCenter();
           fFlashZ = my_flash.ZCenter();
           fFlashYWidth = my_flash.YWidth();
           fFlashZWidth = my_flash.ZWidth();
 
           fMatchTree_PF->Fill();
 
           return;
         }
 
       }
 
   }
 
 }

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

private

Definition at line 282 of file OpticalRecoAna_module.cc.

                                                                                                                         {
 
   for(sim::ParticleList::const_iterator ipart = plist.begin(); ipart != plist.end(); ++ipart) {
 
     const simb::MCParticle* particle = (*ipart).second;
     /*
     std::cout << "Particle " << particle_vector.size() << " (" << (*ipart).first << ") is " << particle->PdgCode() << " (mother=" << particle->Mother()
                 << ") with K_energy " << particle->E()-0.001*particle->Mass() << std::endl;
       std::cout << "\t(X,Y,Z,T)=(" << particle->Vx() << "," << particle->Vy() << "," << particle->Vz() << "," << particle->T() << ")" << std::endl;
     */
     //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);
       //std::cout << "Particle " << particle_vector.size() << " (" << (*ipart).first << ") is " << pdg << " (status=" << particle->StatusCode()
       //        << ") with K_energy " << particle->E()-0.001*particle->Mass() << std::endl;
       //std::cout << "\t(X,Y,Z,T)=(" << particle->Vx() << "," << particle->Vy() << "," << particle->Vz() << "," << particle->T() << ")" << std::endl;
     }
   }
 
 }

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

private

Definition at line 277 of file OpticalRecoAna_module.cc.

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

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 379 of file OpticalRecoAna_module.cc.

                                                                                     {
 
   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;
 
     //std::cout << "Particle " << i_particle << " (" << my_particle.PdgCode() << ")" << particle_time << std::endl;
 
     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;
 
       //if(my_flash.OnBeamTime())
         //std::cout << "\tFlash " << i_flash << " time is " << flash_time << std::endl;
 
       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++;
 
         //std::cout << "\t\tParticle (x,y,z)=(" << my_particle.Vx() << "," << my_particle.Vy() << "," << my_particle.Vz() << std::endl;
         //std::cout << "\t\tParticle PDG = " << my_particle.PdgCode() << " mother=" << my_particle.Mother() << std::endl;
         //std::cout << "\t\tFlash (y,z) = ("
         //        << my_flash.YCenter() << " +/- " << my_flash.YWidth() << ","
         //        << my_flash.ZCenter() << " +/- " << my_flash.ZWidth() << std::endl;
 
         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_particles	(	std::vector< recob::Track > const &	track_vector,
		std::vector< simb::MCParticle > const &	particle_vector,
		geo::Geometry const &	geometry
	)

private

Definition at line 509 of file OpticalRecoAna_module.cc.

                                                                                     {
   bool matching=false;
 
   for(size_t i_track=0; i_track < track_vector.size(); i_track++){
 
     recob::Track const& my_track( track_vector.at(i_track) );
 
     for(size_t i_particle=0; i_particle < particle_vector.size(); i_particle++){
 
       simb::MCParticle const& my_particle( particle_vector.at(i_particle) );
 
       matching=false;
       compare_particle_and_track(my_particle,my_track,matching,geometry);
       if(matching){
         fTrack_match_vector.at(i_track).particle_indices.push_back(i_track);
         fParticle_match_vector.at(i_particle).track_indices.push_back(i_track);
       }
 
     }//end inner loop over particles
 
   }//end loop over tracks
 
 }//end match_tracks_to_particles

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

private

Definition at line 348 of file OpticalRecoAna_module.cc.

                                                                                                {
   bool matching=false;
 
   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;
 
     for(size_t i_track=0; i_track < track_vector.size(); i_track++){
 
       recob::Track const& my_track( track_vector.at(i_track) );
 
       matching=false;
       compare_track_and_flash(my_track,my_flash,matching);
       if(matching){
         fFlash_match_vector.at(i_flash).track_indices.push_back(i_track);
         fTrack_match_vector.at(i_track).flash_indices.push_back(i_flash);
       }
 
     }//end inner loop over tracks
 
   }//end loop over flashes
 
 }//end match_flashes_to_tracks

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

private

Definition at line 319 of file OpticalRecoAna_module.cc.

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

Member Data Documentation

int opreco::OpticalRecoAna::fEvent

private

Definition at line 107 of file OpticalRecoAna_module.cc.

std::vector<flash_match> opreco::OpticalRecoAna::fFlash_match_vector

private

Definition at line 61 of file OpticalRecoAna_module.cc.

int opreco::OpticalRecoAna::fFlashID

private

Definition at line 115 of file OpticalRecoAna_module.cc.

std::string opreco::OpticalRecoAna::fFlashModuleLabel

private

Definition at line 55 of file OpticalRecoAna_module.cc.

int opreco::OpticalRecoAna::fFlashOnBeamTime

private

Definition at line 123 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fFlashPE

private

Definition at line 122 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fFlashTime

private

Definition at line 116 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fFlashTimeWidth

private

Definition at line 117 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fFlashY

private

Definition at line 118 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fFlashYWidth

private

Definition at line 120 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fFlashZ

private

Definition at line 119 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fFlashZWidth

private

Definition at line 121 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fKineticEnergyMin

private

Definition at line 57 of file OpticalRecoAna_module.cc.

int opreco::OpticalRecoAna::fMatchIndex

private

Definition at line 124 of file OpticalRecoAna_module.cc.

int opreco::OpticalRecoAna::fMatchIndex_NotNu

private

Definition at line 125 of file OpticalRecoAna_module.cc.

TTree* opreco::OpticalRecoAna::fMatchTree_PF

private

Definition at line 104 of file OpticalRecoAna_module.cc.

TTree* opreco::OpticalRecoAna::fMatchTree_PF_NotNu

private

Definition at line 105 of file OpticalRecoAna_module.cc.

TH1I* opreco::OpticalRecoAna::fNBeamFlashes

private

Definition at line 102 of file OpticalRecoAna_module.cc.

std::vector<particle_match> opreco::OpticalRecoAna::fParticle_match_vector

private

Definition at line 63 of file OpticalRecoAna_module.cc.

int opreco::OpticalRecoAna::fParticleID

private

Definition at line 108 of file OpticalRecoAna_module.cc.

int opreco::OpticalRecoAna::fParticleMother

private

Definition at line 109 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fParticleTime

private

Definition at line 111 of file OpticalRecoAna_module.cc.

int opreco::OpticalRecoAna::fParticleTrackID

private

Definition at line 110 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fParticleVx

private

Definition at line 112 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fParticleVy

private

Definition at line 113 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fParticleVz

private

Definition at line 114 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fPEMin

private

Definition at line 58 of file OpticalRecoAna_module.cc.

int opreco::OpticalRecoAna::fRun

private

Definition at line 106 of file OpticalRecoAna_module.cc.

TH1F* opreco::OpticalRecoAna::fTimeDiff

private

Definition at line 100 of file OpticalRecoAna_module.cc.

TH1F* opreco::OpticalRecoAna::fTimeDiff_fine

private

Definition at line 101 of file OpticalRecoAna_module.cc.

float opreco::OpticalRecoAna::fTimeMatchMax

private

Definition at line 59 of file OpticalRecoAna_module.cc.

std::vector<track_match> opreco::OpticalRecoAna::fTrack_match_vector

private

Definition at line 62 of file OpticalRecoAna_module.cc.

std::string opreco::OpticalRecoAna::fTrackModuleLabel

private

Definition at line 56 of file OpticalRecoAna_module.cc.

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

larana/larana/OpticalDetector/OpticalRecoAna_module.cc

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation