icarus::trigger::LVDSgates Class Reference

Combines discriminated PMT outputs into V1730 LVDS gates. More...

Inheritance diagram for icarus::trigger::LVDSgates:

Classes
struct	Config
struct	SourceInfo_t
	Information for each source. More...

Public Types
enum	ComboMode {   ComboMode::disable, ComboMode::Input1, ComboMode::Input2, ComboMode::AND,   ComboMode::OR }
	Available operations for the combination of channels. More...
using	TriggerGateData_t = icarus::trigger::OpticalTriggerGate::GateData_t
using	Parameters = art::EDProducer::Table< Config >

Public Member Functions
	LVDSgates (Parameters const &config)
	LVDSgates (LVDSgates const &)=delete
	LVDSgates (LVDSgates &&)=delete
LVDSgates &	operator= (LVDSgates const &)=delete
LVDSgates &	operator= (LVDSgates &&)=delete
virtual void	produce (art::Event &event) override
	Fills the plots. Also extracts the information to fill them with. More...
template<typename Op >
auto	binaryCombineChannel (std::vector< TrackedTriggerGate_t > const &gates, std::vector< raw::Channel_t > const &pairing, Op combine) const -> TrackedTriggerGate_t

Private Types
using	BinaryCombinationFunc_t = OpticalTriggerGate &(OpticalTriggerGate::*)(OpticalTriggerGate const &)
	Type of member function to combine the current gate with another one. More...
using	TrackedTriggerGate_t = icarus::trigger::TrackedOpticalTriggerGate< sbn::OpDetWaveformMeta >
	Reconstituted trigger gate type internally used. More...

Private Member Functions
void	produceThreshold (art::Event &event, icarus::trigger::OpDetWaveformMetaDataProductMap_t &waveformMap, std::string const &thresholdStr, SourceInfo_t const &srcInfo) const
	Completely processes the data for the specified threshold. More...
std::vector< std::vector < raw::Channel_t > >	removeChannels (std::vector< std::vector< raw::Channel_t >> channelPairing, std::vector< raw::Channel_t > const &ignoreChannels) const
	Removes all the channel in ignoreChannels from channelPairing. More...
TrackedTriggerGate_t	discardChannels (std::vector< TrackedTriggerGate_t > const &, std::vector< raw::Channel_t > const &pairing) const
	Combination function for the disable mode. More...
TrackedTriggerGate_t	selectChannel (std::vector< TrackedTriggerGate_t > const &, std::vector< raw::Channel_t > const &pairing, std::size_t chosenIndex) const
	Combination function for the input1 and input2 modes. More...
template<typename Op >
TrackedTriggerGate_t	binaryCombineChannel (std::vector< TrackedTriggerGate_t > const &gates, std::vector< raw::Channel_t > const &pairing, Op combine) const
	Combination function for the AND and OR modes; op is from GateOps. More...
TrackedTriggerGate_t	combineChannels (std::vector< TrackedTriggerGate_t > const &gates, std::vector< raw::Channel_t > const &pairing, ComboMode comboMode) const
	Performs the combination of a group of channels. More...
unsigned int	checkPairings () const
void	checkInput (std::vector< TrackedTriggerGate_t > const &gates) const
	Input requirement check. Throws if requirements fail. More...

Static Private Member Functions
static void	UpdateWaveformMap (icarus::trigger::OpDetWaveformMetaDataProductMap_t &map, art::Assns< TriggerGateData_t, sbn::OpDetWaveformMeta > const &assns)
	Adds the associated waveforms into the map. More...
static std::vector < TrackedTriggerGate_t >	ReadTriggerGates (art::Event const &event, art::InputTag const &dataTag, icarus::trigger::OpDetWaveformMetaDataProductMap_t &waveformMap)
	Assembles trigger gates from dataTag data products in event. More...
static art::InputTag	makeTag (std::string const &thresholdStr, std::string const &defModule)
	Converts a threshold string into an input tag. More...
static std::string	makeOutputInstanceName (art::InputTag const &inputTag, std::string const &defModule)
	Converts an input tag into an instance name for the corresponding output. More...

Private Attributes
std::map< std::string, SourceInfo_t >	fADCthresholds
	ADC thresholds to read, and the input tag connected to their data. More...
std::vector< std::vector < raw::Channel_t > >	fChannelPairing
	Pairing of optical detector channels. More...
ComboMode	fComboMode
	The operation used to combinate channels. More...
std::vector< raw::Channel_t >	fIgnoreChannels
bool	fProduceWaveformAssns
	Whether to produce gate/waveform associations. More...
std::string	fLogCategory
	Message facility stream category for output. More...

Detailed Description

Combines discriminated PMT outputs into V1730 LVDS gates.

This module simulates the combination of discriminated PMT outputs by the V1730 board LVDS output.

Input data products

• std::vector<icarus::trigger::OpticalTriggerGateData_t> (labels out of TriggerGatesTag and Thresholds): full sets of discriminated waveforms, each waveform possibly covering multiple optical channels, and their associations to optical waveform metadata. One set per threshold.

Requirements

The algorithms require that the list of discriminated waveforms has in each position the waveform from the optical detector channel number matching the position (e.g. entry 0 will be the discriminated waveform from channel 0, and so forth). No gaps are allowed: if no signal is present above threshold for a certain channel, a discriminated waveform should appear for that channel, with a gate always closed.

Output data products

• std::vector<icarus::trigger::OpticalTriggerGateData_t> (instance name: concatenation of input module label and instance name of the input gates; the former is omitted if it is TriggerGatesTag): sets of gates combined according to the configuration; one set per input threshold.
• art::Assns<icarus::trigger::OpticalTriggerGateData_t, sbn::OpDetWaveformMeta> (instance name: same as above): associations between each produced gate and the metadata of the optical waveforms providing the original data.
• art::Assns<icarus::trigger::OpticalTriggerGateData_t, raw::OpDetWaveform> (instance name: same as above; optional): associations between each produced gate and the optical waveforms providing the original data. It is produced only if ProduceWaveformAssns configuration parameter is true, and it relies on the assumption that there is an association available between each sbn::OpDetWaveformMeta and its raw::OpDetWaveform, produced by the same module (i.e. with the same input tag) as the one of the original sbn::OpDetWaveformMeta data product itself.

Configuration parameters

A terse description of the parameters is printed by running lar --print-description LVDSgates.

• TriggerGatesTag (string, default: discrimopdaq): name of the module instance which produced the discriminated waveforms; it must not include any instance name, as the instance names will be automatically added from Thresholds parameter. This value is used as module name for all thresholds which do not specify one.
• Thresholds (list of tags, mandatory): list of the discrimination thresholds to consider. A data product containing a digital signal is read for each one of the thresholds; each threshold entry is expected to be a input tag in the form "[ModuleLabel:]InstanceName", and if the module label part is not specified, the one from TriggerGatesTag is used as default. In this way, thresholds can be specified simply by a number, e.g. [ 200, 400, 600 ], which will be translated into e.g. "discrimopdaq:200", "discrimopdaq:400" and "discrimopdaq:600", while a full specification can be also used: [ 200, "discrim:config" ] will turn into "discrimopdaq:200" and "discrim:config" (to specify a label with no instance name, set it ending with a colon, like in "discrim:").
• ChannelPairing (list of integral number lists): channels to combine; each element of this list is itself a list of optical detector channel numbers. The channels within each group are combined according to CombinationMode, resulting in a single combined gate associated to all the channels in the group. All optical detector channels must appear in the configuration, and each channel can be combined only in one group. Groups must not be empty.
• IgnoreChannels (list of integral numbers, optional): ID of the optical detector channels to skip.
• CombinationMode (either: "disable", "input1", "input2", "AND" or "OR"): for each group of channels defined in ChannelPairing, the selected operation is used to combine all the channels in the group:
  • disable: all channels are discarded, and the resulting gates are all closed all the way;
  • input1: the first channel in the pairing is kept, and the others are discarded;
  • input2: the second channel in the pairing is kept, and the others are discarded;
  • AND: all channels are combined in a AND, resulting in a gate open only at the time when all the channel gates in the group are open; if there is a single channel in the group, the combined gate is a copy of it;
  • OR: all channels are combined in a OR, resulting in a gate open at every time when any of the channel gates in the group is open; if there is a single channel in the group, the combined gate is a copy of it. All pairings undergo the same operation (it is not possible, for example, disabling only one group of channels and combining the other groups with a AND).
• ProduceWaveformAssns (flag, default: true): produce also associations between each gate and the raw::OpDetWaveform which contributed to it.
• LogCategory (string): name of the output stream category for console messages (managed by MessageFacility library).

Definition at line 166 of file LVDSgates_module.cc.

Member Typedef Documentation

using icarus::trigger::LVDSgates::BinaryCombinationFunc_t = OpticalTriggerGate& (OpticalTriggerGate::*)(OpticalTriggerGate const&)

private

Type of member function to combine the current gate with another one.

Definition at line 277 of file LVDSgates_module.cc.

using icarus::trigger::LVDSgates::Parameters = art::EDProducer::Table<Config>

Definition at line 248 of file LVDSgates_module.cc.

using icarus::trigger::LVDSgates::TrackedTriggerGate_t = icarus::trigger::TrackedOpticalTriggerGate<sbn::OpDetWaveformMeta>

private

Reconstituted trigger gate type internally used.

Definition at line 281 of file LVDSgates_module.cc.

using icarus::trigger::LVDSgates::TriggerGateData_t = icarus::trigger::OpticalTriggerGate::GateData_t

Definition at line 170 of file LVDSgates_module.cc.

Member Enumeration Documentation

enum icarus::trigger::LVDSgates::ComboMode

strong

Available operations for the combination of channels.

Enumerator
disable
Input1
Input2
AND
OR

Definition at line 173 of file LVDSgates_module.cc.

{ disable, Input1, Input2, AND, OR };

Constructor & Destructor Documentation

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

explicit

Definition at line 399 of file LVDSgates_module.cc.

  : art::EDProducer(config)
  // configuration
  , fChannelPairing(config().ChannelPairing())
  , fComboMode(config().getCombinationMode())
  , fIgnoreChannels(config().IgnoreChannels())
  , fProduceWaveformAssns(config().ProduceWaveformAssns())
  , fLogCategory(config().LogCategory())
{
  //
  // more complex parameter parsing
  //
  std::string const discrModuleLabel = config().TriggerGatesTag().value_or("");
  for (std::string const& thresholdStr: config().Thresholds()) {
    art::InputTag const inputTag = makeTag(thresholdStr, discrModuleLabel);
    fADCthresholds[thresholdStr]
      = { inputTag, makeOutputInstanceName(inputTag, discrModuleLabel) };
  } // for all thresholds
  
  //
  // configuration validation
  //
  unsigned int nConfiguredChannels = checkPairings();

  //
  // configuration report (short)
  //
  {
    mf::LogInfo log(fLogCategory);
    log << nConfiguredChannels
      << " optical channels configured to be combined into "
      << fChannelPairing.size() << " LVDS outputs.";
    log << "\nignored " << fIgnoreChannels.size() << " channels.";
    log << "\nConfigured " << fADCthresholds.size() << " thresholds (ADC):";
    for (auto const& [ threshold, srcInfo ]: fADCthresholds) {
      log << "\n * " << threshold
        << " (from '" << srcInfo.inputTag.encode() << "')";
    }
  } // local block

  
  using icarus::trigger::OpticalTriggerGateData_t; // for convenience
  
  //
  // input data declaration
  //
  for (auto const& [ inputTag, outName ]: util::const_values(fADCthresholds)) {
    consumes<std::vector<OpticalTriggerGateData_t>>(inputTag);
    consumes<art::Assns<OpticalTriggerGateData_t, sbn::OpDetWaveformMeta>>
      (inputTag);
  } // for
  
  
  //
  // output data declaration
  //
  for (auto const& [ inputTag, outName ]: util::const_values(fADCthresholds)) {
    produces<std::vector<OpticalTriggerGateData_t>>(outName);
    produces<art::Assns<OpticalTriggerGateData_t, raw::OpDetWaveform>>(outName);
    if (fProduceWaveformAssns) {
      produces<art::Assns<OpticalTriggerGateData_t, sbn::OpDetWaveformMeta>>
        (outName);
    }
  } // for
  
  
} // icarus::trigger::LVDSgates::LVDSgates()

icarus::trigger::LVDSgates::LVDSgates ( LVDSgates const &  )

delete

icarus::trigger::LVDSgates::LVDSgates ( LVDSgates &&  )

delete

Member Function Documentation

template<typename Op >

TrackedTriggerGate_t icarus::trigger::LVDSgates::binaryCombineChannel ( std::vector< TrackedTriggerGate_t > const &  gates, std::vector< raw::Channel_t > const &  pairing, Op  combine  ) const

private

Combination function for the AND and OR modes; op is from GateOps.

template<typename Op >

auto icarus::trigger::LVDSgates::binaryCombineChannel	(	std::vector< TrackedTriggerGate_t > const &	gates,
		std::vector< raw::Channel_t > const &	pairing,
		Op	combine
	)		const -> TrackedTriggerGate_t

Definition at line 645 of file LVDSgates_module.cc.

                                {
  if (pairing.empty()) return discardChannels(gates, pairing);

#if 1
  
  auto byIndex = [&gates](std::size_t index) -> TrackedTriggerGate_t const&
    { return gates[index]; };
  
# if 0
  // C++20: the following loses the debug output:
  
  return icarus::trigger::OpGateColl
    (combine, pairing | std::ranges::views::transform(byIndex));
# else
  
  return icarus::trigger::OpGateColl
    (combine, util::make_transformed_span(pairing, byIndex));
  
# endif // 0
  
#else
  auto iChannel = pairing.begin();
  auto cend = pairing.end();

  // requiring that gates are at an index matching their channel number
  TrackedTriggerGate_t gate { gates[*iChannel] };

  mf::LogTrace(fLogCategory) << "Input:  " << gates[*iChannel].gate();
  while (++iChannel != cend) {

    mf::LogTrace(fLogCategory) << "Input:  " << gates[*iChannel].gate();
    gate = icarus::trigger::OpGates(combine, gate, gates[*iChannel]);

  } // while
  mf::LogTrace(fLogCategory) << "Output: " << gate.gate();

  return gate;
#endif // 0
} // icarus::trigger::LVDSgates::binaryCombineChannel()

void icarus::trigger::LVDSgates::checkInput ( std::vector< TrackedTriggerGate_t > const &  gates ) const

private

Input requirement check. Throws if requirements fail.

Definition at line 781 of file LVDSgates_module.cc.

{
  /*
   * check that 
   *  * each gate has a single channel
   *  * each gate is in the position matching its channel number
   */
  
  using icarus::trigger::gatesIn;
  
  for (auto const& [ iGate, gate ]: util::enumerate(gatesIn(gates))) {
    // gate is a OpticalTriggerGateData_t
    
    auto const expectedChannel = static_cast<raw::Channel_t>(iGate);
    
    if (gate.nChannels() != 1U) {
      cet::exception e("LVDSgates");
      e << "Requirement failure: gate #" << iGate << " includes ";
      if (!gate.hasChannels())
        e << "no channels";
      else {
        auto const& channels = gate.channels();
        auto iChannel = channels.begin();
        auto const cend = channels.end();
        e << gate.nChannels() << " channels (" << *iChannel;
        while (++iChannel != cend) e << ", " << *iChannel;
        e << ")";
      }
      e << " should have exactly one channel (" << expectedChannel << ").\n";
      throw e;
    }
    
    if (gate.channel() != expectedChannel) {
      throw cet::exception("LVDSgates")
        << "Requirement failure: gate #" << iGate << " gate covers channel "
        << gate.channel() << ", should cover " << expectedChannel
        << " instead.\n";
    }
    
  } // for
  
  MF_LOG_TRACE(fLogCategory)
    << "LVDSgates[" << moduleDescription().moduleLabel() << "]: input checked.";
  
} // icarus::trigger::LVDSgates::checkInput()

unsigned int icarus::trigger::LVDSgates::checkPairings ( ) const

private

Checks the pairing configuration, throws on error. Returns the number of configured channels.

Definition at line 691 of file LVDSgates_module.cc.

                                                         {

  //
  // collect all the errors first
  //
  auto const& geom = *(lar::providerFrom<geo::Geometry>());


  // collect configured and duplicate channel numbers
  unsigned int nEmptyGroups = 0U;
  std::set<raw::Channel_t> configuredChannels, duplicateChannels;
  for (auto const& pairing: fChannelPairing) {
    if (pairing.empty()) {
      ++nEmptyGroups;
      continue;
    }
    for (raw::Channel_t channel: pairing) {
      if (!configuredChannels.insert(channel).second)
        duplicateChannels.insert(channel);
    } // for channel
  } // for pairing

  // collect invalid channel numbers
  std::vector<raw::Channel_t> invalidChannels;
  for (raw::Channel_t channel: configuredChannels) {
    if (!geom.IsValidOpChannel(channel)) invalidChannels.push_back(channel);
  } // for configured channels

  // collect missing channels
  auto const endChannel = geom.MaxOpChannel() + 1U;
  std::vector<raw::Channel_t> missingChannels;
  for (auto channel: util::counter<raw::Channel_t>(endChannel)) {
    if (!geom.IsValidOpChannel(channel)) continue;
    if (configuredChannels.count(channel) > 0U) continue;
    missingChannels.push_back(channel);
  } // for channel

  // no error? good we are
  if (invalidChannels.empty()
    && missingChannels.empty()
    && duplicateChannels.empty()
    && (nEmptyGroups == 0U)
  ) {
    return configuredChannels.size();
  }

  // error? good we are not
  art::Exception e(art::errors::Configuration);
  e << "The pairing configuration of " << configuredChannels.size()
    << " optical channels in `ChannelPairing` presents the following errors.\n";
  if (!invalidChannels.empty()) {
    auto iChannel = invalidChannels.cbegin();
    auto const cend = invalidChannels.cend();
    e
      << invalidChannels.size()
      << " channel numbers do not represent valid channels: " << *iChannel;
    while (++iChannel != cend) e << ", " << *iChannel;
    e << ".\n";
  } // if invalid channels

  if (!missingChannels.empty()) {
    auto iChannel = missingChannels.cbegin();
    auto const cend = missingChannels.cend();
    e
      << missingChannels.size()
      << " channels do not appear in the configuration: " << *iChannel;
    while (++iChannel != cend) e << ", " << *iChannel;
    e << ".\n";
  } // if missing channels

  if (!duplicateChannels.empty()) {
    auto iChannel = duplicateChannels.cbegin();
    auto const cend = duplicateChannels.cend();
    e
      << duplicateChannels.size()
      << " channels are specified more than once: " << *iChannel;
    while (++iChannel != cend) e << ", " << *iChannel;
    e << ".\n";
  } // if duplicate channels
  
  if (nEmptyGroups > 0U) {
    e << nEmptyGroups << " channel groups are empty.";
  }
  
  throw e;
} // icarus::trigger::LVDSgates::checkPairings()

auto icarus::trigger::LVDSgates::combineChannels ( std::vector< TrackedTriggerGate_t > const &  gates, std::vector< raw::Channel_t > const &  pairing, ComboMode  comboMode  ) const

private

Performs the combination of a group of channels.

Definition at line 565 of file LVDSgates_module.cc.

                                {
  
  namespace GateOps = icarus::trigger::GateOps;
  
  switch (comboMode) {
    case ComboMode::disable:
      return discardChannels(gates, pairing);
    case ComboMode::AND:
      return binaryCombineChannel(gates, pairing, GateOps::Min);
    case ComboMode::OR:
      return binaryCombineChannel(gates, pairing, GateOps::Max);
    case ComboMode::Input1:
      return selectChannel(gates, pairing, 0U);
    case ComboMode::Input2:
      return selectChannel(gates, pairing, 1U);
    default:
      throw art::Exception(art::errors::LogicError)
        << "Unexpected combination mode (#" << static_cast<int>(comboMode)
        << ").\n";
  } // switch(comboMode)
} // icarus::trigger::LVDSgates::combineChannels()

auto icarus::trigger::LVDSgates::discardChannels ( std::vector< TrackedTriggerGate_t > const &  gates, std::vector< raw::Channel_t > const &  pairing  ) const

private

Combination function for the disable mode.

Definition at line 614 of file LVDSgates_module.cc.

                                {
  TrackedTriggerGate_t gate;
  for (raw::Channel_t channel: pairing) gate.gate().addChannel(channel);
  for (auto const& srcGate: gates) gate.tracking().add(srcGate.tracking());
  return gate;
} // icarus::trigger::LVDSgates::combineChannels()

std::string icarus::trigger::LVDSgates::makeOutputInstanceName ( art::InputTag const &  inputTag, std::string const &  defModule  )

staticprivate

Converts an input tag into an instance name for the corresponding output.

Definition at line 878 of file LVDSgates_module.cc.

{
  return (inputTag.label() == defModule)
    ? inputTag.instance()
    : inputTag.instance().empty()
      ? inputTag.label(): inputTag.label() + inputTag.instance()
    ;
} // icarus::trigger::LVDSgates::makeTag()

art::InputTag icarus::trigger::LVDSgates::makeTag ( std::string const &  thresholdStr, std::string const &  defModule  )

staticprivate

Converts a threshold string into an input tag.

Definition at line 862 of file LVDSgates_module.cc.

{
  return (thresholdStr.find(':') != std::string::npos)
    ? art::InputTag{ thresholdStr }
    : defModule.empty()
      ? throw (art::Exception(art::errors::Configuration)
        << "No default module label (`TriggerGatesTag`) specified"
           ", and it's needed for threshold '"
        << thresholdStr << "'.\n")
      : art::InputTag{ defModule, thresholdStr }
    ;
} // icarus::trigger::LVDSgates::makeTag()

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

delete

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

delete

void icarus::trigger::LVDSgates::produce ( art::Event &  event )

overridevirtual

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

Definition at line 469 of file LVDSgates_module.cc.

                                                    {
  
  icarus::trigger::OpDetWaveformMetaDataProductMap_t waveformMap;
  
  for (auto const& [ thresholdStr, srcInfo ]: fADCthresholds) {
    
    produceThreshold(event, waveformMap, thresholdStr, srcInfo);
    
  } // for all thresholds
  
} // icarus::trigger::LVDSgates::produce()

void icarus::trigger::LVDSgates::produceThreshold ( art::Event &  event, icarus::trigger::OpDetWaveformMetaDataProductMap_t &  waveformMap, std::string const &  thresholdStr, SourceInfo_t const &  srcInfo  ) const

private

Completely processes the data for the specified threshold.

Definition at line 485 of file LVDSgates_module.cc.

        {
  
  auto const& [ dataTag, outputInstanceName ] = srcInfo;
  
  mf::LogDebug(fLogCategory)
    << "Processing threshold " << thresholdStr
    << " from '" << dataTag.encode() << "'";
  
  using icarus::trigger::OpticalTriggerGateData_t; // for convenience
  
  std::vector<TrackedTriggerGate_t> const& gates
    = ReadTriggerGates(event, dataTag, waveformMap);

  checkInput(gates);
  
  std::vector<TrackedTriggerGate_t> combinedGates;
  
  std::vector<std::vector<raw::Channel_t>> const cleanedChannels
    = removeChannels(fChannelPairing, fIgnoreChannels);

  for (std::vector<raw::Channel_t> const& pairing: cleanedChannels) {
    if (pairing.empty()) continue; // ???
    
    combinedGates.push_back(combineChannels(gates, pairing, fComboMode));
    
  } // for
  
  // transform the data; after this line, `gates` is not usable any more
  art::PtrMaker<OpticalTriggerGateData_t> const makeGatePtr
    (event, outputInstanceName);
  auto [ outputGates, outputAssns ]
    = icarus::trigger::transformIntoOpticalTriggerGate
    (std::move(combinedGates), makeGatePtr, waveformMap);
  
  mf::LogTrace(fLogCategory)
    << "Threshold " << thresholdStr << " ('" << dataTag.encode() << "'): "
    << gates.size() << " input channels, "
    << outputGates.size() << " output channels (+"
    << outputAssns.size() << " associations to waveforms) into '"
    << moduleDescription().moduleLabel() << ":" << outputInstanceName << "'"
    ;

  
  if (fProduceWaveformAssns) {
    
    // produce one gate-waveform association for each gate-metadata one;
    // do it now while the gate/metadata association is still locally available
    icarus::trigger::OpDetWaveformMetaMatcher waveformMetaMatcher{ event };
    art::Assns<OpticalTriggerGateData_t, raw::OpDetWaveform> outputWaveAssns;
    for (auto const [ gatePtr, metaPtr ]: outputAssns)
      outputWaveAssns.addSingle(gatePtr, waveformMetaMatcher(metaPtr));
    
    event.put(
      std::make_unique<art::Assns<OpticalTriggerGateData_t, raw::OpDetWaveform>>
        (std::move(outputWaveAssns)),
      outputInstanceName
      );
    
  } // if fProduceWaveformAssns
  
  event.put(
    std::make_unique<std::vector<OpticalTriggerGateData_t>>
      (std::move(outputGates)),
    outputInstanceName
    );
  event.put(
    std::make_unique<art::Assns<OpticalTriggerGateData_t, sbn::OpDetWaveformMeta>>
      (std::move(outputAssns)),
    outputInstanceName
    );
  
} // icarus::trigger::LVDSgates::produceThreshold()

auto icarus::trigger::LVDSgates::ReadTriggerGates ( art::Event const &  event, art::InputTag const &  dataTag, icarus::trigger::OpDetWaveformMetaDataProductMap_t &  waveformMap  )

staticprivate

Assembles trigger gates from dataTag data products in event.

Definition at line 841 of file LVDSgates_module.cc.

                                     {
  using icarus::trigger::OpticalTriggerGateData_t;
  
  auto const& assns =
    event.getProduct<art::Assns<OpticalTriggerGateData_t, sbn::OpDetWaveformMeta>>
    (dataTag);
  
  UpdateWaveformMap(waveformMap, assns);
  
  return icarus::trigger::FillTriggerGates
    (event.getProduct<std::vector<OpticalTriggerGateData_t>>(dataTag), assns);
  
} // icarus::trigger::LVDSgates::ReadTriggerGates()

std::vector< std::vector< raw::Channel_t > > icarus::trigger::LVDSgates::removeChannels ( std::vector< std::vector< raw::Channel_t >>  channelPairing, std::vector< raw::Channel_t > const &  ignoreChannels  ) const

private

Removes all the channel in ignoreChannels from channelPairing.

Returns

a copy of channelPairing with no element from ignoreChannels

Channel lists in the returned list may become empty.

Definition at line 593 of file LVDSgates_module.cc.

          {

  for (std::vector<raw::Channel_t>& channels: channelPairing) {
    for (unsigned int j = channels.size(); j-- > 0; ) {
      std::vector<raw::Channel_t>::const_iterator const it
        = find(ignoreChannels.begin(), ignoreChannels.end(), channels[j]);
      if (it != fIgnoreChannels.end()) {
        channels.erase(channels.begin() + j);
      }
    }
  }

  return channelPairing;

} // icarus::trigger::LVDSgates::removeChannels()

auto icarus::trigger::LVDSgates::selectChannel ( std::vector< TrackedTriggerGate_t > const &  gates, std::vector< raw::Channel_t > const &  pairing, std::size_t  chosenIndex  ) const

private

Combination function for the input1 and input2 modes.

Definition at line 626 of file LVDSgates_module.cc.

                                {
  // requiring that gates are at an index matching their channel number
  TrackedTriggerGate_t gate { gates[pairing[chosenIndex]] };
  for (raw::Channel_t channel: pairing) {
    mf::LogTrace(fLogCategory) << "Input:  " << gates[channel].gate();
    gate.gate().addChannel(channel);
  }
  mf::LogTrace(fLogCategory) << "Output: " << gate.gate();
  for (auto const& srcGate: gates) gate.tracking().add(srcGate.tracking());
  return gate;
} // icarus::trigger::LVDSgates::selectChannel()

void icarus::trigger::LVDSgates::UpdateWaveformMap ( icarus::trigger::OpDetWaveformMetaDataProductMap_t &  map, art::Assns< TriggerGateData_t, sbn::OpDetWaveformMeta > const &  assns  )

staticprivate

Adds the associated waveforms into the map.

Definition at line 829 of file LVDSgates_module.cc.

  {
  
  for (art::Ptr<sbn::OpDetWaveformMeta> const& wave: util::get_elements<1U>(assns))
    map.emplace(wave.get(), wave);
  
} // icarus::trigger::LVDSgates::UpdateWaveformMap()

Member Data Documentation

std::map<std::string, SourceInfo_t> icarus::trigger::LVDSgates::fADCthresholds

private

ADC thresholds to read, and the input tag connected to their data.

Definition at line 293 of file LVDSgates_module.cc.

std::vector<std::vector<raw::Channel_t> > icarus::trigger::LVDSgates::fChannelPairing

private

Pairing of optical detector channels.

Definition at line 296 of file LVDSgates_module.cc.

ComboMode icarus::trigger::LVDSgates::fComboMode

private

The operation used to combinate channels.

Definition at line 297 of file LVDSgates_module.cc.

std::vector<raw::Channel_t> icarus::trigger::LVDSgates::fIgnoreChannels

private

Definition at line 299 of file LVDSgates_module.cc.

std::string icarus::trigger::LVDSgates::fLogCategory

private

Message facility stream category for output.

Definition at line 304 of file LVDSgates_module.cc.

bool icarus::trigger::LVDSgates::fProduceWaveformAssns

private

Whether to produce gate/waveform associations.

Definition at line 302 of file LVDSgates_module.cc.

---

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

• LVDSgates_module.cc