Inheritance diagram for opdet::FlashMatchAna:

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

virtual	~FlashMatchAna ()

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 Attributes
std::string	fOpFlashModuleLabel

std::string	fOpHitModuleLabel

std::string	fSignalLabel

std::string	fGeantLabel

TTree *	fFlashMatchTree

TTree *	fLargestFlashTree

TTree *	fSelectedFlashTree

TEfficiency *	fRecoEfficiencyVsE

TEfficiency *	fRecoEfficiencyVsX

TEfficiency *	fRecoEfficiencyVsXandE

TEfficiency *	fLargestEfficiencyVsE

TEfficiency *	fLargestEfficiencyVsX

TEfficiency *	fLargestEfficiencyVsXandE

TEfficiency *	fSelectedEfficiencyVsE

TEfficiency *	fSelectedEfficiencyVsX

TEfficiency *	fSelectedEfficiencyVsXandE

int	fNBinsE

float	fLowE

float	fHighE

int	fNBinsX

float	fLowX

float	fHighX

float	fDistanceCut

Int_t	fEventID

Float_t	fTrueX

Float_t	fTrueY

Float_t	fTrueZ

Float_t	fTrueT

Float_t	fDetectedT

Float_t	fTrueE

Int_t	fTruePDG

Float_t	fRecoX

std::vector< Float_t >	fTruePxallpart

std::vector< Float_t >	fTruePyallpart

std::vector< Float_t >	fTruePzallpart

std::vector< Float_t >	fTrueEallpart

std::vector< Int_t >	fTrueAllPDG

Int_t	fNFlashes

std::vector< Int_t >	fFlashIDVector

std::vector< Float_t >	fYCenterVector

std::vector< Float_t >	fZCenterVector

std::vector< Float_t >	fYWidthVector

std::vector< Float_t >	fZWidthVector

std::vector< Float_t >	fTimeVector

std::vector< Float_t >	fRecoXVector

std::vector< Float_t >	fTimeWidthVector

std::vector< Float_t >	fTimeDiffVector

std::vector< Int_t >	fFlashFrameVector

std::vector< Bool_t >	fInBeamFrameVector

std::vector< Int_t >	fOnBeamTimeVector

std::vector< Float_t >	fTotalPEVector

Float_t	fSumPE

std::vector< Float_t >	fPurityVector

std::vector< Float_t >	fDistanceVector

Int_t	fNOpDets

std::vector< Int_t >	fNHitOpDetVector

Int_t	fFlashID

Float_t	fYCenter

Float_t	fZCenter

Float_t	fYWidth

Float_t	fZWidth

Float_t	fTime

Float_t	fTimeWidth

Float_t	fTimeDiff

Float_t	fTotalPE

Float_t	fPurity

Float_t	fDistance

Int_t	fNHitOpDets

std::vector< Float_t >	fPEsPerOpDetVector

std::string	fOpDetWaveformLabel

float	fBaseline

float	fPE

TTree *	fCountTree

Int_t	fnwaveforms1pe

Int_t	fnwaveforms2pe

Int_t	fnwaveforms3pe

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 51 of file FlashMatchAna_module.cc.

Constructor & Destructor Documentation

opdet::FlashMatchAna::FlashMatchAna ( const fhicl::ParameterSet & )

Definition at line 174 of file FlashMatchAna_module.cc.

     : EDAnalyzer(pset)
   {
 
     // Indicate that the Input Module comes from .fcl
     fOpFlashModuleLabel = pset.get<std::string>("OpFlashModuleLabel");
     fOpHitModuleLabel   = pset.get<std::string>("OpHitModuleLabel");
     fSignalLabel        = pset.get<std::string>("SignalLabel");
     fGeantLabel         = pset.get<std::string>("GeantLabel");
     fNBinsE             = pset.get<int>("NBinsE");
     fLowE               = pset.get<float>("LowE");
     fHighE              = pset.get<float>("HighE");
     fNBinsX             = pset.get<int>("NBinsX");
     fLowX               = pset.get<float>("LowX");
     fHighX              = pset.get<float>("HighX");
     fDistanceCut        = pset.get<float>("DistanceCut");
 
     fOpDetWaveformLabel = pset.get<std::string>("OpDetWaveformLabel","");
     fBaseline           = pset.get<float>("Baseline", 1500.);
     fPE                 = pset.get<float>("PE", 18.);
 
     art::ServiceHandle< art::TFileService > tfs;
 
     fFlashMatchTree = tfs->make<TTree>("FlashMatchTree","FlashMatchTree");
     fFlashMatchTree->Branch("EventID",                     &fEventID,   "EventID/I");
     fFlashMatchTree->Branch("TrueX",                       &fTrueX,     "TrueX/F");
     fFlashMatchTree->Branch("TrueY",                       &fTrueY,     "TrueY/F");
     fFlashMatchTree->Branch("TrueZ",                       &fTrueZ,     "TrueZ/F");
     fFlashMatchTree->Branch("TrueT",                       &fTrueT,     "TrueT/F");
     fFlashMatchTree->Branch("DetectedT",                   &fDetectedT, "DetectedT/F");
     fFlashMatchTree->Branch("TrueE",                       &fTrueE,     "TrueE/F");
     fFlashMatchTree->Branch("TruePDG",                     &fTruePDG,   "TruePDG/I");
     fFlashMatchTree->Branch("NFlashes",                    &fNFlashes,  "NFlashes/I");
     fFlashMatchTree->Branch("FlashIDVector",               &fFlashIDVector);
     fFlashMatchTree->Branch("YCenterVector",               &fYCenterVector);
     fFlashMatchTree->Branch("ZCenterVector",               &fZCenterVector);
     fFlashMatchTree->Branch("YWidthVector",                &fYWidthVector);
     fFlashMatchTree->Branch("ZWidthVector",                &fZWidthVector);
     fFlashMatchTree->Branch("TimeVector",                  &fTimeVector);
     fFlashMatchTree->Branch("TimeWidthVector",             &fTimeWidthVector);
     fFlashMatchTree->Branch("TimeDiffVector",              &fTimeDiffVector);
     fFlashMatchTree->Branch("TotalPEVector",               &fTotalPEVector);
     fFlashMatchTree->Branch("SumPE",                       &fSumPE,      "SumPE/F");
     fFlashMatchTree->Branch("NOpDets",                     &fNOpDets,    "NOpDets/I");
     fFlashMatchTree->Branch("NHitOpDetVector",             &fNHitOpDetVector);
     fFlashMatchTree->Branch("Purity",                      &fPurityVector);
     fFlashMatchTree->Branch("Distance",                    &fDistanceVector);
     fFlashMatchTree->Branch("RecoXVector",                 &fRecoXVector);
 
 
     fLargestFlashTree = tfs->make<TTree>("LargestFlashTree","LargestFlashTree");
     fLargestFlashTree->Branch("EventID",                     &fEventID,   "EventID/I");
     fLargestFlashTree->Branch("TrueX",                       &fTrueX,     "TrueX/F");
     fLargestFlashTree->Branch("TrueY",                       &fTrueY,     "TrueY/F");
     fLargestFlashTree->Branch("TrueZ",                       &fTrueZ,     "TrueZ/F");
     fLargestFlashTree->Branch("TrueT",                       &fTrueT,     "TrueT/F");
     fLargestFlashTree->Branch("DetectedT",                   &fDetectedT, "DetectedT/F");
     fLargestFlashTree->Branch("TrueE",                       &fTrueE,     "TrueE/F");
     fLargestFlashTree->Branch("TruePDG",                     &fTruePDG,   "TruePDG/I");
     fLargestFlashTree->Branch("NFlashes",                    &fNFlashes,  "NFlashes/I");
     fLargestFlashTree->Branch("FlashID",                     &fFlashID,   "FlashID/I");
     fLargestFlashTree->Branch("YCenter",                     &fYCenter,   "YCenter/F");
     fLargestFlashTree->Branch("ZCenter",                     &fZCenter,   "ZCenter/F");
     fLargestFlashTree->Branch("YWidth",                      &fYWidth,    "YWidth/F");
     fLargestFlashTree->Branch("ZWidth",                      &fZWidth,    "ZWidth/F");
     fLargestFlashTree->Branch("Time",                        &fTime,      "Time/F");
     fLargestFlashTree->Branch("TimeWidth",                   &fTimeWidth, "TimeWidth/F");
     fLargestFlashTree->Branch("TimeDiff",                    &fTimeDiff,  "TimeDiff/F");
     fLargestFlashTree->Branch("TotalPE",                     &fTotalPE,   "TotalPE/F");
     fLargestFlashTree->Branch("NOpDets",                     &fNOpDets,   "NOpDets/I");
     fLargestFlashTree->Branch("NHitOpDets",                  &fNHitOpDets,"NHitOpDets/I");
     fLargestFlashTree->Branch("PEsPerOpDetVector",           &fPEsPerOpDetVector);
     fLargestFlashTree->Branch("Purity",                      &fPurity,    "Purity/F");
     fLargestFlashTree->Branch("Distance",                    &fDistance,  "Distance/F");
     fLargestFlashTree->Branch("RecoX",                       &fRecoX,     "RecoX/F");
       
 
     fSelectedFlashTree = tfs->make<TTree>("SelectedFlashTree","SelectedFlashTree");
     fSelectedFlashTree->Branch("EventID",                     &fEventID,   "EventID/I");
     fSelectedFlashTree->Branch("TrueX",                       &fTrueX,     "TrueX/F");
     fSelectedFlashTree->Branch("TrueY",                       &fTrueY,     "TrueY/F");
     fSelectedFlashTree->Branch("TrueZ",                       &fTrueZ,     "TrueZ/F");
     fSelectedFlashTree->Branch("TrueT",                       &fTrueT,     "TrueT/F");
     fSelectedFlashTree->Branch("DetectedT",                   &fDetectedT, "DetectedT/F");
     fSelectedFlashTree->Branch("TrueE",                       &fTrueE,     "TrueE/F");
     fSelectedFlashTree->Branch("TruePDG",                     &fTruePDG,   "TruePDG/I");
     fSelectedFlashTree->Branch("NFlashes",                    &fNFlashes,  "NFlashes/I");
     fSelectedFlashTree->Branch("FlashID",                     &fFlashID,   "FlashID/I");
     fSelectedFlashTree->Branch("YCenter",                     &fYCenter,   "YCenter/F");
     fSelectedFlashTree->Branch("ZCenter",                     &fZCenter,   "ZCenter/F");
     fSelectedFlashTree->Branch("YWidth",                      &fYWidth,    "YWidth/F");
     fSelectedFlashTree->Branch("ZWidth",                      &fZWidth,    "ZWidth/F");
     fSelectedFlashTree->Branch("Time",                        &fTime,      "Time/F");
     fSelectedFlashTree->Branch("TimeWidth",                   &fTimeWidth, "TimeWidth/F");
     fSelectedFlashTree->Branch("TimeDiff",                    &fTimeDiff,  "TimeDiff/F");
     fSelectedFlashTree->Branch("TotalPE",                     &fTotalPE,   "TotalPE/F");
     fSelectedFlashTree->Branch("NOpDets",                     &fNOpDets,   "NOpDets/I");
     fSelectedFlashTree->Branch("NHitOpDets",                  &fNHitOpDets,"NHitOpDets/I");
     fSelectedFlashTree->Branch("PEsPerOpDetVector",           &fPEsPerOpDetVector);
     fSelectedFlashTree->Branch("Purity",                      &fPurity,    "Purity/F");
     fSelectedFlashTree->Branch("Distance",                    &fDistance,    "Distance/F");
     fSelectedFlashTree->Branch("RecoX",                       &fRecoX,     "RecoX/F");
     fSelectedFlashTree->Branch("TruePxallpart",               &fTruePxallpart);
     fSelectedFlashTree->Branch("TruePyallpart",               &fTruePyallpart);
     fSelectedFlashTree->Branch("TruePzallpart",               &fTruePzallpart);
     fSelectedFlashTree->Branch("TrueEallpart",                &fTrueEallpart);
     fSelectedFlashTree->Branch("TrueAllPDG",                  &fTrueAllPDG);
 
     if (!fOpDetWaveformLabel.empty()) {
       fCountTree = tfs->make<TTree>("CountWaveforms","CountWaveforms");
       fCountTree->Branch("EventID",       &fEventID,      "EventID/I");
       fCountTree->Branch("nwaveforms1pe", &fnwaveforms1pe, "nwaveforms1pe/I");
       fCountTree->Branch("nwaveforms2pe", &fnwaveforms2pe, "nwaveforms2pe/I");
       fCountTree->Branch("nwaveforms3pe", &fnwaveforms3pe, "nwaveforms3pe/I");
     }
 
 
 
     fRecoEfficiencyVsE         = tfs->make<TEfficiency>("recoEfficiencyVsE",         ";Energy (GeV);Efficiency",  fNBinsE, fLowE, fHighE);
     fRecoEfficiencyVsX         = tfs->make<TEfficiency>("recoEfficiencyVsX",         ";Position (cm);Efficiency", fNBinsX, fLowX, fHighX);
     fRecoEfficiencyVsXandE     = tfs->make<TEfficiency>("recoEfficiencyVsXandE",     ";Position (cm);Energy (GeV);Efficiency", fNBinsX, fLowX, fHighX, fNBinsE, fLowE, fHighE);
     fLargestEfficiencyVsE      = tfs->make<TEfficiency>("largestEfficiencyVsE",      ";Energy (GeV);Efficiency",  fNBinsE, fLowE, fHighE);
     fLargestEfficiencyVsX      = tfs->make<TEfficiency>("largestEfficiencyVsX",      ";Position (cm);Efficiency", fNBinsX, fLowX, fHighX);
     fLargestEfficiencyVsXandE  = tfs->make<TEfficiency>("largestEfficiencyVsXandE",  ";Position (cm);Energy (GeV);Efficiency", fNBinsX, fLowX, fHighX, fNBinsE, fLowE, fHighE);
     fSelectedEfficiencyVsE     = tfs->make<TEfficiency>("selectedEfficiencyVsE",     ";Energy (GeV);Efficiency",  fNBinsE, fLowE, fHighE);
     fSelectedEfficiencyVsX     = tfs->make<TEfficiency>("selectedEfficiencyVsX",     ";Position (cm);Efficiency", fNBinsX, fLowX, fHighX);
     fSelectedEfficiencyVsXandE = tfs->make<TEfficiency>("selectedEfficiencyVsXandE", ";Position (cm);Energy (GeV);Efficiency", fNBinsX, fLowX, fHighX, fNBinsE, fLowE, fHighE);
   }

opdet::FlashMatchAna::~FlashMatchAna ( )

virtual

Definition at line 305 of file FlashMatchAna_module.cc.

306 {}

Member Function Documentation

void opdet::FlashMatchAna::analyze ( const art::Event & evt )

Definition at line 313 of file FlashMatchAna_module.cc.

   {
     // Get the required services
     art::ServiceHandle< geo::Geometry > geom;
     art::ServiceHandle< cheat::PhotonBackTrackerService > pbt;
     art::ServiceHandle<cheat::ParticleInventoryService> pinv;
     art::ServiceHandle< art::TFileService > tfs;
     //pbt->Rebuild(evt);
 
 
     // Record the event ID
     fEventID = evt.id().event();
 
 
 
 
     ///////////////////////////////////////////////////
     // Count waveforms if a waveform label was given //
     ///////////////////////////////////////////////////
 
     if (!fOpDetWaveformLabel.empty()) {
       fnwaveforms1pe = 0;
       fnwaveforms2pe = 0;
       fnwaveforms3pe = 0;
       auto wfHandle = evt.getHandle< std::vector< raw::OpDetWaveform > >(fOpDetWaveformLabel);
       if (wfHandle) {
         fnwaveforms1pe = wfHandle->size();
 
         for (auto wf: *wfHandle) {
           auto it = max_element(std::begin(wf), std::end(wf));
           double peak = *it - fBaseline;
           if ( peak > (1.5*fPE)) {
             ++fnwaveforms2pe;
 
             if ( peak > (2.5*fPE) )
               ++fnwaveforms3pe;
           }
         }
         fCountTree->Fill();
       }
     }
 
 
 
 
     //////////////////////////////////////
     // Access all the Flash Information //
     //////////////////////////////////////
 
     // Get flashes from event
     std::vector<art::Ptr<recob::OpFlash> > flashlist;
     auto FlashHandle = evt.getHandle< std::vector< recob::OpFlash > >(fOpFlashModuleLabel);
     if (FlashHandle) {
       art::fill_ptr_vector(flashlist, FlashHandle);
       std::sort(flashlist.begin(), flashlist.end(), recob::OpFlashPtrSortByPE);
     }
     else {
       mf::LogWarning("FlashMatchAna") << "Cannot load any flashes. Failing";
       return;
     }
 
     std::vector<art::Ptr<recob::OpHit> > hitlist;
     auto HitHandle = evt.getHandle< std::vector< recob::OpHit > >(fOpHitModuleLabel);
     if (HitHandle) {
       art::fill_ptr_vector(hitlist, HitHandle);
     }
 
     // Get total PE in all hits
     fSumPE = 0;
     for (auto hit: hitlist) 
         fSumPE += hit->PE();
 
     // Get assosciations between flashes and hits
     //art::FindManyP< recob::OpHit > Assns(flashlist, evt, fOpFlashModuleLabel);
 
 
     
     //////////////////////////////////////
     // Access all the truth information //
     //////////////////////////////////////
 
     std::set<int> signal_trackids;
     geo::PlaneID planeid;
 
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
     auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clockData);
 
     try {
       auto MClistHandle = evt.getValidHandle<std::vector<simb::MCTruth> >(fSignalLabel);
 
       art::Ptr<simb::MCTruth> mctruth(MClistHandle, 0);
       if (mctruth->NParticles() == 0) {
         mf::LogError("FlashMatchAna") << "No MCTruth Particles";
       }
 
       // Get all the track ids associated with the signal event.
       art::FindManyP<simb::MCParticle> SignalGeantAssns(MClistHandle,evt,fGeantLabel);
       for ( size_t i = 0; i < SignalGeantAssns.size(); i++) {
         auto parts = SignalGeantAssns.at(i);
         for (auto part = parts.begin(); part != parts.end(); part++) {
           signal_trackids.emplace((*part)->TrackId());
         }
       }
 
       // Get just the neutrino, entry 0 from the list, and record its properties
       const simb::MCParticle& part(mctruth->GetParticle(0));
       fTrueX     = part.Vx();
       fTrueY     = part.Vy();
       fTrueZ     = part.Vz();
       fTrueT     = part.T()*1000; // ns -> us
       fTrueE     = part.E();
       fTruePDG   = part.PdgCode();
 
       // Get all the paricle including neutrino, and record its properties
       unsigned int const nParticles = mctruth->NParticles();
       for (unsigned int i = 0; i < nParticles; ++i) {
         simb::MCParticle const& particle = mctruth->GetParticle(i);
         fTruePxallpart    .emplace_back(particle.Px());
         fTruePyallpart    .emplace_back(particle.Py());
         fTruePzallpart    .emplace_back(particle.Pz());
         fTrueEallpart     .emplace_back(particle.E());
         fTrueAllPDG       .emplace_back(particle.PdgCode());
       }
 
       // Get the PlaneID which describes the location of the true vertex
       int plane = 0;
       double loc[] = {part.Vx(), part.Vy(), part.Vz()};
       geo::TPCID tpc = geom->FindTPCAtPosition(loc);
       if (! geom->HasTPC(tpc) ) {
         mf::LogInfo("FlashMatchAna") << "No valid TPC for " << tpc;
         return;
       }
       geo::PlaneID tempid(tpc, plane);
       planeid = tempid;
 
       // Convert true X to would-be charge arrival time, and convert from ticks to us, add to MC time
       double deltaTicks = detProp.ConvertXToTicks(part.Vx(), planeid);
       double deltaT = clockData.TPCTick2Time(deltaTicks);
       fDetectedT = fTrueT + deltaT;
     }
     catch (art::Exception const& err) 
     {
       // If the error isn't that a product wasn't found, throw it back up.
       if ( err.categoryCode() != art::errors::ProductNotFound ) throw;
 
       // Otherwise, this event just doesn't have signal. Fill default values
       fTrueX = 0;
       fTrueY = 0;
       fTrueZ = 0;
       fTrueT = 0;
       fTrueE = 0;
       fTruePDG = 0;
       fDetectedT = 0;
     }
 
     // Get the maximum possible time difference by getting number of ticks corresponding to
     // one full drift distance, and converting to time.
     double maxT = clockData.TPCTick2Time(detProp.NumberTimeSamples());
 
 
 
     /////////////////////////
     // Analyze the flashes //
     /////////////////////////
 
 
     // Set up some flags to fill as we loop
     // through flashes. These will control
     // filling of efficiency plots after the loop.
     bool AnyReconstructed = false;
     bool LargestFound     = false;
     bool LargestRight     = false;
     bool SelectedFound    = false;
     bool SelectedRight    = false;
 
 
     // For every OpFlash in the vector
     fNOpDets   = geom->NOpDets();
     fNFlashes  = flashlist.size();
     for(unsigned int i = 0; i < flashlist.size(); ++i)
     {
       // Get OpFlash and associated hits
       recob::OpFlash TheFlash = *flashlist[i];
       art::Ptr<recob::OpFlash> FlashP = flashlist[i];
       std::vector< art::Ptr<recob::OpHit> > hitFromFlash = pbt->OpFlashToOpHits_Ps(FlashP);
       std::vector< art::Ptr<recob::OpHit> > matchedHits = pbt->OpFlashToOpHits_Ps(FlashP);
       //std::vector< art::Ptr<recob::OpHit> > matchedHits = Assns.at(i);
 
       // Calculate the flash purity
       double purity = pbt->OpHitCollectionPurity(signal_trackids, matchedHits);
 
       // Calcuate relative detection time
       double timeDiff = fDetectedT - TheFlash.Time();
 
       if (!planeid) {
         // planeid isn't valid
         fRecoX = 0;
       }
       else {
         double ticks = clockData.Time2Tick(timeDiff);
         fRecoX = detProp.ConvertTicksToX(ticks, planeid);
       }
 
       // Check if this is a possible flash (w/in 1 drift window)
       // Otherwise, skip it
       if (timeDiff < -10 || timeDiff > maxT)
         continue;
 
       // Put flash info into variables
       fFlashID     = i;
       fYCenter     = TheFlash.YCenter();
       fZCenter     = TheFlash.ZCenter();
       fYWidth      = TheFlash.YWidth();
       fZWidth      = TheFlash.ZWidth();
       fTime        = TheFlash.Time();
       fTimeWidth   = TheFlash.TimeWidth();
       fTimeDiff    = timeDiff;
       fTotalPE     = TheFlash.TotalPE();
       fPurity      = purity;
 
       // Calculate distance from MC truth vertex in the Y-Z plane
       fDistance = sqrt( pow(fTrueY-fYCenter,2) +  pow(fTrueZ-fZCenter,2) );
 
 
 
       // Loop through all the opdets with hits in this flash
       fPEsPerOpDetVector.clear();
       for(unsigned int iOD = 0; iOD < geom->NOpDets(); ++iOD){
         fPEsPerOpDetVector.emplace_back(0);
       }
       for(unsigned int iC=0; iC < geom->NOpChannels(); ++iC)
       {
         unsigned int iOD = geom->OpDetFromOpChannel(iC);
         fPEsPerOpDetVector[iOD] += TheFlash.PE(iC);
       }
 
       fNHitOpDets = 0;
       for(unsigned int iOD = 0; iOD < geom->NOpDets(); ++iOD){
         if (fPEsPerOpDetVector[iOD] > 0) ++fNHitOpDets;
       }
       fNHitOpDetVector.emplace_back(fNHitOpDets);
      
 
       // Add flash info to the tree of all possible flashes
       fFlashIDVector    .emplace_back(fFlashID);
       fYCenterVector    .emplace_back(fYCenter);
       fZCenterVector    .emplace_back(fZCenter);
       fYWidthVector     .emplace_back(fYWidth);
       fZWidthVector     .emplace_back(fZWidth);
       fTimeVector       .emplace_back(fTime);
       fTimeWidthVector  .emplace_back(fTimeWidth);
       fTimeDiffVector   .emplace_back(fTimeDiff);
       fTotalPEVector    .emplace_back(fTotalPE);
       fPurityVector     .emplace_back(fPurity);
       fDistanceVector   .emplace_back(fDistance);
       fRecoXVector      .emplace_back(fRecoX);
 
 
       // Did we reconstruct any flashes with signal in them?
       if (fPurity > 0) AnyReconstructed = true;
 
 
       // First == Largest, so if this is the first flash it is also the largest.
       // So, fill the LargestFlash tree and the LargestFlash efficiency plots
       if (!LargestFound) {
 
         // Write out the info into the tree for the largest flash
         fLargestFlashTree->Fill();
 
         // Record that we found the largest flash
         // and if we got it right
         LargestFound = true;
         if (fPurity > 0) LargestRight = true;
       }
 
 
       // The first time we get into here we have the largest flash that is
       // within the distance cut. So, fill the SelectedFlash tree and the
       // selected flash efficiency plots
       if (!SelectedFound && fDistance < fDistanceCut) {
 
         // Write out the info for the selected flash
         fSelectedFlashTree->Fill();
 
         // Record that we found the selected flash
         // and if we got it right
         SelectedFound = true;
         if (fPurity > 0) SelectedRight = true;
       }
 
     }
 
     // Fill these TEfficiencies once for every event
     // but use the booleans to decide if it was
     // "selected" or not.
     fRecoEfficiencyVsE->Fill(AnyReconstructed, fTrueE);
     fRecoEfficiencyVsX->Fill(AnyReconstructed, fTrueX);
     fRecoEfficiencyVsXandE->Fill(AnyReconstructed, fTrueX, fTrueE);
 
     fLargestEfficiencyVsE->Fill(LargestRight, fTrueE);
     fLargestEfficiencyVsX->Fill(LargestRight, fTrueX);
     fLargestEfficiencyVsXandE->Fill(LargestRight, fTrueX, fTrueE);
 
     fSelectedEfficiencyVsE->Fill(SelectedRight, fTrueE);
     fSelectedEfficiencyVsX->Fill(SelectedRight, fTrueX);
     fSelectedEfficiencyVsXandE->Fill(SelectedRight, fTrueX, fTrueE);
 
 
 
 
     ///////////////////////////////////////////////
     // Write out the FlashMatchTree and clean up //
     ///////////////////////////////////////////////
 
     fFlashMatchTree->Fill();
     fFlashIDVector              .clear();
     fYCenterVector              .clear();
     fZCenterVector              .clear();
     fYWidthVector               .clear();
     fZWidthVector               .clear();
     fTimeVector                 .clear();
     fTimeWidthVector            .clear();
     fTimeDiffVector             .clear();
     fTotalPEVector              .clear();
     fNHitOpDetVector            .clear();
     fPurityVector               .clear();
     fDistanceVector             .clear();
     fRecoXVector                .clear();
     fTruePxallpart              .clear();
     fTruePyallpart              .clear();
     fTruePzallpart              .clear();
     fTrueEallpart               .clear();
     fTrueAllPDG                 .clear();
   }

void opdet::FlashMatchAna::beginJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 309 of file FlashMatchAna_module.cc.

310 {}

Member Data Documentation

float opdet::FlashMatchAna::fBaseline

private

Definition at line 157 of file FlashMatchAna_module.cc.

TTree* opdet::FlashMatchAna::fCountTree

private

Definition at line 159 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fDetectedT

private

Definition at line 106 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fDistance

private

Definition at line 150 of file FlashMatchAna_module.cc.

float opdet::FlashMatchAna::fDistanceCut

private

Definition at line 98 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fDistanceVector

private

Definition at line 133 of file FlashMatchAna_module.cc.

Int_t opdet::FlashMatchAna::fEventID

private

Definition at line 100 of file FlashMatchAna_module.cc.

std::vector< Int_t > opdet::FlashMatchAna::fFlashFrameVector

private

Definition at line 127 of file FlashMatchAna_module.cc.

Int_t opdet::FlashMatchAna::fFlashID

private

Definition at line 137 of file FlashMatchAna_module.cc.

std::vector< Int_t > opdet::FlashMatchAna::fFlashIDVector

private

Definition at line 118 of file FlashMatchAna_module.cc.

TTree* opdet::FlashMatchAna::fFlashMatchTree

private

Definition at line 76 of file FlashMatchAna_module.cc.

std::string opdet::FlashMatchAna::fGeantLabel

private

Definition at line 74 of file FlashMatchAna_module.cc.

float opdet::FlashMatchAna::fHighE

private

Definition at line 94 of file FlashMatchAna_module.cc.

float opdet::FlashMatchAna::fHighX

private

Definition at line 97 of file FlashMatchAna_module.cc.

std::vector< Bool_t > opdet::FlashMatchAna::fInBeamFrameVector

private

Definition at line 128 of file FlashMatchAna_module.cc.

TEfficiency* opdet::FlashMatchAna::fLargestEfficiencyVsE

private

Definition at line 84 of file FlashMatchAna_module.cc.

TEfficiency* opdet::FlashMatchAna::fLargestEfficiencyVsX

private

Definition at line 85 of file FlashMatchAna_module.cc.

TEfficiency* opdet::FlashMatchAna::fLargestEfficiencyVsXandE

private

Definition at line 86 of file FlashMatchAna_module.cc.

TTree* opdet::FlashMatchAna::fLargestFlashTree

private

Definition at line 77 of file FlashMatchAna_module.cc.

float opdet::FlashMatchAna::fLowE

private

Definition at line 93 of file FlashMatchAna_module.cc.

float opdet::FlashMatchAna::fLowX

private

Definition at line 96 of file FlashMatchAna_module.cc.

int opdet::FlashMatchAna::fNBinsE

private

Definition at line 92 of file FlashMatchAna_module.cc.

int opdet::FlashMatchAna::fNBinsX

private

Definition at line 95 of file FlashMatchAna_module.cc.

Int_t opdet::FlashMatchAna::fNFlashes

private

Definition at line 117 of file FlashMatchAna_module.cc.

Int_t opdet::FlashMatchAna::fNHitOpDets

private

Definition at line 151 of file FlashMatchAna_module.cc.

std::vector<Int_t> opdet::FlashMatchAna::fNHitOpDetVector

private

Definition at line 135 of file FlashMatchAna_module.cc.

Int_t opdet::FlashMatchAna::fNOpDets

private

Definition at line 134 of file FlashMatchAna_module.cc.

Int_t opdet::FlashMatchAna::fnwaveforms1pe

private

Definition at line 160 of file FlashMatchAna_module.cc.

Int_t opdet::FlashMatchAna::fnwaveforms2pe

private

Definition at line 161 of file FlashMatchAna_module.cc.

Int_t opdet::FlashMatchAna::fnwaveforms3pe

private

Definition at line 162 of file FlashMatchAna_module.cc.

std::vector< Int_t > opdet::FlashMatchAna::fOnBeamTimeVector

private

Definition at line 129 of file FlashMatchAna_module.cc.

std::string opdet::FlashMatchAna::fOpDetWaveformLabel

private

Definition at line 156 of file FlashMatchAna_module.cc.

std::string opdet::FlashMatchAna::fOpFlashModuleLabel

private

Definition at line 71 of file FlashMatchAna_module.cc.

std::string opdet::FlashMatchAna::fOpHitModuleLabel

private

Definition at line 72 of file FlashMatchAna_module.cc.

float opdet::FlashMatchAna::fPE

private

Definition at line 158 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fPEsPerOpDetVector

private

Definition at line 152 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fPurity

private

Definition at line 149 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fPurityVector

private

Definition at line 132 of file FlashMatchAna_module.cc.

TEfficiency* opdet::FlashMatchAna::fRecoEfficiencyVsE

private

Definition at line 81 of file FlashMatchAna_module.cc.

TEfficiency* opdet::FlashMatchAna::fRecoEfficiencyVsX

private

Definition at line 82 of file FlashMatchAna_module.cc.

TEfficiency* opdet::FlashMatchAna::fRecoEfficiencyVsXandE

private

Definition at line 83 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fRecoX

private

Definition at line 109 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fRecoXVector

private

Definition at line 124 of file FlashMatchAna_module.cc.

TEfficiency* opdet::FlashMatchAna::fSelectedEfficiencyVsE

private

Definition at line 87 of file FlashMatchAna_module.cc.

TEfficiency* opdet::FlashMatchAna::fSelectedEfficiencyVsX

private

Definition at line 88 of file FlashMatchAna_module.cc.

TEfficiency* opdet::FlashMatchAna::fSelectedEfficiencyVsXandE

private

Definition at line 89 of file FlashMatchAna_module.cc.

TTree* opdet::FlashMatchAna::fSelectedFlashTree

private

Definition at line 78 of file FlashMatchAna_module.cc.

std::string opdet::FlashMatchAna::fSignalLabel

private

Definition at line 73 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fSumPE

private

Definition at line 131 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fTime

private

Definition at line 142 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fTimeDiff

private

Definition at line 144 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fTimeDiffVector

private

Definition at line 126 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fTimeVector

private

Definition at line 123 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fTimeWidth

private

Definition at line 143 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fTimeWidthVector

private

Definition at line 125 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fTotalPE

private

Definition at line 148 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fTotalPEVector

private

Definition at line 130 of file FlashMatchAna_module.cc.

std::vector< Int_t > opdet::FlashMatchAna::fTrueAllPDG

private

Definition at line 115 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fTrueE

private

Definition at line 107 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fTrueEallpart

private

Definition at line 114 of file FlashMatchAna_module.cc.

Int_t opdet::FlashMatchAna::fTruePDG

private

Definition at line 108 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fTruePxallpart

private

Definition at line 111 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fTruePyallpart

private

Definition at line 112 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fTruePzallpart

private

Definition at line 113 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fTrueT

private

Definition at line 105 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fTrueX

private

Definition at line 102 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fTrueY

private

Definition at line 103 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fTrueZ

private

Definition at line 104 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fYCenter

private

Definition at line 138 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fYCenterVector

private

Definition at line 119 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fYWidth

private

Definition at line 140 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fYWidthVector

private

Definition at line 121 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fZCenter

private

Definition at line 139 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fZCenterVector

private

Definition at line 120 of file FlashMatchAna_module.cc.

Float_t opdet::FlashMatchAna::fZWidth

private

Definition at line 141 of file FlashMatchAna_module.cc.

std::vector< Float_t > opdet::FlashMatchAna::fZWidthVector

private

Definition at line 122 of file FlashMatchAna_module.cc.

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

duneopdet/duneopdet/OpticalDetector/FlashMatchAna_module.cc

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation