icarus::trigger::SlidingWindowCombinerAlg Class Reference

#include <SlidingWindowCombinerAlg.h>

Public Types
using	WindowChannels_t = icarus::trigger::TriggerWindowChannels_t
	Type of optical detector channel list in a window. More...
using	Windows_t = icarus::trigger::TriggerWindowDefs_t
	Type of content of all windows. More...
using	TrackedTriggerGate_t = icarus::trigger::TrackedOpticalTriggerGate< sbn::OpDetWaveformMeta >
	Trigger gate data type (tracks sources via sbn::OpDetWaveformMeta). More...

Public Member Functions
	SlidingWindowCombinerAlg (Windows_t const &windows, std::vector< raw::Channel_t > missingChannels={}, bool requireFullCoverage=true, std::string logCategory="SlidingWindowCombinerAlg")
	Constructor: learns about the window pattern (keeps a reference). More...
std::vector< TrackedTriggerGate_t >	combine (std::vector< TrackedTriggerGate_t > const &gates) const
	Combines the gates according to the configured grouping. More...
bool	isMissingChannel (raw::Channel_t channel) const
	Returns if channel is configured to be missing. More...

Private Types
using	TriggerGateIndex_t = icarus::trigger::TriggerGateIndex< TrackedTriggerGate_t >

Private Member Functions
void	checkInput (TriggerGateIndex_t const &gates) const
	Throws an exception if the gates are not suitable for input. More...
TrackedTriggerGate_t	combineChannels (TriggerGateIndex_t const &gates, WindowChannels_t const &channels) const
	Returns the combination of the channels selected from the gates. More...
WindowChannels_t::const_iterator	firstChannelPresent (WindowChannels_t const &channels) const
	Returns an iterator to the first of the channels which is not missing. More...

Static Private Member Functions
static bool	mergeGateInto (TrackedTriggerGate_t &dest, TrackedTriggerGate_t const &input)
static Windows_t	sortedWindowChannels (Windows_t const &windows)
	Returns windows with numerically sorted channel numbers. More...
static std::vector < raw::Channel_t >	sortChannels (std::vector< raw::Channel_t > channels)
	Returns a sorted copy of channels. More...
template<typename Cont , typename T >
static bool	inList (Cont const &c, T const &value)
	Returns whether the container c has value. More...

Private Attributes
Windows_t const	fWindowChannels
	Content of channels of each window. More...
std::vector< raw::Channel_t >	fMissingChannels
	Channels known (and required) to be missing (sorted). More...
bool const	fRequireFullCoverage
	Whether to require all channels to be used. More...
std::string	fLogCategory
	Category for messages to MessageFacility. More...

Detailed Description

Definition at line 43 of file SlidingWindowCombinerAlg.h.

Member Typedef Documentation

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

Trigger gate data type (tracks sources via sbn::OpDetWaveformMeta).

Definition at line 54 of file SlidingWindowCombinerAlg.h.

using icarus::trigger::SlidingWindowCombinerAlg::TriggerGateIndex_t = icarus::trigger::TriggerGateIndex<TrackedTriggerGate_t>

private

Definition at line 75 of file SlidingWindowCombinerAlg.h.

using icarus::trigger::SlidingWindowCombinerAlg::WindowChannels_t = icarus::trigger::TriggerWindowChannels_t

Type of optical detector channel list in a window.

Definition at line 47 of file SlidingWindowCombinerAlg.h.

using icarus::trigger::SlidingWindowCombinerAlg::Windows_t = icarus::trigger::TriggerWindowDefs_t

Type of content of all windows.

Definition at line 50 of file SlidingWindowCombinerAlg.h.

Constructor & Destructor Documentation

icarus::trigger::SlidingWindowCombinerAlg::SlidingWindowCombinerAlg	(	Windows_t const &	windows,
		std::vector< raw::Channel_t >	missingChannels = {},
		bool	requireFullCoverage = true,
		std::string	logCategory = "SlidingWindowCombinerAlg"
	)

Constructor: learns about the window pattern (keeps a reference).

Definition at line 19 of file SlidingWindowCombinerAlg.cxx.

  : fWindowChannels(sortedWindowChannels(windows))
  , fMissingChannels(sortChannels(std::move(missingChannels)))
  , fRequireFullCoverage(requireFullCoverage)
  , fLogCategory(std::move(logCategory))
  {}

Member Function Documentation

void icarus::trigger::SlidingWindowCombinerAlg::checkInput ( TriggerGateIndex_t const &  gates ) const

private

Throws an exception if the gates are not suitable for input.

Definition at line 56 of file SlidingWindowCombinerAlg.cxx.

{
  /*
   * Checks:
   *
   * * no gate is only partially contained in a window
   * * no channel in the gates is skipped (optional)
   *
   */

  auto const isChannelInWindow
    = [](raw::Channel_t channel, std::vector<raw::Channel_t> const& window)
      { return std::binary_search(window.begin(), window.end(), channel); };

  std::set<TrackedTriggerGate_t const*> usedGates;
  for (std::vector<raw::Channel_t> const& window: fWindowChannels) {

    for (raw::Channel_t const channel: window) {

      if (isMissingChannel(channel)) continue;

      //
      // check that we have all the channels we need
      //
      TrackedTriggerGate_t const* gate = gateIndex.find(channel);
      if (!gate) {
        cet::exception e("SlidingWindowCombinerAlg");
        e << "SlidingWindowCombinerAlg::checkInput(): No gate has channel "
          << channel << ", required in the window including channels: ";
        for (raw::Channel_t const channel: window) e << " " << channel;
        e << ".\n";
        throw e;
      }

      //
      // check that all channels of this gate are in this window
      //
      for (raw::Channel_t const gateChannel: gate->channels()) {
        if (isChannelInWindow(gateChannel, window)) continue;

        cet::exception e("SlidingWindowCombinerAlg");
        e << "SlidingWindowCombinerAlg::checkInput(): gate with channels {";
        for (raw::Channel_t const channel: gate->channels())
          e << " " << channel;
        e << " } is not fully included in window including channels: ";
        for (raw::Channel_t const channel: window) e << " " << channel;
        e << " (" << gateChannel << " is missing).\n";
        throw e;
      } // for gate channels

      usedGates.insert(gate);
    } // for channel in window

  } // for windows

  //
  // check for channels that should be missing but are here
  //
  std::vector<raw::Channel_t> spuriousChannels;
  for (raw::Channel_t const channel: fMissingChannels) {
    if (gateIndex.find(channel)) spuriousChannels.push_back(channel);
  } // for
  if (!spuriousChannels.empty()) {
    cet::exception e("SlidingWindowCombinerAlg");
    e << "SlidingWindowCombinerAlg::checkInput(): "
      << spuriousChannels.size() << " of the " << fMissingChannels.size()
      << " supposedly missing channels are actually included:";
    for (raw::Channel_t const channel: spuriousChannels) e << " " << channel;
    e << "\n";
    throw e;
  }
  
  //
  // check that all channels are here (except known missing ones)
  //
  if (fRequireFullCoverage) {
    std::set<TrackedTriggerGate_t const*> allGates;
    for (auto const channel: util::counter<raw::Channel_t >(gateIndex.nChannels())) {
      if (isMissingChannel(channel)) continue;
      allGates.insert(&(gateIndex[channel]));
    }

    std::vector<TrackedTriggerGate_t const*> unusedGates;
    std::set_difference(
      allGates.cbegin(), allGates.cend(), usedGates.cbegin(), usedGates.cend(),
      std::back_inserter(unusedGates)
      );
    if (!unusedGates.empty()) {
      // we don't have much information to identify "which" gates...
      cet::exception e("SlidingWindowCombinerAlg");
      e << "SlidingWindowCombinerAlg::checkInput(): "
        << "used only " << usedGates.size() << "/" << allGates.size()
        << " input trigger gates, " << unusedGates.size() << " were not used:";
      for (TrackedTriggerGate_t const* gate: unusedGates) {
        e << "{";
        for (raw::Channel_t const channel: gate->channels())
          e << " ch:" << std::to_string(channel);
        e << " }";
      } // for
      e << "\n";
      throw e;
    } // if unused
  } // if full coverage

} // icarus::trigger::SlidingWindowCombinerAlg::checkInput()

auto icarus::trigger::SlidingWindowCombinerAlg::combine

(

std::vector< TrackedTriggerGate_t > const &

gates

)

const

Combines the gates according to the configured grouping.

Definition at line 34 of file SlidingWindowCombinerAlg.cxx.

{

  TriggerGateIndex_t gateIndex { gates };

  checkInput(gateIndex);

  std::vector<TrackedTriggerGate_t> combinedGates;
  for (std::vector<raw::Channel_t> const& channels: fWindowChannels) {
    assert(!channels.empty());

    combinedGates.push_back(combineChannels(gateIndex, channels));

  } // for

  return combinedGates;
} // icarus::trigger::SlidingWindowCombinerAlg::combine()

auto icarus::trigger::SlidingWindowCombinerAlg::combineChannels ( TriggerGateIndex_t const &  gates, WindowChannels_t const &  channels  ) const

private

Returns the combination of the channels selected from the gates.

Definition at line 165 of file SlidingWindowCombinerAlg.cxx.

{
  assert(!channels.empty());

  auto iChannel = firstChannelPresent(channels);
  auto const cend = channels.end();
  if (iChannel == cend) return {}; // empty gate, no channels inside

  TrackedTriggerGate_t const& firstGate = gates[*iChannel];

  // add the first gate
  TrackedTriggerGate_t gate { firstGate };

  mf::LogTrace(fLogCategory) << "Input:  " << firstGate;
  while (++iChannel != cend) {
    if (isMissingChannel(*iChannel)) continue;

    TrackedTriggerGate_t const& inputGate = gates[*iChannel];

    mf::LogTrace(fLogCategory) << "Input:  " << inputGate;
    mergeGateInto(gate, inputGate);

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

  return gate;

} // icarus::trigger::SlidingWindowCombinerAlg::combineChannel()

auto icarus::trigger::SlidingWindowCombinerAlg::firstChannelPresent ( WindowChannels_t const &  channels ) const

private

Returns an iterator to the first of the channels which is not missing.

Definition at line 198 of file SlidingWindowCombinerAlg.cxx.

{
  auto iChannel = channels.begin();
  auto const cend = channels.end();
  while (iChannel != cend) if (!isMissingChannel(*iChannel)) return iChannel;
  return cend;
} // icarus::trigger::SlidingWindowCombinerAlg::firstChannelPresent()

template<typename Cont , typename T >

static bool icarus::trigger::SlidingWindowCombinerAlg::inList ( Cont const &  c, T const &  value  )

inlinestaticprivate

Returns whether the container c has value.

Definition at line 114 of file SlidingWindowCombinerAlg.h.

    { auto cend = c.end(); return std::find(c.begin(), cend, value) != cend; }

bool icarus::trigger::SlidingWindowCombinerAlg::isMissingChannel ( raw::Channel_t  channel ) const

inline

Returns if channel is configured to be missing.

Definition at line 125 of file SlidingWindowCombinerAlg.h.

{
  return std::find(fMissingChannels.begin(), fMissingChannels.end(), channel)
    != fMissingChannels.end();
} // icarus::trigger::SlidingWindowCombinerAlg::isMissingChannel()

bool icarus::trigger::SlidingWindowCombinerAlg::mergeGateInto ( TrackedTriggerGate_t &  dest, TrackedTriggerGate_t const &  input  )

staticprivate

Adds the gate data of input to dest, unless it's already included.

Returns

whether the addition happened

Definition at line 209 of file SlidingWindowCombinerAlg.cxx.

{
  // loose check: assumes channel sets of all possible inputs do not overlap
  // and checks whether the destination has already any one of input channels
  auto const& channels = dest.gate().channels();
  if (inList(channels, *(input.gate().channels().begin()))) return false;

  dest = icarus::trigger::sumGates(std::move(dest), input);

  return true;

} // icarus::trigger::SlidingWindowCombinerAlg::mergeGateInto()

auto icarus::trigger::SlidingWindowCombinerAlg::sortChannels ( std::vector< raw::Channel_t >  channels )

staticprivate

Returns a sorted copy of channels.

Definition at line 235 of file SlidingWindowCombinerAlg.cxx.

{
  std::sort(channels.begin(), channels.end());
  return channels;
} // icarus::trigger::SlidingWindowCombinerAlg::sortChannels

auto icarus::trigger::SlidingWindowCombinerAlg::sortedWindowChannels ( Windows_t const &  windows )

staticprivate

Returns windows with numerically sorted channel numbers.

Definition at line 225 of file SlidingWindowCombinerAlg.cxx.

{
  Windows_t newWindows { windows };
  for (auto& window: newWindows) std::sort(window.begin(), window.end());
  return newWindows;
} // icarus::trigger::SlidingWindowCombinerAlg::sortWindowChannels()

Member Data Documentation

std::string icarus::trigger::SlidingWindowCombinerAlg::fLogCategory

private

Category for messages to MessageFacility.

Definition at line 86 of file SlidingWindowCombinerAlg.h.

std::vector<raw::Channel_t> icarus::trigger::SlidingWindowCombinerAlg::fMissingChannels

private

Channels known (and required) to be missing (sorted).

Definition at line 81 of file SlidingWindowCombinerAlg.h.

bool const icarus::trigger::SlidingWindowCombinerAlg::fRequireFullCoverage

private

Whether to require all channels to be used.

Definition at line 84 of file SlidingWindowCombinerAlg.h.

Windows_t const icarus::trigger::SlidingWindowCombinerAlg::fWindowChannels

private

Content of channels of each window.

Definition at line 78 of file SlidingWindowCombinerAlg.h.

---

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

• SlidingWindowCombinerAlg.h
• SlidingWindowCombinerAlg.cxx