Extracts PMT activity as optical hits (recob::OpHit). More...

Inheritance diagram for opdet::ICARUSOpHitFinder:

Classes
struct	Config

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

Public Member Functions
	ICARUSOpHitFinder (Parameters const &config, art::ProcessingFrame const &frame)

virtual void	produce (art::Event &, art::ProcessingFrame const &) override

Private Types
using	FWInterfacedPedAlgo = opdet::factory::FWInterfacedIF< pmtana::PMTPedestalBase, ArtTraits >

Private Member Functions
std::vector< sim::BeamGateInfo const * >	fetchBeamGates (art::Event const &event) const
	Optionally reads the beam gates from `fBeamGateTag`, empty if none. More...

std::vector< raw::OpDetWaveform >	selectWaveforms (std::vector< raw::OpDetWaveform > const &waveforms) const
	Returns a vector with copies of only the waveforms not in masked channels. More...

Private Attributes
art::InputTag const	fWaveformTags
	Input PMT waveform data product tags. More...

art::InputTag const	fBeamGateTag

std::vector< unsigned int > const	fChannelMasks
	Sorted list of channels to skip. More...

float const	fHitThreshold
	Hit finding threshold. More...

bool const	fUseStartTime
	Whether to store start instead of peak time. More...

std::unique_ptr < calib::IPhotonCalibrator >	fMyCalib
	Storage for our own calibration algorithm, if any. More...

unsigned int const	fMaxOpChannel
	Number of channels in the detector. More...

calib::IPhotonCalibrator const *	fCalib = nullptr
	The calibration algorithm to be used (not owned). More...

pmtana::PulseRecoManager	fPulseRecoMgr

std::unique_ptr < pmtana::PMTPulseRecoBase > const	fThreshAlg

std::unique_ptr < FWInterfacedPedAlgo > const	fPedAlg

Detailed Description

Extracts PMT activity as optical hits (recob::OpHit).

This module runs hit-finding algorithms, and is tailored to allow for an update of the hit finding parameters event by event.

Motivation

This module is a branch of the standard LArSoft opdet::OpHitFinder by Gleb Sinev, Ben Jones and others. That module itself is an interface to the hit finding mini-framework also in larana, authored by Kazuhiro Terao.

That framework independently analyzes each waveform and performs hit finding using general timing and geometry information (from detinfo::DetectorClocks and geo::GeometryCore service providers), a threshold parameter and configurable algorithms for baseline evaluation, hit finding and calibration.

It is believed that the baseline of ICARUS PMT is remarkably stable in the short time, and it is conceivable to use a single steady value for many waveforms on each channel. Unfortunately the existing module is not suitable for a baseline that may change event by event or in time: the mini-framework does not explicitly allow this, and the module is not equipped with the necessary workarounds.

This module is a replica of LArSoft's, with the additional workarounds needed to allow for a baseline learnt from an external source and changing event by event.

Configuration parameters

The configuration parameters are intentionally left the same as in opdet::OpHitFinder, with a few exceptions and additions where needed.

InputModule (input tag): data product with the optical waveforms to analyze.
GenModule (input tag, mandatory): data product with the beam gate (either generated or from trigger information).
UseStartTime (flag, default: false): store the start time in the hit instead of the peak time.
ChannelMasks (list of channel numbers, default: empty): skip waveforms on the channels specified in this list.
HitAlgoPset (table, mandatory): configuration of the hit finding algorithm; its content depends on the algorithm itself, but the following elements are nonetheless mandatory:
- Name (text): algorithm name; the supported algorithms are hard-coded by name.
PedAlgoPset (table, mandatory): configuration of the pedestal algorithm; its content depends on the algorithm itself, but the following elements are nonetheless mandatory:
- Name (text): algorithm name; the supported algorithms are hard-coded by name.
HitThreshold (real): hit threshold [ADC counts]
UseCalibrator (flag, default: false): if set, use the calibration service configured in the job; otherwise, use the simpler calibration configured in this module (see the following parameters).
AreaToPE (flag): whether the conversion factor goes from hit area (total ADC) or from amplitude (ADC), to photoelectrons.
SPEArea (real): area or amplitude (depending on AreaToPE) of the response signal to a single photoelectron.
SPEShift (real, default: 0)

Noticeable differences with LArSoft's opdet::OpHitFinder configuration:

multiple input collections are not supported, so the InputModule is a complete input tag and no list of instance names can be specified.

Multithreading

In order to support the algorithms that require an event-specific configuration, the module is not shared. While the algorithms could be written to keep track of different event configurations, at the time the algorithms are executed on a waveform they have no mean to know which event the waveforms belong to. Rather than writing complex workarounds on this problem, the module is replicated so that there are multiple algorithms (and multiple managers) but each of them sees an event at a time, in a way that the module (replica) can predict.

Definition at line 202 of file ICARUSOpHitFinder_module.cc.

Member Typedef Documentation

using opdet::ICARUSOpHitFinder::FWInterfacedPedAlgo = opdet::factory::FWInterfacedIF<pmtana::PMTPedestalBase, ArtTraits>

private

Definition at line 312 of file ICARUSOpHitFinder_module.cc.

using opdet::ICARUSOpHitFinder::Parameters = art::ReplicatedProducer::Table<Config>

Definition at line 280 of file ICARUSOpHitFinder_module.cc.

Constructor & Destructor Documentation

opdet::ICARUSOpHitFinder::ICARUSOpHitFinder	(	Parameters const &	config,
		art::ProcessingFrame const &	frame
	)

explicit

Definition at line 484 of file ICARUSOpHitFinder_module.cc.

   : art::ReplicatedProducer{ params, frame }
   // configuration
   , fWaveformTags{ params().InputModule() }
   , fBeamGateTag{ params().GenModule().value_or(art::InputTag{}) }
   , fChannelMasks{ sortedVector(params().ChannelMasks()) }
   , fHitThreshold{ params().HitThreshold() }
   , fUseStartTime{ params().UseStartTime() }
   // caches
   , fMaxOpChannel{ frame.serviceHandle<geo::Geometry>()->MaxOpChannel() }
   // algorithms
   , fPulseRecoMgr{}
   , fThreshAlg
     { HitAlgoFactory.create(params().HitAlgoPset.get<fhicl::ParameterSet>()) }
   , fPedAlg
     { PedAlgoFactory.create(params().PedAlgoPset.get<fhicl::ParameterSet>()) }
 {
   
   //
   // declaration of input
   //
   consumes<std::vector<raw::OpDetWaveform>>(fWaveformTags);
   if (!fBeamGateTag.empty())
     mayConsume<std::vector<sim::BeamGateInfo>>(fBeamGateTag);
   
   //
   // calibration initialization
   //
   if (params().UseCalibrator()) {
     fCalib = frame.serviceHandle<calib::IPhotonCalibratorService>()->provider();
   }
   else {
     fMyCalib = std::make_unique<calib::PhotonCalibratorStandard>(
         params().AreaToPE()
       , params().SPEArea()
       , params().SPEShift()
       );
     fCalib = fMyCalib.get();
   } // if ... else
   
   //
   // register the algorithms in the manager
   //
   fPulseRecoMgr.AddRecoAlgo(fThreshAlg.get());
   fPulseRecoMgr.SetDefaultPedAlgo(&(fPedAlg->algo()));
   
   // framework hooks to the algorithms
   if (!fChannelMasks.empty() && (fPedAlg->algo().Name() == "Fixed")) {
     /* TODO
      * The reason why this is not working is complicate.
      * The interface of ophit mini-framework is quite minimal and tight,
      * it accepts only `std::vector<short>` input and nothing more.
      * The whole reason of this module is to overcome that limitation;
      * since there is no channel information, we have to guess which channel
      * this is the data of, and the way we do it is by address of the data;
      * `raw::OpDetWaveform` derives from `std::vector<short>`, so when we use
      * the original data product, the waveform data `std::vector<short>` is
      * actually the same object and we can compare with the address of the data
      * product, which we have because of the framework hooks here introduced;
      * but if the `ChannelMasks` is not empty, we are forced to copy the
      * original data in a new location (excluding the masked channels) and the
      * new data has a different address. In principle we could still try to
      * look for which `raw::OpDetWaveform` data product has the same content as
      * the `std::vector<short>` we were given, which may be a bit tedious
      * (thousand of vector comparisons to do, although all except the target one
      * will be short because the noise pattern are different).
      */
     throw art::Exception{ art::errors::Configuration }
       << "Pedestal algorithm \"Fixed\" will not work"
       " since a channel mask list is specified.\n";
   }
   fPedAlg->initialize(consumesCollector());
   
   //
   // declare output products
   //
   produces<std::vector<recob::OpHit>>();
 
 } // opdet::ICARUSOpHitFinder::ICARUSOpHitFinder()

Member Function Documentation

std::vector< sim::BeamGateInfo const * > opdet::ICARUSOpHitFinder::fetchBeamGates ( art::Event const & event ) const

private

Optionally reads the beam gates from fBeamGateTag, empty if none.

Definition at line 637 of file ICARUSOpHitFinder_module.cc.

 {
   std::vector<const sim::BeamGateInfo*> beamGateArray;
   if (fBeamGateTag.empty()) return beamGateArray;
   try {
     event.getView(fBeamGateTag, beamGateArray);
   }
   catch (art::Exception const& err) {
     if (err.categoryCode() != art::errors::ProductNotFound) throw;
   }
   return beamGateArray;
 } // opdet::ICARUSOpHitFinder::fetchBeamGates()

void opdet::ICARUSOpHitFinder::produce	(	art::Event &	event,
		art::ProcessingFrame const &	frame
	)

overridevirtual

Definition at line 567 of file ICARUSOpHitFinder_module.cc.

 {
 
   //
   // read and select the waveforms
   //
   auto const& allWaveforms
     = event.getProduct<std::vector<raw::OpDetWaveform>>(fWaveformTags);
   
   // this pointer owns the waveforms only if they come from `selectWaveforms()`
 //   MaybeOwnerPtr<std::vector<raw::OpDetWaveform> const> waveforms
 //     = fChannelMasks.empty()? &allWaveforms: selectWaveforms(allWaveforms);
   using WaveformsPtr_t = MaybeOwnerPtr<std::vector<raw::OpDetWaveform> const>;
   WaveformsPtr_t waveforms = fChannelMasks.empty()
     ? WaveformsPtr_t{ &allWaveforms }
     : WaveformsPtr_t{ selectWaveforms(allWaveforms) }
     ;
   
   if (fChannelMasks.empty() && (&allWaveforms != &*waveforms)) {
     // if this happens, contact the author
     throw art::Exception{ art::errors::LogicError }
       << "Bug in MaybeOwnerPtr!\n";
   }
   assert(fChannelMasks.empty() || (&allWaveforms == &*waveforms));
   
   //
   // run the algorithm
   //
   
   // framework hooks to the algorithms
   fPedAlg->beginEvent(event);
   
   std::vector<sim::BeamGateInfo const*> const beamGateArray
     = fetchBeamGates(event);
 
   auto const& geom = *(frame.serviceHandle<geo::Geometry>()->provider());
   auto const clockData
     = frame.serviceHandle<detinfo::DetectorClocksService const>()
       ->DataFor(event)
     ;
   
   std::vector<recob::OpHit> opHits;
 
   RunHitFinder(
     *waveforms, opHits,
     fPulseRecoMgr, *fThreshAlg,
     geom,
     fHitThreshold,
     clockData,
     *fCalib,
     fUseStartTime
     );
   
   mf::LogInfo{ "ICARUSOpHitFinder" }
     << "Found " << opHits.size() << " hits from " << waveforms->size()
     << " waveforms.";
   
   // framework hooks to the algorithms
   fPedAlg->endEvent(event);
   
   //
   // store results into the event
   //
   event.put(std::make_unique<std::vector<recob::OpHit>>(std::move(opHits)));
   
 } // opdet::ICARUSOpHitFinder::produce()

std::vector< raw::OpDetWaveform > opdet::ICARUSOpHitFinder::selectWaveforms ( std::vector< raw::OpDetWaveform > const & waveforms ) const

private

Returns a vector with copies of only the waveforms not in masked channels.

Definition at line 653 of file ICARUSOpHitFinder_module.cc.

 {
   std::vector<raw::OpDetWaveform> selected;
   
   auto const isNotMasked = [this](raw::OpDetWaveform const& waveform)
     {
       return !std::binary_search
         (fChannelMasks.begin(), fChannelMasks.end(), waveform.ChannelNumber());
     };
   
   std::copy_if
     (waveforms.begin(), waveforms.end(), back_inserter(selected), isNotMasked);
   
   return selected;
 } // selectWaveforms()