icarus::trigger::SlidingWindowTriggerEfficiencyPlots Class Reference

Produces plots about trigger simulation and trigger efficiency. More...

Inheritance diagram for icarus::trigger::SlidingWindowTriggerEfficiencyPlots:

Classes
struct	Config

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

Public Member Functions
	SlidingWindowTriggerEfficiencyPlots (Parameters const &config)
virtual void	beginJob () override
	Initializes the plots. More...
virtual void	analyze (art::Event const &event) override
	Fills the plots. Also extracts the information to fill them with. More...
virtual void	endJob () override
	Prints end-of-job summaries. More...

Private Types
using	WindowPatterns_t = icarus::trigger::WindowPatterns_t
	List of configured patterns. More...
using	TriggerInfo_t = details::TriggerInfo_t
using	WindowTriggerInfo_t = icarus::trigger::SlidingWindowPatternAlg::AllTriggerInfo_t
	Data structure to communicate internally a trigger response. More...
Private Types inherited from icarus::trigger::TriggerEfficiencyPlotsBase
using	microseconds = util::quantities::intervals::microseconds
using	nanoseconds = util::quantities::intervals::nanoseconds
using	EventInfo_t = details::EventInfo_t
using	PMTInfo_t = details::PMTInfo_t
using	TriggerInfo_t = details::TriggerInfo_t
using	PlotSandbox = icarus::trigger::PlotSandbox
	Import type. More...
using	PlotSandboxRefs_t = std::vector< std::reference_wrapper< PlotSandbox const >>
	List of references to plot sandboxes. More...
using	PlotCategories_t = std::vector< PlotCategory >
using	InputTriggerGate_t = icarus::trigger::TrackedOpticalTriggerGate< sbn::OpDetWaveformMeta >
	Type of trigger gate extracted from the input event. More...
using	TriggerGates_t = std::vector< InputTriggerGate_t >
	A list of trigger gates from input. More...
using	TriggerGatesPerCryostat_t = std::vector< TriggerGates_t >
	Type of lists of gates, one list per cryostat (outer index: cryostat no). More...
using	ChannelID_t = InputTriggerGate_t::TriggerGate_t::ChannelID_t
	Type representing the unique identifier of a optical detector channel. More...

Private Member Functions
virtual void	initializePlotSet (PlotSandbox &plots, std::vector< SettingsInfo_t > const &settings) const override
	Initializes full set of plots for (ADC threshold + category). More...
virtual void	simulateAndPlot (std::size_t const thresholdIndex, TriggerGatesPerCryostat_t const &gates, EventInfo_t const &eventInfo, detinfo::DetectorClocksData const &clockData, PlotSandboxRefs_t const &selectedPlots) override
	Simulates all trigger minimum requirements plots the results. More...
void	plotResponse (std::size_t iThr, std::string const &threshold, std::size_t iPattern, WindowPattern const &pattern, PlotSandboxRefs_t const &plotSets, EventInfo_t const &eventInfo, PMTInfo_t const &PMTinfo, WindowTriggerInfo_t const &triggerInfo) const
	Fills plots with the specified trigger response. More...
void	initializePatternAlgorithms ()
void	fillAllEventPlots (PlotSandboxRefs_t const &plotSets, EventInfo_t const &eventInfo) const
	Fills all event plots with data from eventInfo as in fillEventPlots(). More...
void	fillAllPMTplots (PlotSandboxRefs_t const &plotSets, PMTInfo_t const &PMTinfo) const
	Fills all PMY plots with data from PMTinfo as in fillPMTplots(). More...
SlidingWindowTriggerEfficiencyPlots const &	helper () const
	Access to the helper. More...
SlidingWindowTriggerEfficiencyPlots &	helper ()
Private Member Functions inherited from icarus::trigger::TriggerEfficiencyPlotsBase
	TriggerEfficiencyPlotsBase (Config const &config, art::ConsumesCollector &consumer)
	Constructor; requires a configuration and module's consumesCollector(). More...
void	process (art::Event const &event)
	Fills the plots. Also extracts the information to fill them with. More...
void	printSummary () const
	Prints end-of-job summaries. More...
std::string const &	logCategory () const
	Returns the name of the log category. More...
TTree *	eventTree ()
	Returns a pointer to the tree where event information is written. More...
bool	useGen () const
	Returns whether we are using and filling generator information. More...
bool	useEDep () const
	Returns whether we are using and filling energy deposition information. More...
std::size_t	nADCthresholds () const
	Returns the number of configured PMT thresholds. More...
auto	ADCthresholds () const
	Returns a iterable sequence of all configured PMT thresholds. More...
std::string const &	ADCthresholdTag (std::size_t iThr) const
geo::GeometryCore const &	geometry () const
	Returns the detector geometry service provider. More...
nanoseconds	triggerTimeResolution () const
	Returns the resolution of trigger timing clock [ns]. More...
virtual void	initializePlots (PlotCategories_t categories, std::vector< SettingsInfo_t > const &settings)
	Initializes all the plot sets, one per PMT threshold. More...
void	initializePlots (std::vector< SettingsInfo_t > const &settings)
	Initializes sets of default plots, one per PMT threshold. More...
virtual void	initializeEfficiencyPerTriggerPlots (PlotSandbox &plots) const
	Initializes set of plots per complete trigger definition into plots. More...
virtual void	initializeEventPlots (PlotSandbox &plots) const
	Initializes a single, trigger-independent plot set into plots. More...
virtual void	initializePMTplots (PlotSandbox &plots) const
virtual bool	shouldPlotEvent (EventInfo_t const &eventInfo) const
virtual void	fillEventPlots (EventInfo_t const &eventInfo, PlotSandbox const &plots) const
	Fills the plots (initializeEventPlots()) with info from eventInfo. More...
virtual void	fillPMTplots (PMTInfo_t const &PMTinfo, PlotSandbox const &plots) const
	Fill the plots (initializePMTplots()) with info from PMTinfo. More...
virtual void	fillEfficiencyPlots (EventInfo_t const &eventInfo, TriggerInfo_t const &triggerInfo, PlotSandbox const &plots) const
virtual void	fillAllEfficiencyPlots (EventInfo_t const &eventInfo, PMTInfo_t const &PMTinfo, TriggerInfo_t const &triggerInfo, PlotSandbox const &plots) const
void	deleteEmptyPlots ()
	Deletes plots with no entries, and directories which became empty. More...
std::size_t	createCountersForPattern (std::string const &patternName)
	Creates counters for all the thresholds of the specified trigger. More...
GatePack_t	makeGatePack (art::Event const *event=nullptr) const
	Creates a GatePack_t from the specified event. More...
void	registerTriggerResult (std::size_t threshold, std::size_t pattern, bool fired)
	Registers the outcome of the specified trigger. More...
void	registerTriggerResult (std::size_t threshold, std::size_t pattern, TriggerInfo_t const &triggerInfo)
icarus::trigger::ApplyBeamGateClass	makeMyBeamGate (detinfo::DetectorClocksData const &clockData) const
	Shortcut to create an ApplyBeamGate with the current configuration. More...
icarus::trigger::ApplyBeamGateClass	makeMyBeamGate (art::Event const *event=nullptr) const
icarus::trigger::ApplyBeamGateClass	makeMyBeamGate (art::Event const &event) const

Private Attributes
WindowPatterns_t const	fPatterns
	Configured sliding window requirement patterns. More...
icarus::trigger::WindowTopologyManager	fWindowMapMan
	Mapping of each sliding window with location and topological information. More...
std::vector < icarus::trigger::SlidingWindowPatternAlg >	fPatternAlgs
	All algorithm instances, one per pattern. More...
std::unique_ptr< ResponseTree >	fResponseTree
	Handler of ROOT tree output. More...

Additional Inherited Members
Static Private Member Functions inherited from icarus::trigger::TriggerEfficiencyPlotsBase
static std::vector< ChannelID_t >	extractActiveChannels (TriggerGatesPerCryostat_t const &cryoGates)
	Returns all channels contributing to the trigger gates. More...
Static Private Attributes inherited from icarus::trigger::TriggerEfficiencyPlotsBase
static PlotCategories_t const	DefaultPlotCategories
	List of event categories. More...

Detailed Description

Produces plots about trigger simulation and trigger efficiency.

This module is an implementation of TriggerEfficiencyPlotsBase for a trigger defined as a pattern of sliding windows.

Note that the multi-level logical waveforms from the sliding windows are expected to be provided as input.

The single sliding window with the highest activity is picked as a reference. A requirement on the number of trigger primitives "on" in that window is imposed. Additional requirements may be imposed on three other sliding windows: the upstream one (if any), the downstream one (if any) and the opposite one in the same cryostat.

As usual for TriggerEfficiencyPlotsBase based modules, this happens for every configured PMT discrimination threshold.

Trigger logic algorithm

This section describes the trigger logic algorithm used in icarus::trigger::SlidingWindowTriggerEfficiencyPlots and its assumptions.

The module receives as input a multi-level trigger gate for each of the windows to be considered. On the first input (i.e. the first event), that input is parsed to learn the windows and their relative position from the input trigger gates (initializeTopologicalMaps()). This topology will be used to apply the configured patterns. On the following events, their input is checked to confirm the compatibility of the composition of its windows with the one from that first event (verifyTopologicalMap()).

All multi-level gates are set in coincidence with the beam gate by multiplying the multi-level and the beam gates. Beacuse of this, trigger gates are suppressed everywhere except than during the beam gate. The beam gate opens at a time configured in DetectorClocks service provider (detinfo::DetectorClocks::BeamGateTime()) and has a duration configured in this module (BeamGateDuration).

The algorithm handles independently multiple trigger patterns. On each input, each configured pattern is applied based on the window topology. Each pattern describes a minimum level of the trigger gate in the window, that usually means the number of LVDS signals in coincidence at any given time ("majority"). A pattern may have requirements on the neighbouring windows in addition to the main one. The pattern is satisfied if all involved windows pass their specific requirements at the same time (coincidence between windows). Each pattern is applied in turn to each of the windows (which is the "main" window). The neighborhood described in the pattern is applied with respect to that main window. The method applyWindowPattern() performs this combination. The trigger fires if one or more of the windows satisfy the pattern, and the trigger time is the one of the earliest satisfied pattern (more precisely, the earliest tick when the coincidence required by that pattern is satisfied).

All windows in the detector are considered independently, but the supported patterns may only include components in the same cryostat. Therefore, triggers are effectively on a single cryostat.

Eventually, for each event there are as many different trigger responses as how many different patterns are configured (Patterns configuration parameter), times how many ADC thresholds are provided in input, configured in Thresholds.

While there is a parameter describing the time resolution of the trigger (TriggerTimeResolution), this is currently only used for aesthetic purposes to choose the binning of some plots: the resolution is not superimposed to the gates (yet).

The set of plots and their organization are described in the documentation of icarus::trigger::TriggerEfficiencyPlotsBase. In the following documentation only the additions are described.

Output plots

A generic "setting" of icarus::trigger::TriggerEfficiencyPlotsBase is in this module represented by a tag encoding the characteristics of the pattern (see WindowPattern::tag()). The folders and plots will identify each requirement with tags like M8 or M5O2.

There are different "types" of plots. Some do not depend on triggering at all, like the deposited energy distribution. Others cross different trigger definitions, like the trigger efficiency as function of trigger requirement. Others still assume a single trigger definition: this is the case of trigger efficiency plots versus energy. Finally, there are plots that depend on a specific trigger definition and outcome: this is the case of all the plots including only triggering or non-triggering events.

There are a few plots that are produced by this module in addition to the ones in TriggerEfficiencyPlotsBase. They are described below.

All the plots are always relative to a specific optical detector channel threshold (ADC) and a broad event category.

Plots independent of the triggers (selection plots)

Only the standard plots from TriggerEfficiencyPlotsBase are produced in this category.

Plots including different trigger requirements

In addition to the plots from TriggerEfficiencyPlotsBase, the following plots are also produced:

• Eff: trigger efficiency defined as number of triggered events over the total number of events, as function of the pattern (as encoded above); uncertainties are managed by TEfficiency.
• Triggers: trigger count as function of the pattern (as encoded above).
• TriggerTick: distribution of the time of the earliest trigger for the event, as function of the pattern (as in Eff). Each event appears at most once for each trigger pattern.

Plots depending on a specific trigger definition

Only the standard plots from TriggerEfficiencyPlotsBase are produced in this category.

Plots depending on a specific trigger definition and response

Only the standard plots from TriggerEfficiencyPlotsBase are produced in this category.

Configuration parameters

In addition to all the configuration parameters from TriggerEfficiencyPlotsBase, the following one is also present:

• Patterns (list of pattern specifications, mandatory): a list of alternative pattern requirements for the definition of a trigger; each value is a table on its own, with the following elements:
  • inMainWindow (integer, mandatory): the minimum number of primitives to be fired in the central ("main") window of the pattern
  • inDownstreamWindow (integer, default: 0): the minimum number of primitives to be fired in the window downstream of the main one (downstream is farther from the face beam neutrinos enter the detector through, i.e. larger z)
  • inUpstreamWindow (integer, default: 0): the minimum number of primitives to be fired in the window upstream of the main one (upstream is closer to the face beam neutrinos enter the detector through, i.e. smaller z)
  • inOppositeWindow (integer, default: 0): the minimum number of primitives to be fired in the window opposite to the main one
  • requireDownstreamWindow (flag, default: false): if set, this pattern is applied only on main windows that have a window downstream of them, i.e. farther from the face of the detector the beam enters through (larger z coordinate); if set to false, if a main window has no downstream window, the downstream window requirement is always considered passed
  • requireUpstreamWindow (flag, default: false): if set, this pattern is applied only on main windows that have a window upstream of them, in the same way as for the requireDownstreamWindow setting described above

An example job configuration is provided as makeslidingwindowtriggerplots_icarus.fcl.

Technical description of the module

This module class is derived from icarus::trigger::TriggerEfficiencyPlotsBase, which provides a backbone to perform the simulation of triggers and plotting of their efficiency.

There is no superior design involved in this separation, but rather the goal to share most code possible between different modules which simulate different trigger patterns and as a consequence might have specific plots to fill.

This module redefines:

• initializePlotSet() to define the few additional plots needed;
• simulateAndPlot(), which must always be defined, and which connects the simulation pieces and the plotting.

It does not redefine initializeEfficiencyPerTriggerPlots() nor initializeEventPlots() because there are no additional plots of the types these functions deal with.

The event categories are from the default list (DefaultPlotCategories) too.

Definition at line 332 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

Member Typedef Documentation

using icarus::trigger::SlidingWindowTriggerEfficiencyPlots::Parameters = art::EDAnalyzer::Table<Config>

Definition at line 352 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

using icarus::trigger::SlidingWindowTriggerEfficiencyPlots::TriggerInfo_t = details::TriggerInfo_t

private

Definition at line 382 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

using icarus::trigger::SlidingWindowTriggerEfficiencyPlots::WindowPatterns_t = icarus::trigger::WindowPatterns_t

private

List of configured patterns.

Definition at line 380 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

using icarus::trigger::SlidingWindowTriggerEfficiencyPlots::WindowTriggerInfo_t = icarus::trigger::SlidingWindowPatternAlg::AllTriggerInfo_t

private

Data structure to communicate internally a trigger response.

Definition at line 386 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

Constructor & Destructor Documentation

icarus::trigger::SlidingWindowTriggerEfficiencyPlots::SlidingWindowTriggerEfficiencyPlots ( Parameters const &  config )

explicit

Definition at line 552 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

  : art::EDAnalyzer           (config)
  , TriggerEfficiencyPlotsBase(config(), consumesCollector())
  // configuration
  , fPatterns(config().Patterns())
  // internal variables
  , fWindowMapMan{
      helper().geometry(),
      helper().logCategory() + "_WindowMapManager"
      }
{
  
  if (fPatterns.empty()) {
    throw art::Exception(art::errors::Configuration)
      << "At least one 'MinimumPrimitives' requirement... required.";
  }
  
  std::size_t iPattern [[maybe_unused]] = 0U; // NOTE: incremented only in DEBUG
  for (auto const& pattern: fPatterns) {
    std::size_t const index [[maybe_unused]]
      = createCountersForPattern(pattern.tag());
    assert(index == iPattern++);
    
  } // for patterns
  
  //
  // more complex parameter parsing
  //
  if (helper().eventTree()) {

    fResponseTree = std::make_unique<ResponseTree>
      (*(helper().eventTree()), helper().ADCthresholds(), fPatterns);

  } // if make tree

  {
    mf::LogInfo log(helper().logCategory());
    
    log
      << "Requirement of sliding window patterns ("
      << fPatterns.size() << "):";
    for (auto const& pattern: fPatterns)
      log << "\n [" << pattern.tag() << "] " << pattern.description();
    
  }
  
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::SlidingWindowTriggerEfficiencyPlots()

Member Function Documentation

void icarus::trigger::SlidingWindowTriggerEfficiencyPlots::analyze ( art::Event const &  event )

overridevirtual

Fills the plots. Also extracts the information to fill them with.

Definition at line 626 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

{
  
  // hook helper and framework;
  // actual action is in the (overridden) virtual function `plotResponse()`
  // and `fillXxxPlots()`.
  helper().process(event);
  
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::analyze()

void icarus::trigger::SlidingWindowTriggerEfficiencyPlots::beginJob ( )

overridevirtual

Initializes the plots.

Definition at line 602 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

                                                                {

  // hook helper and framework;
  // actual action is in the (overridden) virtual functions `initializeXxx()`.
  
  // NOTE this action can't happen in constructor because relies on polymorphism
  std::vector<SettingsInfo_t> settings;
  for (auto const& [ iPattern, pattern ]: util::enumerate(fPatterns)) {
    settings.emplace_back(
      iPattern,             // index
      pattern.tag(),        // tag
      pattern.description() // description
      );
  } // for
  
  // we use the default plot categories defined in
  // `TriggerEfficiencyPlotsBase::DefaultPlotCategories`
  helper().initializePlots(settings);
  
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::beginJob()

void icarus::trigger::SlidingWindowTriggerEfficiencyPlots::endJob ( )

overridevirtual

Prints end-of-job summaries.

Definition at line 638 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

                                                              {
  
  helper().deleteEmptyPlots(); // don't keep plots with no entries
  
  // hook helper and framework
  helper().printSummary();
  
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::endJob()

void icarus::trigger::SlidingWindowTriggerEfficiencyPlots::fillAllEventPlots ( PlotSandboxRefs_t const &  plotSets, EventInfo_t const &  eventInfo  ) const

private

Fills all event plots with data from eventInfo as in fillEventPlots().

Definition at line 830 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

{
  /*
   * Now fill the plots independent of the trigger response:
   * the same value is plotted in all plot sets.
   * (again for all pertinent event categories, e.g. charged currents, etc.)
   */
  for (PlotSandbox const& plotSet: plotSets) {
    
    //
    // general plots, independent of trigger definition details
    //
    fillEventPlots(eventInfo, plotSet);
    
  } // for
  
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::fillAllEventPlots()

void icarus::trigger::SlidingWindowTriggerEfficiencyPlots::fillAllPMTplots ( PlotSandboxRefs_t const &  plotSets, PMTInfo_t const &  PMTinfo  ) const

private

Fills all PMY plots with data from PMTinfo as in fillPMTplots().

Definition at line 852 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

{
  /*
   * Now fill the plots independent of the trigger response:
   * the same value is plotted in all plot sets.
   * (again for all pertinent event categories, e.g. charged currents, etc.)
   */
  for (PlotSandbox const& plotSet: plotSets) {
    
    //
    // general plots, independent of trigger definition but dependent on
    // threshold
    //
    fillPMTplots(PMTinfo, plotSet);
    
  } // for
  
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::fillAllPMTplots()

SlidingWindowTriggerEfficiencyPlots const& icarus::trigger::SlidingWindowTriggerEfficiencyPlots::helper ( ) const

inlineprivate

Access to the helper.

Definition at line 412 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

{ return *this; }

SlidingWindowTriggerEfficiencyPlots& icarus::trigger::SlidingWindowTriggerEfficiencyPlots::helper ( )

inlineprivate

Definition at line 413 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

{ return *this; }

void icarus::trigger::SlidingWindowTriggerEfficiencyPlots::initializePatternAlgorithms ( )

private

Constructs all the pattern algorithms. Must be called after setting the window topology.

Definition at line 820 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

{
  fPatternAlgs.clear();
  for (auto const& pattern: fPatterns)
    fPatternAlgs.emplace_back(*fWindowMapMan, pattern, helper().logCategory());
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::initializePatternAlgorithms()

void icarus::trigger::SlidingWindowTriggerEfficiencyPlots::initializePlotSet ( PlotSandbox &  plots, std::vector< SettingsInfo_t > const &  settings  ) const

overrideprivatevirtual

Initializes full set of plots for (ADC threshold + category).

This customization of TriggerEfficiencyPlotsBase::initializePlotSet() adds some trigger-definition specific plots and some overview plots across different trigger definitions.

Reimplemented from icarus::trigger::TriggerEfficiencyPlotsBase.

Definition at line 650 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

{

  //
  // Selection-related plots
  //
  
  // (inherited)
  helper().TriggerEfficiencyPlotsBase::initializePlotSet(plots, settings);
  
  //
  // overview plots with different settings
  //
  
  std::vector<std::string> patternLabels; // each pattern has tag as label
  std::transform(
    fPatterns.cbegin(), fPatterns.cend(), back_inserter(patternLabels),
    std::mem_fn(&WindowPattern::tag)
    );
  
  //
  // Triggering efficiency vs. requirements.
  //
  auto const [ detTimings, beamGate, preSpillWindow ] = makeGatePack();
  detinfo::timescales::optical_time_ticks const triggerResolutionTicks
    { detTimings.toOpticalTicks(helper().triggerTimeResolution()) };
  
  auto const& beamGateOpt = beamGate.asOptTickRange();
  
  auto* TrigTime = plots.make<TH2F>(
    "TriggerTick",
    "Trigger time tick"
      ";window pattern"
      ";optical time tick [ /" + util::to_string(triggerResolutionTicks) + " ]",
    fPatterns.size(), 0.0, double(fPatterns.size()),
    beamGateOpt.duration() / triggerResolutionTicks,
    beamGateOpt.first.value(), beamGateOpt.second.value()
    );
  
  util::ROOT::applyAxisLabels(TrigTime->GetXaxis(), patternLabels);
  
  auto* Triggers = plots.make<TH1F>(
    "Triggers",
    "Triggered events"
      ";window pattern"
      ";triggered events",
    fPatterns.size(), 0.0, double(fPatterns.size())
    );
  
  util::ROOT::applyAxisLabels(Triggers->GetXaxis(), patternLabels);
  
  auto* Eff = plots.make<TEfficiency>(
    "Eff",
    "Efficiency of triggering"
      ";window pattern"
      ";trigger efficiency",
    fPatterns.size(), 0.0, double(fPatterns.size())
//    fMinimumPrimitives.back(), 0, fMinimumPrimitives.back() + 1
    );
  
  // people are said to have earned hell for things like this;
  // but TEfficiency really does not expose the interface to assign labels to
  // its axes, which supposedly could be done had we chosen to create it by
  // histograms instead of directly as recommended.
  // Also need to guess which is the relevant histogram.
  util::ROOT::applyAxisLabels
    (const_cast<TH1*>(Eff->GetTotalHistogram())->GetXaxis(), patternLabels);
  util::ROOT::applyAxisLabels
    (const_cast<TH1*>(Eff->GetPassedHistogram())->GetXaxis(), patternLabels);
  
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::initializePlotSet()

void icarus::trigger::SlidingWindowTriggerEfficiencyPlots::plotResponse ( std::size_t  iThr, std::string const &  threshold, std::size_t  iPattern, WindowPattern const &  pattern, PlotSandboxRefs_t const &  plotSets, EventInfo_t const &  eventInfo, PMTInfo_t const &  PMTinfo, WindowTriggerInfo_t const &  triggerInfo  ) const

private

Fills plots with the specified trigger response.

Parameters

iThr	index of PMT threshold (used in tree output)
threshold	PMT threshold tag (for printing)
iPattern	index of the pattern being plotted
pattern	the pattern being plotted
plotSets	set of plot boxes to fill (from initializePlotSet())
eventInfo	event information for plotting
triggerInfo	the information about the response of this trigger

This method fills all the relevant plots for the specified trigger pattern and threshold. The trigger response is passed as a parameter.

Definition at line 872 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

        {
  
  using namespace std::string_literals;
  
  bool const fired = triggerInfo.info.fired();
  
  if (fResponseTree) fResponseTree->assignResponse(iThr, iPattern, fired);
  
  
  std::string const patternTag { pattern.tag() };
  
  // go through all the plot categories this event qualifies for
  // (for example: charged currents, muon neutrinos, ...)
  for (icarus::trigger::PlotSandbox const& plotSet: plotSets) {
    
    //
    // overview plots from different thresholds
    //
    
    HistGetter const get { plotSet };
    
    // simple efficiency
    get.Eff("Eff"s).Fill(fired, iPattern);
    
    // simple count
    if (fired) get.Hist("Triggers"s).Fill(iPattern);
    
    // trigger time (if any)
    if (fired) {
      get.Hist2D("TriggerTick"s).Fill
        (iPattern, triggerInfo.info.atTick().value());
    }
    
    //
    // plots depending on the trigger response
    // (but not caring of the trigger definition details)
    //
    
    // efficiency plots
    // (including event plots in the triggered or non-triggered category)
    helper().fillAllEfficiencyPlots
      (eventInfo, PMTinfo, triggerInfo.info, plotSet.demandSandbox(patternTag));
    
    //
    // add here further trigger-specific plots
    //
    
  } // for all qualifying plot categories
  
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::plotResponse()

void icarus::trigger::SlidingWindowTriggerEfficiencyPlots::simulateAndPlot ( std::size_t const  thresholdIndex, TriggerGatesPerCryostat_t const &  gates, EventInfo_t const &  eventInfo, detinfo::DetectorClocksData const &  clockData, PlotSandboxRefs_t const &  selectedPlots  )

overrideprivatevirtual

Simulates all trigger minimum requirements plots the results.

Parameters

thresholdIndex	the index of the PMT threshold of input primitives
gates	the trigger primitives used to simulate the trigger response
eventInfo	general information about the event being simulated
selectedPlots	list of boxes containing plots to be filled

This method is expected to perform the following steps for each trigger primitive requirement in MinimumPrimitives:

1. combine the trigger primitives: combineTriggerPrimitives();
2. apply the beam gate: applyBeamGateToAll() on the combined primitives;
3. generate the trigger response: in plotResponse();
4. fill all plots: also in in plotResponse().

Details are in the documentation of the relevant methods.

This method is invoked once per PMT threshold.

Implements icarus::trigger::TriggerEfficiencyPlotsBase.

Definition at line 724 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

  {
  
  auto const threshold = helper().ADCthresholdTag(thresholdIndex);
  
  /*
   * 0. initialize or verify the topology of the input
   * 1. apply the beam gate to each input gate
   * 2. for each pattern: apply the pattern, plot the trigger outcome
   * 3. fill all trigger-independent plots
   * 4. fill all PMT plots (threshold-dependent)
   */
  
  //
  // 0. initialize or verify the topology of the input
  //
  
  // throws exception on verification failure;
  // pattern algorithms are constructed here because they require window mapping
  if (fWindowMapMan(gates)) initializePatternAlgorithms();

  
  auto const& beamGate = helper().makeMyBeamGate(clockData);
  
  //
  // 1. apply the beam gate to each input gate
  //    (it's ok to lose provenance information since we have the map)
  //
  TriggerGates_t inBeamGates;
  for (auto const& cryoGates: gates)
    appendCollection(inBeamGates, beamGate.applyToAll(cryoGates));
  
  // --- BEGIN DEBUG -----------------------------------------------------------
  {
    mf::LogTrace log(helper().logCategory());
    log << "Input for threshold " << threshold << ": " << inBeamGates.size()
      << " primitives. After beam gate:";
    unsigned int nOpen = 0U;
    using icarus::trigger::gatesIn;
    for (auto const& [ iWindow, gate ]: util::enumerate(gatesIn(inBeamGates))) {
      auto const maxTick = gate.findMaxOpen();
      if (maxTick == gate.MinTick) continue;
      ++nOpen;
      log << "\n  window #" << iWindow << ": maximum "
        << gate.openingCount(maxTick) << " at tick " << maxTick;
    } // for
    if (!nOpen) log << "  nothing.";
  }
  // --- END DEBUG -------------------------------------------------------------
  
  // get which gates are active during the beam gate
  PMTInfo_t const PMTinfo
    { threshold, helper().extractActiveChannels(gates) };
  
  //
  // 2. for each pattern:
  //
  for (auto const& [ iPattern, pattern ]: util::enumerate(fPatterns)) {

    auto& patternAlg = fPatternAlgs[iPattern];
    
    WindowTriggerInfo_t const triggerInfo
      = patternAlg.simulateResponse(inBeamGates);
    
    registerTriggerResult(thresholdIndex, iPattern, triggerInfo.info);

    plotResponse(
      thresholdIndex, threshold,
      iPattern, pattern,
      selectedPlots,
      eventInfo, PMTinfo, triggerInfo
      );
    
  } // for window patterns
  
  //
  // 3. fill all trigger-independent plots (one copy per threshold... meh)
  //
  fillAllEventPlots(selectedPlots, eventInfo);
  
  //
  // 4. fill all PMT plots (threshold-dependent)
  //
  fillAllPMTplots(selectedPlots, PMTinfo);
  
} // icarus::trigger::SlidingWindowTriggerEfficiencyPlots::simulateAndPlot()

Member Data Documentation

std::vector<icarus::trigger::SlidingWindowPatternAlg> icarus::trigger::SlidingWindowTriggerEfficiencyPlots::fPatternAlgs

private

All algorithm instances, one per pattern.

Definition at line 403 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

WindowPatterns_t const icarus::trigger::SlidingWindowTriggerEfficiencyPlots::fPatterns

private

Configured sliding window requirement patterns.

Definition at line 391 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

std::unique_ptr<ResponseTree> icarus::trigger::SlidingWindowTriggerEfficiencyPlots::fResponseTree

private

Handler of ROOT tree output.

Definition at line 405 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

icarus::trigger::WindowTopologyManager icarus::trigger::SlidingWindowTriggerEfficiencyPlots::fWindowMapMan

mutableprivate

Mapping of each sliding window with location and topological information.

Definition at line 400 of file SlidingWindowTriggerEfficiencyPlots_module.cc.

---

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

• SlidingWindowTriggerEfficiencyPlots_module.cc