opdet::OpFlashAna Class Reference

Inheritance diagram for opdet::OpFlashAna:

Public Types
using	WorkerType = WorkerT< EDAnalyzer >
using	ModuleType = EDAnalyzer

Public Member Functions
	OpFlashAna (const fhicl::ParameterSet &)
virtual	~OpFlashAna ()
void	beginJob ()
void	analyze (const art::Event &)
std::string	workerType () const
bool	modifiesEvent () const
void	registerProducts (MasterProductRegistry &, ProductDescriptions &, ModuleDescription const &)
std::string const &	processName () const
bool	wantAllEvents () const
bool	wantEvent (Event const &e)
fhicl::ParameterSetID	selectorConfig () const
art::Handle< art::TriggerResults >	getTriggerResults (Event const &e) const
template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)
template<typename T , art::BranchType BT>
art::ProductToken< T >	consumes (InputTag const &it)
template<typename T , BranchType = InEvent>
void	consumesMany ()
template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)
template<typename T , art::BranchType BT>
art::ViewToken< T >	consumesView (InputTag const &it)
template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)
template<typename T , art::BranchType BT>
art::ProductToken< T >	mayConsume (InputTag const &it)
template<typename T , BranchType = InEvent>
void	mayConsumeMany ()
template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)
template<typename T , art::BranchType BT>
art::ViewToken< T >	mayConsumeView (InputTag const &it)
base_engine_t &	createEngine (seed_t seed)
base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make)
base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make, label_t const &engine_label)
seed_t	get_seed_value (fhicl::ParameterSet const &pset, char const key[]="seed", seed_t const implicit_seed=-1)

Static Public Member Functions
static cet::exempt_ptr< Consumer >	non_module_context ()

Protected Member Functions
CurrentProcessingContext const *	currentContext () const
detail::CachedProducts &	cachedProducts ()
void	validateConsumedProduct (BranchType const bt, ProductInfo const &pi)
void	prepareForJob (fhicl::ParameterSet const &pset)
void	showMissingConsumes () const

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
Float_t	fFlashTime
Float_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
Float_t	fPeakTimeAbs
Float_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< float >	fFlashTimeVector
std::vector< float >	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 49 of file OpFlashAna_module.cc.

Member Typedef Documentation

using art::EDAnalyzer::ModuleType = EDAnalyzer

inherited

Definition at line 39 of file EDAnalyzer.h.

using art::EDAnalyzer::WorkerType = WorkerT<EDAnalyzer>

inherited

Definition at line 38 of file EDAnalyzer.h.

Constructor & Destructor Documentation

opdet::OpFlashAna::OpFlashAna

(

const fhicl::ParameterSet &

)

Definition at line 145 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(), art::TFileDirectory::make(), 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> odp;
//    fTimeBegin  = odp->TimeBegin();
//    fTimeEnd    = odp->TimeEnd();
//    fSampleFreq = odp->SampleFreq();

    auto const* timeService = lar::providerFrom<detinfo::DetectorClocksService>();
    fTimeBegin  = timeService->OpticalClock().Time();
    fTimeEnd    = timeService->OpticalClock().FramePeriod();
    fSampleFreq = timeService->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 > 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/F");
      fFlashBreakdownTree->Branch("NPe",        &fNPe,         "NPe/F");
      fFlashBreakdownTree->Branch("AbsTime",    &fAbsTime,     "AbsTime/F");
      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/F");
      fPerOpHitTree->Branch("PeakTime",    &fPeakTime,     "PeakTime/F");
      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/F");
      fPerFlashTree->Branch("AbsTime",    &fAbsTime,     "AbsTime/F");
      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/F");
      fFlashHitMatchTree->Branch("FlashTime",     &fFlashTime,  "FlashTime/F");
      fFlashHitMatchTree->Branch("HitFrame",      &fFrame,      "HitFrame/I");
      fFlashHitMatchTree->Branch("FlashFrame",    &fFlashFrame, "FlashFrame/I");
    }
    
    fFlashID = 0;
  }

opdet::OpFlashAna::~OpFlashAna ( )

virtual

Definition at line 280 of file OpFlashAna_module.cc.

  {}

Member Function Documentation

void opdet::OpFlashAna::analyze

(

const art::Event &

evt

)

Definition at line 288 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::DataViewImpl::getByLabel(), art::Event::id(), recob::OpFlash::InBeamFrame(), art::TFileDirectory::make(), 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 > 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 > 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();
    }

  }

void opdet::OpFlashAna::beginJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 284 of file OpFlashAna_module.cc.

  {}

detail::CachedProducts& art::EventObserverBase::cachedProducts ( )

inlineprotectedinherited

Definition at line 79 of file EventObserverBase.h.

References art::EventObserverBase::selectors_.

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

  {
    return selectors_;
  }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::consumes ( InputTag const &  it )

inherited

Definition at line 147 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

{
  if (!moduleContext_)
    return ProductToken<T>::invalid();

  consumables_[BT].emplace_back(ConsumableType::Product,
                                TypeID{typeid(T)},
                                it.label(),
                                it.instance(),
                                it.process());
  return ProductToken<T>{it};
}

template<typename T , art::BranchType BT>

void art::Consumer::consumesMany ( )

inherited

Definition at line 162 of file Consumer.h.

{
  if (!moduleContext_)
    return;

  consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
}

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::consumesView ( InputTag const &  it )

inherited

Definition at line 172 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

{
  if (!moduleContext_)
    return ViewToken<T>::invalid();

  consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                TypeID{typeid(T)},
                                it.label(),
                                it.instance(),
                                it.process());
  return ViewToken<T>{it};
}

EngineCreator::base_engine_t & EngineCreator::createEngine ( seed_t  seed )

inherited

Definition at line 26 of file EngineCreator.cc.

References art::EngineCreator::rng().

Referenced by evgen::CosmicsGen::CosmicsGen(), rndm::NuRandomService::createEngine(), cluster::fuzzyCluster::fuzzyCluster(), cluster::HoughLineFinder::HoughLineFinder(), art::MixFilter< T >::initEngine_(), larg4::LArG4::LArG4(), evgen::LightSource::LightSource(), evgen::NeutronOsc::NeutronOsc(), evgen::NucleonDecay::NucleonDecay(), opdet::OpMCDigi::OpMCDigi(), opdet::OptDetDigitizer::OptDetDigitizer(), phot::PhotonLibraryPropagation::PhotonLibraryPropagation(), detsim::SimDriftElectrons::SimDriftElectrons(), evgen::SingleGen::SingleGen(), evgen::SNNueAr40CCGen::SNNueAr40CCGen(), ToyOneShowerGen::ToyOneShowerGen(), and trkf::Track3DKalman::Track3DKalman().

{
  return rng()->createEngine(placeholder_schedule_id(), seed);
}

EngineCreator::base_engine_t & EngineCreator::createEngine ( seed_t  seed, std::string const &  kind_of_engine_to_make  )

inherited

Definition at line 32 of file EngineCreator.cc.

References art::EngineCreator::rng().

{
  return rng()->createEngine(
    placeholder_schedule_id(), seed, kind_of_engine_to_make);
}

EngineCreator::base_engine_t & EngineCreator::createEngine ( seed_t  seed, std::string const &  kind_of_engine_to_make, label_t const &  engine_label  )

inherited

Definition at line 40 of file EngineCreator.cc.

References art::EngineCreator::rng().

{
  return rng()->createEngine(
    placeholder_schedule_id(), seed, kind_of_engine_to_make, engine_label);
}

CurrentProcessingContext const * art::EDAnalyzer::currentContext ( ) const

protectedinherited

Definition at line 114 of file EDAnalyzer.cc.

References art::EDAnalyzer::current_context_.

Referenced by art::EDAnalyzer::workerType().

  {
    return current_context_.get();
  }

EngineCreator::seed_t EngineCreator::get_seed_value ( fhicl::ParameterSet const &  pset, char const  key[] = "seed", seed_t const  implicit_seed = -1  )

inherited

Definition at line 49 of file EngineCreator.cc.

References fhicl::ParameterSet::get().

Referenced by art::MixFilter< T >::initEngine_().

{
  auto const& explicit_seeds = pset.get<std::vector<int>>(key, {});
  return explicit_seeds.empty() ? implicit_seed : explicit_seeds.front();
}

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

inlineinherited

Definition at line 61 of file EventObserverBase.h.

References art::detail::CachedProducts::getOneTriggerResults(), and art::EventObserverBase::selectors_.

Referenced by art::OutputModule::doWriteEvent().

  {
    return selectors_.getOneTriggerResults(e);
  }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::mayConsume ( InputTag const &  it )

inherited

Definition at line 190 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

{
  if (!moduleContext_)
    return ProductToken<T>::invalid();

  consumables_[BT].emplace_back(ConsumableType::Product,
                                TypeID{typeid(T)},
                                it.label(),
                                it.instance(),
                                it.process());
  return ProductToken<T>{it};
}

template<typename T , art::BranchType BT>

void art::Consumer::mayConsumeMany ( )

inherited

Definition at line 205 of file Consumer.h.

{
  if (!moduleContext_)
    return;

  consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
}

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::mayConsumeView ( InputTag const &  it )

inherited

Definition at line 215 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

{
  if (!moduleContext_)
    return ViewToken<T>::invalid();

  consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                TypeID{typeid(T)},
                                it.label(),
                                it.instance(),
                                it.process());
  return ViewToken<T>{it};
}

bool art::EventObserverBase::modifiesEvent ( ) const

inlineinherited

Definition at line 25 of file EventObserverBase.h.

  {
    return false;
  }

cet::exempt_ptr< art::Consumer > art::Consumer::non_module_context ( )

staticinherited

Definition at line 76 of file Consumer.cc.

Referenced by art::RootOutput::beginSubRun(), art::OutputModule::doBeginRun(), art::OutputModule::doBeginSubRun(), art::OutputModule::doEndRun(), art::OutputModule::doEndSubRun(), art::ProducingService::doPostReadEvent(), art::ProducingService::doPostReadRun(), art::ProducingService::doPostReadSubRun(), art::OutputModule::doWriteEvent(), art::ProcessPackage< L >::postScheduleSignal(), art::BeginEndPackage< Level::Run >::Begin::postScheduleSignal(), art::BeginEndPackage< Level::Run >::End::postScheduleSignal(), art::BeginEndPackage< Level::SubRun >::Begin::postScheduleSignal(), art::BeginEndPackage< Level::SubRun >::End::postScheduleSignal(), art::ProcessPackage< L >::preScheduleSignal(), art::BeginEndPackage< Level::Run >::Begin::preScheduleSignal(), art::BeginEndPackage< Level::SubRun >::Begin::preScheduleSignal(), art::EventProcessor::readEvent(), art::EventProcessor::readRun(), art::EmptyEvent::readRun_(), art::EventProcessor::readSubRun(), and art::EmptyEvent::readSubRun_().

{
  static Consumer invalid{InvalidTag{}};
  return &invalid;
}

void art::Consumer::prepareForJob ( fhicl::ParameterSet const &  pset )

protectedinherited

Definition at line 89 of file Consumer.cc.

References fhicl::ParameterSet::get_if_present().

Referenced by art::EDProducer::doBeginJob(), art::EDFilter::doBeginJob(), and art::EDAnalyzer::doBeginJob().

{
  if (!moduleContext_)
    return;

  pset.get_if_present("errorOnMissingConsumes", requireConsumes_);
  for (auto& consumablesPerBranch : consumables_) {
    cet::sort_all(consumablesPerBranch);
  }
}

std::string const& art::EventObserverBase::processName ( ) const

inlineinherited

Definition at line 41 of file EventObserverBase.h.

References art::EventObserverBase::process_name_.

Referenced by art::FileDumperOutput::printPrincipal(), and art::RootOutput::RootOutput().

  {
    return process_name_;
  }

void art::EventObserverBase::registerProducts ( MasterProductRegistry &  , ProductDescriptions &  , ModuleDescription const &    )

inlineinherited

Definition at line 33 of file EventObserverBase.h.

  {}

fhicl::ParameterSetID art::EventObserverBase::selectorConfig ( ) const

inlineinherited

Definition at line 56 of file EventObserverBase.h.

References art::EventObserverBase::selector_config_id_.

Referenced by art::RootOutputFile::writeOne().

  {
    return selector_config_id_;
  }

void art::Consumer::showMissingConsumes ( ) const

protectedinherited

Definition at line 125 of file Consumer.cc.

Referenced by art::EDProducer::doEndJob(), art::EDFilter::doEndJob(), art::EDAnalyzer::doEndJob(), and art::RootOutput::endJob().

{
  if (!moduleContext_)
    return;

  // If none of the branches have missing consumes statements, exit early.
  if (std::all_of(cbegin(missingConsumes_),
                  cend(missingConsumes_),
                  [](auto const& perBranch) { return perBranch.empty(); }))
    return;

  constexpr cet::HorizontalRule rule{60};
  mf::LogPrint log{"MTdiagnostics"};
  log << '\n'
      << rule('=') << '\n'
      << "The following consumes (or mayConsume) statements are missing from\n"
      << module_context(moduleDescription_) << '\n'
      << rule('-') << '\n';

  cet::for_all_with_index(
    missingConsumes_, [&log](std::size_t const i, auto const& perBranch) {
      for (auto const& pi : perBranch) {
        log << "  "
            << assemble_consumes_statement(static_cast<BranchType>(i), pi)
            << '\n';
      }
    });
  log << rule('=');
}

void art::Consumer::validateConsumedProduct ( BranchType const  bt, ProductInfo const &  pi  )

protectedinherited

Definition at line 101 of file Consumer.cc.

References art::errors::ProductRegistrationFailure.

{
  // Early exits if consumes tracking has been disabled or if the
  // consumed product is an allowed consumable.
  if (!moduleContext_)
    return;

  if (cet::binary_search_all(consumables_[bt], pi))
    return;

  if (requireConsumes_) {
    throw Exception(errors::ProductRegistrationFailure,
                    "Consumer: an error occurred during validation of a "
                    "retrieved product\n\n")
      << "The following consumes (or mayConsume) statement is missing from\n"
      << module_context(moduleDescription_) << ":\n\n"
      << "  " << assemble_consumes_statement(bt, pi) << "\n\n";
  }

  missingConsumes_[bt].insert(pi);
}

bool art::EventObserverBase::wantAllEvents ( ) const

inlineinherited

Definition at line 46 of file EventObserverBase.h.

References art::EventObserverBase::wantAllEvents_.

Referenced by art::EDAnalyzer::doEvent(), art::OutputModule::doEvent(), art::OutputModule::doWriteEvent(), art::RootOutput::RootOutput(), and art::OutputWorker::wantAllEvents().

  {
    return wantAllEvents_;
  }

bool art::EventObserverBase::wantEvent ( Event const &  e )

inlineinherited

Definition at line 51 of file EventObserverBase.h.

References art::EventObserverBase::selectors_, and art::detail::CachedProducts::wantEvent().

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

  {
    return selectors_.wantEvent(e);
  }

std::string art::EDAnalyzer::workerType ( ) const

inlineinherited

Definition at line 109 of file EDAnalyzer.h.

References art::EDAnalyzer::currentContext().

    {
      return "WorkerT<EDAnalyzer>";
    }

Member Data Documentation

Float_t opdet::OpFlashAna::fAbsTime

private

Definition at line 99 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 128 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fAmplitude

private

Definition at line 117 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fArea

private

Definition at line 116 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fEventID

private

Definition at line 95 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fFastToTotal

private

Definition at line 119 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fFlashBreakdownTree

private

Definition at line 92 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fFlashFrame

private

Definition at line 103 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 129 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fFlashHitMatchTree

private

Definition at line 93 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fFlashID

private

Definition at line 96 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 122 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fFlashTime

private

Definition at line 98 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 127 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fFrame

private

Definition at line 114 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fHitID

private

Definition at line 97 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fInBeamFrame

private

Definition at line 100 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 130 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakeFlashBreakdownTree

private

Definition at line 86 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakeFlashHitMatchTree

private

Definition at line 87 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakeFlashPosHist

private

Definition at line 80 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakeFlashTimeHist

private

Definition at line 79 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakePerEventFlashTree

private

Definition at line 83 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakePerFlashHists

private

Definition at line 81 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakePerFlashTree

private

Definition at line 84 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

bool opdet::OpFlashAna::fMakePerOpHitTree

private

Definition at line 85 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::fNChannels

private

Definition at line 133 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::fNFlashes

private

Definition at line 121 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fNPe

private

Definition at line 105 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::fOnBeamTime

private

Definition at line 101 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 131 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Int_t opdet::OpFlashAna::fOpChannel

private

Definition at line 111 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::string opdet::OpFlashAna::fOpFlashModuleLabel

private

Definition at line 69 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

std::string opdet::OpFlashAna::fOpHitModuleLabel

private

Definition at line 70 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fPE

private

Definition at line 118 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fPeakTime

private

Definition at line 113 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fPeakTimeAbs

private

Definition at line 112 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fPerEventFlashTree

private

Definition at line 89 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fPerFlashTree

private

Definition at line 90 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

TTree* opdet::OpFlashAna::fPerOpHitTree

private

Definition at line 91 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 134 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fSampleFreq

private

Definition at line 71 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fTimeBegin

private

Definition at line 72 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fTimeEnd

private

Definition at line 73 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fTotalPE

private

Definition at line 102 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 132 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fWidth

private

Definition at line 115 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fYCenter

private

Definition at line 106 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 123 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fYMax

private

Definition at line 75 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fYMin

private

Definition at line 75 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fYWidth

private

Definition at line 107 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 125 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fZCenter

private

Definition at line 108 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 124 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fZMax

private

Definition at line 75 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

float opdet::OpFlashAna::fZMin

private

Definition at line 75 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

Float_t opdet::OpFlashAna::fZWidth

private

Definition at line 109 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

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

private

Definition at line 126 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::PosHistYRes

private

Definition at line 77 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

int opdet::OpFlashAna::PosHistZRes

private

Definition at line 77 of file OpFlashAna_module.cc.

Referenced by analyze(), and OpFlashAna().

---

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

• larana/v06_21_01/source/larana/OpticalDetector/OpFlashAna_module.cc