icarus::trigger::MajorityTriggerEfficiencyPlots Class Reference

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

Inheritance diagram for icarus::trigger::MajorityTriggerEfficiencyPlots:

Classes
struct	Config

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

Public Member Functions
	MajorityTriggerEfficiencyPlots (Parameters const &config)
	MajorityTriggerEfficiencyPlots (MajorityTriggerEfficiencyPlots const &)=delete
	MajorityTriggerEfficiencyPlots (MajorityTriggerEfficiencyPlots &&)=delete
MajorityTriggerEfficiencyPlots &	operator= (MajorityTriggerEfficiencyPlots const &)=delete
MajorityTriggerEfficiencyPlots &	operator= (MajorityTriggerEfficiencyPlots &&)=delete
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	WorkingTriggerGate_t = InputTriggerGate_t
	Type of gate data used for internal processing. 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	plotResponses (std::size_t iThr, std::string const &threshold, PlotSandboxRefs_t const &plotSets, EventInfo_t const &eventInfo, detinfo::DetectorClocksData const &clockData, std::vector< WorkingTriggerGate_t > const &combinedCounts, std::vector< ChannelID_t > const &channelList)
	Completes the event trigger simulation and fills the plots. More...
std::vector< WorkingTriggerGate_t >	combineTriggerPrimitives (TriggerGatesPerCryostat_t const &cryoGates, std::string const &threshold) const
	Computes the trigger response from primitives with the given threshold. More...
MajorityTriggerEfficiencyPlots const &	helper () const
	Access to the helper. More...
MajorityTriggerEfficiencyPlots &	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
std::vector< unsigned int >	fMinimumPrimitives
	Minimum number of trigger primitives for a trigger to happen. 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 minimum number of trigger primitives beyond threshold.

A trigger primitive is a two-level function of time which describes when that primitive is on and when it is off. Trigger primitives are given as input to this module and their origin may vary, but the standard source in ICARUS is the pairing with AND or OR of two optical detector channels discriminated against a certain ADC count threshold.

Trigger logic algorithm

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

The algorithm keeps the trigger primitives from the different cryostats separate for the most time. Within each cryostat, all trigger primitives are treated equally, whether they originate from one or from two channels (or 10 or 30), and wherever their channels are in the cryostat. The trigger primitives in each cryostat are combined in a multi-level gate by adding them, so that the level of the resulting gate matches at any time how many trigger primitives are on at that time. Finally, the maximum number of trigger primitives open in any of the cryostats at each time is the level to be compared to the trigger requirements.

This multi-level gate is set in coincidence with the beam gate by multiplying the multi-level and the beam gates. The beam gate opens at a time configured in DetectorClocks service provider (detinfo::DetectorClocks::BeamGateTime()) and has a duration configured in this module (BeamGateDuration).

At this point, the trigger gate is a multi-level gate suppressed everywhere except than during the beam gate. The algorithm handles multiple trigger primitive requirements. Each requirement is simply how many trigger primitives must be open at the same time in a single cryostat for the trigger to fire. The values of these requirements are set in the configuration (MinimumPrimitives). To determine whether a trigger with a given requirement, i.e. with a required minimum number of trigger primitives open at the same time, has fired, the gate combined as described above is scanned to find the first tick where the level of the gate reaches or passes this minimum required number. If such tick exists, the trigger is considered to have fired, and at that time.

As a consequence, there are for each event as many different trigger responses as how many different requirements are configured in MinimumPrimitives, 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 combination algorithm is implemented in combineTriggerPrimitives() while the requirement evaluation and plotting are implemented in plotResponses().

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 the single trigger primitive requirement N (configuration parameter: MinimumPrimitives). The folders and plots will identify each requirement with the tag ReqN (e.g. Req5 when requesting at least 5 trigger primitives for an event trigger).

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

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.

A list of additional plots follows for each plot type. 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 minimum number of trigger primitives (MinimumPrimitives) to define a firing trigger; uncertainties are managed by TEfficiency.
• TriggerTick: distribution of the time of the earliest trigger for the event, as function of the minimum number of trigger primitives (as in Eff). It may happen that the event is such that there is e.g. a 20-primitive flash, then subsiding, and then another 30-primitive flash. In such a case, in the trigger requirement "≥ 15 primitives" such event will show at the time of the 20-primitive flash, while in the trigger requirement "≥ 25 primitives" it will show at the time of the 30-primitive flash. Each event appears at most once for each trigger requirement, and it may not appear at all if does not fire a trigger.
• NPrimitives: the maximum number of primitives "on" at any time.

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:

• MinimumPrimitives (list of integers, mandatory): a list of alternative requirements for the definition of a trigger; each value is the number of trigger primitives needed to be "on" at the same time for the trigger to fire;

An example job configuration is provided as maketriggerplots_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 not any superior design involved in this separation, but just the desire 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 278 of file MajorityTriggerEfficiencyPlots_module.cc.

Member Typedef Documentation

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

Definition at line 298 of file MajorityTriggerEfficiencyPlots_module.cc.

using icarus::trigger::MajorityTriggerEfficiencyPlots::WorkingTriggerGate_t = InputTriggerGate_t

private

Type of gate data used for internal processing.

Definition at line 331 of file MajorityTriggerEfficiencyPlots_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 506 of file MajorityTriggerEfficiencyPlots_module.cc.

  : art::EDAnalyzer           (config)
  , TriggerEfficiencyPlotsBase(config(), consumesCollector())
  // configuration
  , fMinimumPrimitives(config().MinimumPrimitives())
{
  std::sort(fMinimumPrimitives.begin(), fMinimumPrimitives.end());
  
  //
  // more complex parameter parsing
  //
  if (helper().eventTree()) {

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

  } // if make tree

  if (fMinimumPrimitives.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& req: fMinimumPrimitives) {
    std::size_t const index [[maybe_unused]]
      = createCountersForPattern("Req" + std::to_string(req));
    assert(index == iPattern++);
  } // for requirements
  
  {
    mf::LogInfo log(helper().logCategory());
    log
      << "Requirement of minimum trigger primitives ("
      << fMinimumPrimitives.size() << "):";
    for (auto const& req: fMinimumPrimitives) log << " " << req;
    log << ".";
  }
  
} // icarus::trigger::MajorityTriggerEfficiencyPlots::MajorityTriggerEfficiencyPlots()

icarus::trigger::MajorityTriggerEfficiencyPlots::MajorityTriggerEfficiencyPlots ( MajorityTriggerEfficiencyPlots const &  )

delete

icarus::trigger::MajorityTriggerEfficiencyPlots::MajorityTriggerEfficiencyPlots ( MajorityTriggerEfficiencyPlots &&  )

delete

Member Function Documentation

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

overridevirtual

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

Definition at line 574 of file MajorityTriggerEfficiencyPlots_module.cc.

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

void icarus::trigger::MajorityTriggerEfficiencyPlots::beginJob ( )

overridevirtual

Initializes the plots.

Definition at line 549 of file MajorityTriggerEfficiencyPlots_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 [ iReq, minCount ]: util::enumerate(fMinimumPrimitives)) {
    std::string const minCountStr { std::to_string(minCount) };
    settings.emplace_back(
      iReq,                              // index
      "Req" + minCountStr,               // tag
      minCountStr + " channels required" // description
      );
  } // for
  
  // we use the default plot categories defined in
  // `TriggerEfficiencyPlotsBase::DefaultPlotCategories`
  helper().initializePlots(settings);
  
} // icarus::trigger::MajorityTriggerEfficiencyPlots::beginJob()

auto icarus::trigger::MajorityTriggerEfficiencyPlots::combineTriggerPrimitives ( TriggerGatesPerCryostat_t const &  cryoGates, std::string const &  threshold  ) const

private

Computes the trigger response from primitives with the given threshold.

Parameters

cryoGates	collections of trigger primitives, one coll. per cryostat
threshold	PMT threshold of the primitives (for printing purposes)

Returns

a list of combined trigger primitives, one combination per cryostat

The input trigger primitives are already grouped by cryostat. For each cryostat, the primitives are combined and one combination is returned. The combination is just the "total" of the primitives opened at each tick.

The event trigger is not finalized here, and the cryostat trigger primitives are all returned.

Definition at line 902 of file MajorityTriggerEfficiencyPlots_module.cc.

                                           {

  //
  // simple count
  //
  std::vector<WorkingTriggerGate_t> cryoCombinedGate;
  cryoCombinedGate.reserve(cryoGates.size());

  for (auto const& [ iCryo, gates ]: util::enumerate(cryoGates)) {
    geo::CryostatID const cryoID(iCryo);
    
    mf::LogTrace(helper().logCategory())
      << "Simulating trigger response with ADC threshold " << threshold
      << " for " << cryoID << " (" << gates.size() << " primitives)";

    cryoCombinedGate.push_back(icarus::trigger::sumGates(gates));
  } // for

  //
  // largest number of trigger primitives at any time, per cryostat
  //
  return cryoCombinedGate;
  
} // icarus::trigger::MajorityTriggerEfficiencyPlots::combineTriggerPrimitives()

void icarus::trigger::MajorityTriggerEfficiencyPlots::endJob ( )

overridevirtual

Prints end-of-job summaries.

Definition at line 586 of file MajorityTriggerEfficiencyPlots_module.cc.

                                                         {
  
  // hook helper and framework
  helper().printSummary();
  
} // icarus::trigger::MajorityTriggerEfficiencyPlots::endJob()

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

inlineprivate

Access to the helper.

Definition at line 351 of file MajorityTriggerEfficiencyPlots_module.cc.

{ return *this; }

MajorityTriggerEfficiencyPlots& icarus::trigger::MajorityTriggerEfficiencyPlots::helper ( )

inlineprivate

Definition at line 352 of file MajorityTriggerEfficiencyPlots_module.cc.

{ return *this; }

void icarus::trigger::MajorityTriggerEfficiencyPlots::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 596 of file MajorityTriggerEfficiencyPlots_module.cc.

{

  //
  // Selection-related plots
  //
  
  // (inherited)
  helper().TriggerEfficiencyPlotsBase::initializePlotSet(plots, settings);
  
  //
  // overview plots with different settings
  //
  
  // a variable binning for the required number of trigger primitives
  auto [ minimumPrimBinning, minimumPrimBinningLabels ]
    = util::ROOT::makeVariableBinningAndLabels(fMinimumPrimitives);
  assert(minimumPrimBinning.size() == minimumPrimBinningLabels.size() + 1U);

  {
    mf::LogTrace log(helper().logCategory());
    log << "MajorityTriggerEfficiencyPlots (plots '"
      << plots.name() << "') variable binning including the "
      << fMinimumPrimitives.size() << " points {";
    for (auto value: fMinimumPrimitives) log << " " << value;
    log << " } => " << minimumPrimBinningLabels.size() << " bins: ";
    for (auto const& [ value, label ]
      : util::zip<1U>(minimumPrimBinning, minimumPrimBinningLabels))
    {
      log << " " << value << " (\"" << label << "\") =>";
    } // for
    log << " " << minimumPrimBinning.back();
  } // debug output block

  //
  // 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"
      ";minimum requested number of trigger primitives"
      ";optical time tick [ /" + util::to_string(triggerResolutionTicks) + " ]",
    minimumPrimBinning.size() - 1U, minimumPrimBinning.data(),
//    fMinimumPrimitives.back(), 0, fMinimumPrimitives.back() + 1
    beamGateOpt.duration() / triggerResolutionTicks,
    beamGateOpt.first.value(), beamGateOpt.second.value()
    );
  
  util::ROOT::applyAxisLabels(TrigTime->GetXaxis(), minimumPrimBinningLabels);
  
  auto* Eff = plots.make<TEfficiency>(
    "Eff",
    "Efficiency of triggering"
      ";minimum requested number of trigger primitives"
      ";trigger efficiency",
    minimumPrimBinning.size() - 1U, minimumPrimBinning.data()
//    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.
  util::ROOT::applyAxisLabels(
    const_cast<TH1*>(Eff->GetTotalHistogram())->GetXaxis(),
    minimumPrimBinningLabels
    );
  
  //
  // plots independent of the trigger primitive requirements
  //
  plots.make<TH1F>(
    "NPrimitives",
    "Number of trigger primitives (\"channels firing at once\")"
    ";maximum trigger primitives at the same time on a single cryostat"
    ";events",
    192, 0.0, 192.0 // large number, zoom in presentations!
    ); 

} // icarus::trigger::MajorityTriggerEfficiencyPlots::initializePlotSet()

MajorityTriggerEfficiencyPlots& icarus::trigger::MajorityTriggerEfficiencyPlots::operator= ( MajorityTriggerEfficiencyPlots const &  )

delete

MajorityTriggerEfficiencyPlots& icarus::trigger::MajorityTriggerEfficiencyPlots::operator= ( MajorityTriggerEfficiencyPlots &&  )

delete

void icarus::trigger::MajorityTriggerEfficiencyPlots::plotResponses ( std::size_t  iThr, std::string const &  threshold, PlotSandboxRefs_t const &  plotSets, EventInfo_t const &  eventInfo, detinfo::DetectorClocksData const &  clockData, std::vector< WorkingTriggerGate_t > const &  combinedCounts, std::vector< ChannelID_t > const &  channelList  )

private

Completes the event trigger simulation and fills the plots.

Parameters

iThr	index of PMT threshold (used in tree output)
threshold	PMT threshold in ADC counts (for printing)
plotSets	set of plot boxes to fill (from initializePlotSet())
eventInfo	event information for plotting
combinedCounts	combined trigger primitives, per cryostat

For each of the trigger requirements (MinimumPrimitives), this method:

1. applies the requirement to the combinedCounts trigger primitive
2. computes the event triggers (including the main one)
3. fills all plots in all the plot sets for this requirement accordingly

The input combined trigger primitives contain the maximum number of trigger primitives active at each optical clock tick, one entry for each cryostat. It is assumed that the beam gate has already been "applied" so that outside it no trigger primitive is considered open.

A trigger with requirement of minimum trigger primitives N is fired if this combined primitive reaches or passes N, i.e. if there are at least N open trigger primitives at any time. The time of the trigger is taken as the first tick at which the requirement is met.

Extra plots are an overview of the trigger efficiency for different requirements, per threshold, the distribution of the trigger time for different requirements, and maximum number of open primitive in a cryostat, per event.

Note that there is no information about which cryostat is meeting the trigger requirement.

Definition at line 716 of file MajorityTriggerEfficiencyPlots_module.cc.

  {
  
  /*
   * This function plots according to the configured minimum number of trigger
   * primitives: for each requirement of minimum number of primitives, the
   * earliest time where that requirement is met is found, and that is
   * considered as the trigger time.
   * 
   * The following quantities are drawn per ADC threshold and per plot category:
   * 
   * * per minimum number of primitives:
   *    * trigger efficiency (i.e. whether there was _any time_ a number of
   *      primitives fulfilling the requirement)
   *    * trigger time in ticks (distribution as 2D histogram)
   * * maximum number of trigger primitives present at any time
   * * deposited energy during beam spill
   * 
   */
  using namespace std::string_literals;
  
  using ClockTick_t = WorkingTriggerGate_t::TriggerGate_t::ClockTick_t;
  using OpeningCount_t = WorkingTriggerGate_t::TriggerGate_t::OpeningCount_t;
  
  using PrimitiveCount_t = std::pair<ClockTick_t, OpeningCount_t>;
  
  PrimitiveCount_t maxPrimitives { ClockTick_t{ 0 } /* dummy */, 0U };
  for (auto const& [ iCryo, combinedCount ]
    : util::enumerate(gatesIn(combinedCounts)))
  {
    auto const maxPrimitiveTime { combinedCount.findMaxOpen() };
    PrimitiveCount_t const maxPrimitivesInCryo
      { maxPrimitiveTime, combinedCount.openingCount(maxPrimitiveTime) };
    if (maxPrimitivesInCryo.second > maxPrimitives.second)
      maxPrimitives = maxPrimitivesInCryo;

    mf::LogTrace log { helper().logCategory() };
    log << "Max primitive count in " << threshold << " for C:" << iCryo << ": "
      << maxPrimitivesInCryo.second;
    if (maxPrimitivesInCryo.second > 0) {
      log << " at tick " << maxPrimitivesInCryo.first << " ("
        << detinfo::DetectorTimings(clockData).toElectronicsTime
          (detinfo::DetectorTimings::optical_tick{ maxPrimitivesInCryo.first })
        << ")"
        ;
    } // if
  } // for
  
  PMTInfo_t const PMTinfo { threshold, channelList };
  
  /*
   * Fill all the histograms for all the minimum primitive requirements
   * (filling the information whether or not the trigger fired),
   * for all the qualifying categories.
   * Note that in this type of plots each event appears in all bins
   * (may be with "fired" or "not fired" on each bin)
   */

  // PrimitiveCount_t lastMinCount { WorkingTriggerGate_t::MinTick, 0 };

  bool fired = true; // the final trigger response (changes with requirement)
  
  for (auto [ iReq, minCount ]: util::enumerate(fMinimumPrimitives)) {
    
    TriggerInfo_t triggerInfo;
    if (fired) { // this is still the previous requirement
      for (auto const& [ iCryo, cryoGate ]: util::enumerate(combinedCounts)) {
        
        icarus::trigger::details::GateOpeningInfoExtractor extractOpeningInfo
          { gateIn(cryoGate), minCount };
        extractOpeningInfo.setLocation(iCryo);
        while (extractOpeningInfo) {
          auto info = extractOpeningInfo();
          if (info) triggerInfo.add(info.value());
        } // while
      } // for all cryostats
      triggerInfo.sortOpenings(); // sort in time
      fired = triggerInfo.fired();
    } // if previous fired
    
    if (fired) {
      mf::LogTrace log(helper().logCategory());
      log
        << " => fired (>" << minCount << ") at " << triggerInfo.atTick()
        << " (level " << triggerInfo.level() << ") from"
        ;
      if (triggerInfo.hasLocation()) log << " C:" << triggerInfo.location();
      else log << " unknown location";
      log << ", " << triggerInfo.nTriggers() << " triggers total:";
      for (auto const& [iTrigger, info ]: util::enumerate(triggerInfo.all())) {
        log << " [" << iTrigger << "] at " << info.tick;
        if (info.hasLocation()) log << " of C:" << info.locationID;
        else log << " [unknown location]";
        log << " (level=" << info.level << ")";
      } // for
      
    } // if fired
    else {
      mf::LogTrace(helper().logCategory())
        << " => not fired (>" << minCount << ")";
    }
    
    // at this point we know we have minCount or more trigger primitives,
    // and the time of this one is in lastMinCount.first (just in case)
    
    if (fResponseTree) fResponseTree->assignResponse(iThr, iReq, fired);
    
    registerTriggerResult(iThr, iReq, fired);
    
    std::string const minCountStr { "Req" + std::to_string(minCount) };
    
    // 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, minCount);
      
      // trigger time (if any)
      if (fired) {
        get.Hist2D("TriggerTick"s).Fill(minCount, triggerInfo.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, plotSet.demandSandbox(minCountStr));
      
      //
      // add here further trigger-specific plots
      //
      
    } // for all qualifying plot categories
    
  } // for all requirements
  
  /*
   * 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);
    
    //
    // general plots, independent of trigger definition but dependent on
    // threshold
    //
    fillPMTplots(PMTinfo, plotSet);
    
    //
    // trigger-definition specific plots
    //
    HistGetter const get(plotSet);
    
    // number of primitives
    get.Hist("NPrimitives"s).Fill(maxPrimitives.second);
    
  } // for

} // icarus::trigger::MajorityTriggerEfficiencyPlots::plotResponses()

void icarus::trigger::MajorityTriggerEfficiencyPlots::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: applyBeamGate() on the combined primitives;
3. generate the trigger response: in plotResponses();
4. fill all plots: also in in plotResponses().

Details are in the documentation of the relevant methods.

This method is invoked once per PMT threshold.

Implements icarus::trigger::TriggerEfficiencyPlotsBase.

Definition at line 687 of file MajorityTriggerEfficiencyPlots_module.cc.

  {
  
  auto const threshold = helper().ADCthresholdTag(thresholdIndex);
  
  auto const& beamGate = helper().makeMyBeamGate(clockData);
  
  /* 
   * 1. combine trigger primitives per cryostat (`combineTriggerPrimitives()`)
   * 2. apply the beam gate on the combination (`applyBeamGate()`)
   * 3. and compute the trigger response (`plotResponses()`)
   * 4. fill plots with the result (also `plotResponses()`)
   */
  plotResponses(
    thresholdIndex, threshold, selectedPlots, eventInfo,
    clockData,
    beamGate.applyToAll(combineTriggerPrimitives(gates, threshold)),
    helper().extractActiveChannels(gates)
    );
  
} // icarus::trigger::MajorityTriggerEfficiencyPlots::simulateAndPlot()

Member Data Documentation

std::vector<unsigned int> icarus::trigger::MajorityTriggerEfficiencyPlots::fMinimumPrimitives

private

Minimum number of trigger primitives for a trigger to happen.

Definition at line 337 of file MajorityTriggerEfficiencyPlots_module.cc.

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

private

Handler of ROOT tree output.

Definition at line 344 of file MajorityTriggerEfficiencyPlots_module.cc.

---

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

• MajorityTriggerEfficiencyPlots_module.cc