Inheritance diagram for sbnd::RunningT0Tagging:

Classes
struct	Config

Public Types
using	Parameters = art::EDAnalyzer::Table< Config >

Public Member Functions
	RunningT0Tagging (Parameters const &config)

virtual void	beginJob () override

virtual void	analyze (const art::Event &event) override

virtual void	endJob () override

Private Attributes
art::InputTag	fSimModuleLabel
	name of detsim producer More...

art::InputTag	fCRTHitLabel
	name of CRT hit producer More...

art::InputTag	fCRTTrackLabel
	name of CRT track producer More...

art::InputTag	fTPCTrackLabel
	name of TPC track producer More...

bool	fVerbose
	print information about what's going on More...

CRTT0MatchAlg	fCRTHitMatch
	CRT hit - TPC track matching algorithms. More...

CRTTrackMatchAlg	fCRTTrackMatch
	CRT track - TPC track matching algorithms. More...

int	nTotal = 0

int	nCrtHitMatched = 0

int	nCrtHitCorrect = 0

int	nCrtTrackMatched = 0

int	nCrtTrackCorrect = 0

Detailed Description

Definition at line 44 of file RunningT0Tagging_module.cc.

Member Typedef Documentation

using sbnd::RunningT0Tagging::Parameters = art::EDAnalyzer::Table<Config>

Definition at line 88 of file RunningT0Tagging_module.cc.

Constructor & Destructor Documentation

sbnd::RunningT0Tagging::RunningT0Tagging ( Parameters const & config )

explicit

Definition at line 125 of file RunningT0Tagging_module.cc.

     : EDAnalyzer(config)
     , fSimModuleLabel      (config().SimModuleLabel())
     , fCRTHitLabel         (config().CRTHitLabel())
     , fCRTTrackLabel       (config().CRTTrackLabel())
     , fTPCTrackLabel       (config().TPCTrackLabel())
     , fVerbose             (config().Verbose())
     , fCRTHitMatch         (config().CRTHitMatch())
     , fCRTTrackMatch       (config().CRTTrackMatch())
   {
 
   } //RunningT0Tagging()

Member Function Documentation

void sbnd::RunningT0Tagging::analyze ( const art::Event & event )

overridevirtual

Definition at line 148 of file RunningT0Tagging_module.cc.

   {
 
     // Fetch basic event info
     if(fVerbose){
       std::cout<<"============================================"<<std::endl
                <<"Run = "<<event.run()<<", SubRun = "<<event.subRun()<<", Event = "<<event.id().event()<<std::endl
                <<"============================================"<<std::endl;
     }
 
     //----------------------------------------------------------------------------------------------------------
     //                                          GETTING PRODUCTS
     //----------------------------------------------------------------------------------------------------------
 
     // Get g4 particles
     auto particleHandle = event.getValidHandle<std::vector<simb::MCParticle>>(fSimModuleLabel);
     // Put into a map for easier access
     std::map<int, simb::MCParticle> particles;
     for (auto const& particle: (*particleHandle)){
       int partID = particle.TrackId();
       particles[partID] = particle;
     }
 
     // Get CRT hits from the event
     auto crtHitHandle = event.getValidHandle<std::vector<sbn::crt::CRTHit>>(fCRTHitLabel);
     std::vector<sbn::crt::CRTHit> crtHits;
     for(auto const& hit : (*crtHitHandle)){
       crtHits.push_back(hit);
     }
 
     // Get CRT tracks from the event
     auto crtTrackHandle = event.getValidHandle<std::vector<sbn::crt::CRTTrack>>(fCRTTrackLabel);
     std::vector<sbn::crt::CRTTrack> crtTracks;
     for(auto const& track : (*crtTrackHandle)){
       crtTracks.push_back(track);
     }
 
     // Get reconstructed tracks from the event
     auto tpcTrackHandle = event.getValidHandle<std::vector<recob::Track>>(fTPCTrackLabel);
 
     // Get the associated hits
     art::FindManyP<recob::Hit> findManyHits(tpcTrackHandle, event, fTPCTrackLabel);
 
     //----------------------------------------------------------------------------------------------------------
     //                                        RUNNING THE T0 TAGGING
     //----------------------------------------------------------------------------------------------------------
 
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(event);
     auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(event, clockData);
 
     // Loop over reconstructed tracks
     for (auto const& tpcTrack : (*tpcTrackHandle)){
       // Get the associated hits
       std::vector<art::Ptr<recob::Hit>> hits = findManyHits.at(tpcTrack.ID());
 
       // Get the true particle
       int trackTrueID = RecoUtils::TrueParticleIDFromTotalRecoHits(clockData, hits, false);
       if(particles.find(trackTrueID) == particles.end()) continue;
 
       // Only consider primary muons
       if(!(std::abs(particles[trackTrueID].PdgCode()) == 13 && particles[trackTrueID].Mother() == 0)) continue;
 
       // Only consider particles inside the reco hit time window
       double trueTime = particles[trackTrueID].T() * 1e-3; // [us]
       if(fVerbose) std::cout<<"True track time = "<<trueTime<<" us\n";
 
       nTotal++;
 
       // Calculate t0 from CRT hit matching
       double hitT0 = fCRTHitMatch.T0FromCRTHits(detProp, tpcTrack, crtHits, event);
       if(hitT0 == -99999){
         if(fVerbose) std::cout<<"Couldn't match to CRT hit.\n";
       }
       else{
         nCrtHitMatched++;
         if(fVerbose) std::cout<<"Hit matched time = "<<hitT0<<" us\n";
         if(std::abs(trueTime - hitT0) < 2) nCrtHitCorrect++;
       }
       // Calculate t0 from CRT track matching
       double trackT0 = fCRTTrackMatch.T0FromCRTTracks(detProp, tpcTrack, crtTracks, event);
       if(trackT0 == -99999){
         if(fVerbose) std::cout<<"Couldn't match to CRT track.\n";
       }
       else{
         nCrtTrackMatched++;
         if(fVerbose) std::cout<<"Track matched time = "<<trackT0<<" us\n";
         if(std::abs(trueTime - trackT0) < 2) nCrtTrackCorrect++;
       }
 
       if(fVerbose) std::cout<<"\n";
 
     }
 
     
   } // RunningT0Tagging::analyze()

void sbnd::RunningT0Tagging::beginJob ( )

overridevirtual

Definition at line 139 of file RunningT0Tagging_module.cc.

   {
 
     // Initial output
     if(fVerbose) std::cout<<"----------------- Running CRT t0 tagging example -------------------"<<std::endl;
 
   } // RunningT0Tagging::beginJob()

void sbnd::RunningT0Tagging::endJob ( )

overridevirtual

Definition at line 245 of file RunningT0Tagging_module.cc.

                                {
 
     std::cout<<"Running CRT t0 tagging:\n"
              <<"-- CRT hit matching:\n"
              <<"---- Efficiency = "<<((double)nCrtHitMatched/nTotal)*100<<"%\n"
              <<"---- Purity     = "<<((double)nCrtHitCorrect/nCrtHitMatched)*100<<"%\n"
              <<"-- CRT track matching:\n"
              <<"---- Efficiency = "<<((double)nCrtTrackMatched/nTotal)*100<<"%\n"
              <<"---- Purity     = "<<((double)nCrtTrackCorrect/nCrtTrackMatched)*100<<"%\n";
     
   } // RunningT0Tagging::endJob()