Inheritance diagram for opdet::OpFlashAna:

Public Types
using	ModuleType = EDAnalyzer

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

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

std::string	fOpHitModuleLabel

float	fSampleFreq

float	fTimeBegin

float	fTimeEnd

float	fYMin

float	fYMax

float	fZMin

float	fZMax

int	PosHistYRes

int	PosHistZRes

bool	fMakeFlashTimeHist

bool	fMakeFlashPosHist

bool	fMakePerFlashHists

bool	fMakePerEventFlashTree

bool	fMakePerFlashTree

bool	fMakePerOpHitTree

bool	fMakeFlashBreakdownTree

bool	fMakeFlashHitMatchTree

TTree *	fPerEventFlashTree

TTree *	fPerFlashTree

TTree *	fPerOpHitTree

TTree *	fFlashBreakdownTree

TTree *	fFlashHitMatchTree

Int_t	fEventID

Int_t	fFlashID

Int_t	fHitID

Double_t	fFlashTime

Double_t	fAbsTime

bool	fInBeamFrame

int	fOnBeamTime

Float_t	fTotalPE

Int_t	fFlashFrame

Float_t	fNPe

Float_t	fYCenter

Float_t	fYWidth

Float_t	fZCenter

Float_t	fZWidth

Int_t	fOpChannel

Double_t	fPeakTimeAbs

Double_t	fPeakTime

Int_t	fFrame

Float_t	fWidth

Float_t	fArea

Float_t	fAmplitude

Float_t	fPE

Float_t	fFastToTotal

int	fNFlashes

std::vector< int >	fFlashIDVector

std::vector< float >	fYCenterVector

std::vector< float >	fZCenterVector

std::vector< float >	fYWidthVector

std::vector< float >	fZWidthVector

std::vector< double >	fFlashTimeVector

std::vector< double >	fAbsTimeVector

std::vector< int >	fFlashFrameVector

std::vector< bool >	fInBeamFrameVector

std::vector< int >	fOnBeamTimeVector

std::vector< float >	fTotalPEVector

int	fNChannels

std::vector< float >	fPEsPerFlashPerChannelVector

Detailed Description

Definition at line 34 of file OpFlashAna_module.cc.

Member Typedef Documentation

using art::EDAnalyzer::ModuleType = EDAnalyzer

inherited

Definition at line 22 of file EDAnalyzer.h.

Constructor & Destructor Documentation

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

Definition at line 121 of file OpFlashAna_module.cc.

References fAbsTime, fAbsTimeVector, fAmplitude, fArea, fEventID, fFastToTotal, fFlashBreakdownTree, fFlashFrame, fFlashFrameVector, fFlashHitMatchTree, fFlashID, fFlashIDVector, fFlashTime, fFlashTimeVector, fFrame, fHitID, fInBeamFrame, fInBeamFrameVector, fMakeFlashBreakdownTree, fMakeFlashHitMatchTree, fMakeFlashPosHist, fMakeFlashTimeHist, fMakePerEventFlashTree, fMakePerFlashHists, fMakePerFlashTree, fMakePerOpHitTree, fNChannels, fNFlashes, fNPe, fOnBeamTime, fOnBeamTimeVector, fOpChannel, fOpFlashModuleLabel, fOpHitModuleLabel, fPE, fPeakTime, fPeakTimeAbs, fPerEventFlashTree, fPerFlashTree, fPerOpHitTree, fPEsPerFlashPerChannelVector, fSampleFreq, fTimeBegin, fTimeEnd, fTotalPE, fTotalPEVector, fWidth, fYCenter, fYCenterVector, fYMax, fYMin, fYWidth, fYWidthVector, fZCenter, fZCenterVector, fZMax, fZMin, fZWidth, fZWidthVector, fhicl::ParameterSet::get(), PosHistYRes, and PosHistZRes.

                                                       : EDAnalyzer(pset)
   {
 
     // Indicate that the Input Module comes from .fcl
     fOpFlashModuleLabel = pset.get<std::string>("OpFlashModuleLabel");
     fOpHitModuleLabel = pset.get<std::string>("OpHitModuleLabel");
 
     //    art::ServiceHandle<OpDigiProperties const> odp;
     //    fTimeBegin  = odp->TimeBegin();
     //    fTimeEnd    = odp->TimeEnd();
     //    fSampleFreq = odp->SampleFreq();
 
     auto const clock_data =
       art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
     fTimeBegin = clock_data.OpticalClock().Time();
     fTimeEnd = clock_data.OpticalClock().FramePeriod();
     fSampleFreq = clock_data.OpticalClock().Frequency();
 
     fYMin = pset.get<float>("YMin");
     fYMax = pset.get<float>("YMax");
     fZMin = pset.get<float>("ZMin");
     fZMax = pset.get<float>("ZMax");
 
     fMakeFlashTimeHist = pset.get<bool>("MakeFlashTimeHist");
     fMakeFlashPosHist = pset.get<bool>("MakeFlashPosHist");
     fMakePerFlashHists = pset.get<bool>("MakePerFlashHists");
 
     fMakePerEventFlashTree = pset.get<bool>("MakePerEventFlashTree");
     fMakePerFlashTree = pset.get<bool>("MakePerFlashTree");
     fMakePerOpHitTree = pset.get<bool>("MakePerOpHitTree");
     fMakeFlashBreakdownTree = pset.get<bool>("MakeFlashBreakdownTree");
     fMakeFlashHitMatchTree = pset.get<bool>("MakeFlashHitMatchTree");
 
     PosHistYRes = 100;
     PosHistZRes = 100;
 
     art::ServiceHandle<art::TFileService const> tfs;
 
     if (fMakeFlashBreakdownTree) {
       fFlashBreakdownTree = tfs->make<TTree>("FlashBreakdownTree", "FlashBreakdownTree");
       fFlashBreakdownTree->Branch("EventID", &fEventID, "EventID/I");
       fFlashBreakdownTree->Branch("FlashID", &fFlashID, "FlashID/I");
       fFlashBreakdownTree->Branch("OpChannel", &fOpChannel, "OpChannel/I");
       fFlashBreakdownTree->Branch("FlashTime", &fFlashTime, "FlashTime/D");
       fFlashBreakdownTree->Branch("NPe", &fNPe, "NPe/F");
       fFlashBreakdownTree->Branch("AbsTime", &fAbsTime, "AbsTime/D");
       fFlashBreakdownTree->Branch("FlashFrame", &fFlashFrame, "FlashFrame/I");
       fFlashBreakdownTree->Branch("InBeamFrame", &fInBeamFrame, "InBeamFrame/B");
       fFlashBreakdownTree->Branch("OnBeamTime", &fOnBeamTime, "OnBeamTime/I");
       fFlashBreakdownTree->Branch("YCenter", &fYCenter, "YCenter/F");
       fFlashBreakdownTree->Branch("ZCenter", &fZCenter, "ZCenter/F");
       fFlashBreakdownTree->Branch("YWidth", &fYWidth, "YWidth/F");
       fFlashBreakdownTree->Branch("ZWidth", &fZWidth, "ZWidth/F");
       fFlashBreakdownTree->Branch("TotalPE", &fTotalPE, "TotalPE/F");
     }
 
     if (fMakePerOpHitTree) {
       fPerOpHitTree = tfs->make<TTree>("PerOpHitTree", "PerOpHitTree");
       fPerOpHitTree->Branch("EventID", &fEventID, "EventID/I");
       fPerOpHitTree->Branch("HitID", &fHitID, "HitID/I");
       fPerOpHitTree->Branch("OpChannel", &fOpChannel, "OpChannel/I");
       fPerOpHitTree->Branch("PeakTimeAbs", &fPeakTimeAbs, "PeakTimeAbs/D");
       fPerOpHitTree->Branch("PeakTime", &fPeakTime, "PeakTime/D");
       fPerOpHitTree->Branch("Frame", &fFrame, "Frame/I");
       fPerOpHitTree->Branch("Width", &fWidth, "Width/F");
       fPerOpHitTree->Branch("Area", &fArea, "Area/F");
       fPerOpHitTree->Branch("Amplitude", &fAmplitude, "Amplitude/F");
       fPerOpHitTree->Branch("PE", &fPE, "PE/F");
       fPerOpHitTree->Branch("FastToTotal", &fFastToTotal, "FastToTotal/F");
     }
 
     if (fMakePerFlashTree) {
       fPerFlashTree = tfs->make<TTree>("PerFlashTree", "PerFlashTree");
       fPerFlashTree->Branch("EventID", &fEventID, "EventID/I");
       fPerFlashTree->Branch("FlashID", &fFlashID, "FlashID/I");
       fPerFlashTree->Branch("YCenter", &fYCenter, "YCenter/F");
       fPerFlashTree->Branch("ZCenter", &fZCenter, "ZCenter/F");
       fPerFlashTree->Branch("YWidth", &fYWidth, "YWidth/F");
       fPerFlashTree->Branch("ZWidth", &fZWidth, "ZWidth/F");
       fPerFlashTree->Branch("FlashTime", &fFlashTime, "FlashTime/D");
       fPerFlashTree->Branch("AbsTime", &fAbsTime, "AbsTime/D");
       fPerFlashTree->Branch("FlashFrame", &fFlashFrame, "FlashFrame/I");
       fPerFlashTree->Branch("InBeamFrame", &fInBeamFrame, "InBeamFrame/B");
       fPerFlashTree->Branch("OnBeamTime", &fOnBeamTime, "OnBeamTime/I");
       fPerFlashTree->Branch("TotalPE", &fTotalPE, "TotalPE/F");
     }
 
     if (fMakePerEventFlashTree) {
       fPerEventFlashTree = tfs->make<TTree>("PerEventFlashTree", "PerEventFlashTree");
       fPerEventFlashTree->Branch("EventID", &fEventID, "EventID/I");
       fPerEventFlashTree->Branch("NFlashes", &fNFlashes, "NFlashes/I");
       fPerEventFlashTree->Branch("FlashIDVector", &fFlashIDVector);
       fPerEventFlashTree->Branch("YCenterVector", &fYCenterVector);
       fPerEventFlashTree->Branch("ZCenterVector", &fZCenterVector);
       fPerEventFlashTree->Branch("YWidthVector", &fYWidthVector);
       fPerEventFlashTree->Branch("ZWidthVector", &fZWidthVector);
       fPerEventFlashTree->Branch("FlashTimeVector", &fFlashTimeVector);
       fPerEventFlashTree->Branch("AbsTimeVector", &fAbsTimeVector);
       fPerEventFlashTree->Branch("FlashFrameVector", &fFlashFrameVector);
       fPerEventFlashTree->Branch("InBeamFrameVector", &fInBeamFrameVector);
       fPerEventFlashTree->Branch("OnBeamTimeVector", &fOnBeamTimeVector);
       fPerEventFlashTree->Branch("TotalPEVector", &fTotalPEVector);
       fPerEventFlashTree->Branch("NChannels", &fNChannels, "NChannels/I");
       // The only way I can think of to record a two-dimensional variable-size array in a TTree
       // is by flattening it into a one-dimension variable-size array
       fPerEventFlashTree->Branch("PEsPerFlashPerChannelVector", &fPEsPerFlashPerChannelVector);
     }
 
     if (fMakeFlashHitMatchTree) {
       fFlashHitMatchTree = tfs->make<TTree>("FlashHitMatchTree", "FlashHitMatchTree");
       fFlashHitMatchTree->Branch("EventID", &fEventID, "EventID/I");
       fFlashHitMatchTree->Branch("FlashID", &fFlashID, "FlashID/I");
       fFlashHitMatchTree->Branch("HitID", &fHitID, "HitID/I");
       fFlashHitMatchTree->Branch("OpChannel", &fOpChannel, "OpChannel/I");
       fFlashHitMatchTree->Branch("HitPeakTimeAbs", &fPeakTimeAbs, "HitPeakTimeAbs/F");
       fFlashHitMatchTree->Branch("HitPeakTime", &fPeakTime, "HitPeakTime/F");
       fFlashHitMatchTree->Branch("HitPE", &fPE, "HitPE/F");
       fFlashHitMatchTree->Branch("FlashPE", &fTotalPE, "FlashPE/F");
       fFlashHitMatchTree->Branch("FlashTimeAbs", &fAbsTime, "FlashTimeAbs/D");
       fFlashHitMatchTree->Branch("FlashTime", &fFlashTime, "FlashTime/D");
       fFlashHitMatchTree->Branch("HitFrame", &fFrame, "HitFrame/I");
       fFlashHitMatchTree->Branch("FlashFrame", &fFlashFrame, "FlashFrame/I");
     }
 
     fFlashID = 0;
   }

Member Function Documentation

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

Definition at line 249 of file OpFlashAna_module.cc.

References recob::OpFlash::AbsTime(), DEFINE_ART_MODULE, art::EventID::event(), fAbsTime, fAbsTimeVector, fAmplitude, fArea, fEventID, fFastToTotal, fFlashBreakdownTree, fFlashFrame, fFlashFrameVector, fFlashHitMatchTree, fFlashID, fFlashIDVector, fFlashTime, fFlashTimeVector, fFrame, fHitID, Fill(), fInBeamFrame, fInBeamFrameVector, fMakeFlashBreakdownTree, fMakeFlashHitMatchTree, fMakeFlashPosHist, fMakeFlashTimeHist, fMakePerEventFlashTree, fMakePerFlashHists, fMakePerFlashTree, fMakePerOpHitTree, fNChannels, fNFlashes, fNPe, fOnBeamTime, fOnBeamTimeVector, fOpChannel, fOpFlashModuleLabel, fOpHitModuleLabel, fPE, fPeakTime, fPeakTimeAbs, fPerEventFlashTree, fPerFlashTree, fPerOpHitTree, fPEsPerFlashPerChannelVector, recob::OpFlash::Frame(), fSampleFreq, fTimeBegin, fTimeEnd, fTotalPE, fTotalPEVector, fWidth, fYCenter, fYCenterVector, fYMax, fYMin, fYWidth, fYWidthVector, fZCenter, fZCenterVector, fZMax, fZMin, fZWidth, fZWidthVector, art::ProductRetriever::getByLabel(), art::Event::id(), recob::OpFlash::InBeamFrame(), geo::GeometryCore::NOpChannels(), recob::OpFlash::OnBeamTime(), recob::OpFlash::PE(), PosHistYRes, PosHistZRes, recob::OpFlash::Time(), recob::OpFlash::TotalPE(), y, recob::OpFlash::YCenter(), recob::OpFlash::YWidth(), z, recob::OpFlash::ZCenter(), and recob::OpFlash::ZWidth().

   {
 
     // Get flashes from event
     art::Handle<std::vector<recob::OpFlash>> FlashHandle;
     evt.getByLabel(fOpFlashModuleLabel, FlashHandle);
 
     // Get assosciations between flashes and hits
     art::FindManyP<recob::OpHit> Assns(FlashHandle, evt, fOpFlashModuleLabel);
 
     // Create string for histogram name
     char HistName[50];
 
     fFlashID = 0;
 
     // Access ART's TFileService, which will handle creating and writing
     // histograms for us.
     art::ServiceHandle<art::TFileService const> tfs;
 
     std::vector<TH1D*> FlashHist;
 
     fEventID = evt.id().event();
 
     sprintf(HistName, "Event %d Flash Times", evt.id().event());
     TH1D* FlashTimes = nullptr;
     if (fMakeFlashTimeHist) {
       FlashTimes = tfs->make<TH1D>(HistName,
                                    ";t (ns);",
                                    int((fTimeEnd - fTimeBegin) * fSampleFreq),
                                    fTimeBegin * 1000.,
                                    fTimeEnd * 1000.);
     }
 
     TH2D* FlashPositions = nullptr;
     if (fMakeFlashPosHist) {
       sprintf(HistName, "Event %d All Flashes YZ", evt.id().event());
 
       FlashPositions =
         tfs->make<TH2D>(HistName, ";y ;z ", PosHistYRes, fYMin, fYMax, PosHistZRes, fZMin, fZMax);
     }
 
     art::ServiceHandle<geo::Geometry const> geom;
     unsigned int NOpChannels = geom->NOpChannels();
 
     if (fMakePerEventFlashTree) {
       fNFlashes = FlashHandle->size();
       fNChannels = NOpChannels;
     }
 
     // For every OpFlash in the vector
     for (unsigned int i = 0; i < FlashHandle->size(); ++i) {
 
       // Get OpFlash
       art::Ptr<recob::OpFlash> TheFlashPtr(FlashHandle, i);
       recob::OpFlash TheFlash = *TheFlashPtr;
 
       fFlashTime = TheFlash.Time();
       fFlashID = i; //++;
 
       TH2D* ThisFlashPosition = nullptr;
       if (fMakePerFlashHists) {
         sprintf(HistName, "Event %d t = %f", evt.id().event(), fFlashTime);
         FlashHist.push_back(
           tfs->make<TH1D>(HistName, ";OpChannel;PE", NOpChannels, 0, NOpChannels));
 
         sprintf(HistName, "Event %d Flash %f YZ", evt.id().event(), fFlashTime);
 
         ThisFlashPosition =
           tfs->make<TH2D>(HistName, ";y ;z ", PosHistYRes, fYMin, fYMax, PosHistZRes, fZMin, fZMax);
       }
       fYCenter = TheFlash.YCenter();
       fZCenter = TheFlash.ZCenter();
       fYWidth = TheFlash.YWidth();
       fZWidth = TheFlash.ZWidth();
       fInBeamFrame = TheFlash.InBeamFrame();
       fOnBeamTime = TheFlash.OnBeamTime();
       fAbsTime = TheFlash.AbsTime();
       fFlashFrame = TheFlash.Frame();
       fTotalPE = TheFlash.TotalPE();
 
       if (fMakePerEventFlashTree) {
         fFlashIDVector.emplace_back(i);
         fYCenterVector.emplace_back(TheFlash.YCenter());
         fZCenterVector.emplace_back(TheFlash.ZCenter());
         fYWidthVector.emplace_back(TheFlash.YWidth());
         fZWidthVector.emplace_back(TheFlash.ZWidth());
         fFlashTimeVector.emplace_back(TheFlash.Time());
         fAbsTimeVector.emplace_back(TheFlash.AbsTime());
         fFlashFrameVector.emplace_back(TheFlash.Frame());
         fInBeamFrameVector.emplace_back(TheFlash.InBeamFrame());
         fOnBeamTimeVector.emplace_back(TheFlash.OnBeamTime());
         fTotalPEVector.emplace_back(TheFlash.TotalPE());
       }
 
       for (unsigned int j = 0; j != NOpChannels; ++j) {
         if (fMakePerFlashHists) FlashHist.at(FlashHist.size() - 1)->Fill(j, TheFlash.PE(j));
         fNPe = TheFlash.PE(j);
         fOpChannel = j;
 
         if (fMakePerEventFlashTree) fPEsPerFlashPerChannelVector.emplace_back(TheFlash.PE(j));
 
         if ((fMakeFlashBreakdownTree) && (fNPe > 0)) fFlashBreakdownTree->Fill();
       }
 
       for (int y = 0; y != PosHistYRes; ++y)
         for (int z = 0; z != PosHistZRes; ++z) {
           float ThisY = fYMin + (fYMax - fYMin) * float(y) / PosHistYRes + 0.0001;
           float ThisZ = fZMin + (fZMax - fZMin) * float(z) / PosHistZRes + 0.0001;
           if (fMakePerFlashHists)
             ThisFlashPosition->Fill(ThisY,
                                     ThisZ,
                                     fTotalPE * exp(-pow((ThisY - fYCenter) / fYWidth, 2) / 2. -
                                                    pow((ThisZ - fZCenter) / fZWidth, 2) / 2.));
           if (fMakeFlashPosHist)
             FlashPositions->Fill(ThisY,
                                  ThisZ,
                                  fTotalPE * exp(-pow((ThisY - fYCenter) / fYWidth, 2) -
                                                 pow((ThisZ - fZCenter) / fZWidth, 2)));
         }
 
       if (fMakeFlashTimeHist) FlashTimes->Fill(fFlashTime, fTotalPE);
 
       if (fMakePerFlashTree) fPerFlashTree->Fill();
 
       if (fMakeFlashHitMatchTree) {
         // Extract the assosciations
         fHitID = 0;
         std::vector<art::Ptr<recob::OpHit>> matchedHits = Assns.at(i);
         for (auto ophit : matchedHits) {
           fOpChannel = ophit->OpChannel();
           fPeakTimeAbs = ophit->PeakTimeAbs();
           fPeakTime = ophit->PeakTime();
           fFrame = ophit->Frame();
           fWidth = ophit->Width();
           fArea = ophit->Area();
           fAmplitude = ophit->Amplitude();
           fPE = ophit->PE();
           fFastToTotal = ophit->FastToTotal();
           fFlashHitMatchTree->Fill();
           fHitID++;
         }
       }
     }
 
     if (fMakePerOpHitTree) {
       art::Handle<std::vector<recob::OpHit>> OpHitHandle;
       evt.getByLabel(fOpHitModuleLabel, OpHitHandle);
 
       for (size_t i = 0; i != OpHitHandle->size(); ++i) {
         fOpChannel = OpHitHandle->at(i).OpChannel();
         fPeakTimeAbs = OpHitHandle->at(i).PeakTimeAbs();
         fPeakTime = OpHitHandle->at(i).PeakTime();
         fFrame = OpHitHandle->at(i).Frame();
         fWidth = OpHitHandle->at(i).Width();
         fArea = OpHitHandle->at(i).Area();
         fAmplitude = OpHitHandle->at(i).Amplitude();
         fPE = OpHitHandle->at(i).PE();
         fFastToTotal = OpHitHandle->at(i).FastToTotal();
         fHitID = i;
         fPerOpHitTree->Fill();
       }
     }
 
     if (fMakePerEventFlashTree) {
       fPerEventFlashTree->Fill();
       fFlashIDVector.clear();
       fYCenterVector.clear();
       fZCenterVector.clear();
       fYWidthVector.clear();
       fZWidthVector.clear();
       fFlashTimeVector.clear();
       fAbsTimeVector.clear();
       fFlashFrameVector.clear();
       fInBeamFrameVector.clear();
       fOnBeamTimeVector.clear();
       fTotalPEVector.clear();
       fPEsPerFlashPerChannelVector.clear();
     }
   }

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

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

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

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

Member Data Documentation

Double_t opdet::OpFlashAna::fAbsTime

private

Definition at line 77 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<double> opdet::OpFlashAna::fAbsTimeVector

private

Definition at line 106 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fAmplitude

private

Definition at line 95 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fArea

private

Definition at line 94 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fEventID

private

Definition at line 73 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fFastToTotal

private

Definition at line 97 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fFlashBreakdownTree

private

Definition at line 70 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fFlashFrame

private

Definition at line 81 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<int> opdet::OpFlashAna::fFlashFrameVector

private

Definition at line 107 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fFlashHitMatchTree

private

Definition at line 71 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fFlashID

private

Definition at line 74 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<int> opdet::OpFlashAna::fFlashIDVector

private

Definition at line 100 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Double_t opdet::OpFlashAna::fFlashTime

private

Definition at line 76 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<double> opdet::OpFlashAna::fFlashTimeVector

private

Definition at line 105 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fFrame

private

Definition at line 92 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fHitID

private

Definition at line 75 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fInBeamFrame

private

Definition at line 78 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<bool> opdet::OpFlashAna::fInBeamFrameVector

private

Definition at line 108 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakeFlashBreakdownTree

private

Definition at line 64 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakeFlashHitMatchTree

private

Definition at line 65 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakeFlashPosHist

private

Definition at line 58 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakeFlashTimeHist

private

Definition at line 57 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakePerEventFlashTree

private

Definition at line 61 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakePerFlashHists

private

Definition at line 59 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakePerFlashTree

private

Definition at line 62 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakePerOpHitTree

private

Definition at line 63 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::fNChannels

private

Definition at line 111 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::fNFlashes

private

Definition at line 99 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fNPe

private

Definition at line 83 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::fOnBeamTime

private

Definition at line 79 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<int> opdet::OpFlashAna::fOnBeamTimeVector

private

Definition at line 109 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fOpChannel

private

Definition at line 89 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::string opdet::OpFlashAna::fOpFlashModuleLabel

private

Definition at line 47 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::string opdet::OpFlashAna::fOpHitModuleLabel

private

Definition at line 48 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fPE

private

Definition at line 96 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Double_t opdet::OpFlashAna::fPeakTime

private

Definition at line 91 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Double_t opdet::OpFlashAna::fPeakTimeAbs

private

Definition at line 90 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fPerEventFlashTree

private

Definition at line 67 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fPerFlashTree

private

Definition at line 68 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fPerOpHitTree

private

Definition at line 69 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<float> opdet::OpFlashAna::fPEsPerFlashPerChannelVector

private

Definition at line 112 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fSampleFreq

private

Definition at line 49 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fTimeBegin

private

Definition at line 50 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fTimeEnd

private

Definition at line 51 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fTotalPE

private

Definition at line 80 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<float> opdet::OpFlashAna::fTotalPEVector

private

Definition at line 110 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fWidth

private

Definition at line 93 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fYCenter

private

Definition at line 84 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<float> opdet::OpFlashAna::fYCenterVector

private

Definition at line 101 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fYMax

private

Definition at line 53 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fYMin

private

Definition at line 53 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fYWidth

private

Definition at line 85 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<float> opdet::OpFlashAna::fYWidthVector

private

Definition at line 103 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fZCenter

private

Definition at line 86 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<float> opdet::OpFlashAna::fZCenterVector

private

Definition at line 102 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fZMax

private

Definition at line 53 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fZMin

private

Definition at line 53 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fZWidth

private

Definition at line 87 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::vector<float> opdet::OpFlashAna::fZWidthVector

private

Definition at line 104 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::PosHistYRes

private

Definition at line 55 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::PosHistZRes

private

Definition at line 55 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

larana/v09_15_05/source/larana/OpticalDetector/OpFlashAna_module.cc

Public Types

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation