daq::TriggerDecoder Class Reference

Tool decoding the trigger information from DAQ. More...

Inheritance diagram for daq::TriggerDecoder:

Classes
struct	TriggerGateTypes
	Codes of gate types from the trigger hardware. More...

Public Member Functions
	TriggerDecoder (fhicl::ParameterSet const &pset)
virtual void	produces (art::ProducesCollector &) override
	The space point building should output the hit collection for those hits which combine to form space points - a nice noise filter! More...
virtual void	configure (const fhicl::ParameterSet &) override
	Interface for configuring the particular algorithm tool. More...
virtual void	initializeDataProducts () override
	Initialize any data products the tool will output. More...
virtual void	process_fragment (const artdaq::Fragment &fragment) override
	Given a set of recob hits, run DBscan to form 3D clusters. More...
virtual void	outputDataProducts (art::Event &event) override
	Output the data products to the event store. More...
	TriggerDecoder (fhicl::ParameterSet const &pset)
virtual void	consumes (art::ConsumesCollector &collector) override
	Declare to the framework what you expect to read. More...
virtual void	produces (art::ProducesCollector &) override
	The space point building should output the hit collection for those hits which combine to form space points - a nice noise filter! More...
virtual void	configure (const fhicl::ParameterSet &) override
	Interface for configuring the particular algorithm tool. More...
virtual void	initializeDataProducts () override
	Initialize any data products the tool will output. More...
virtual void	setupRun (art::Run const &run) override
	Preparation to process a new run. More...
virtual void	process_fragment (const artdaq::Fragment &fragment) override
	Given a set of recob hits, run DBscan to form 3D clusters. More...
virtual void	outputDataProducts (art::Event &event) override
	Output the data products to the event store. More...
Public Member Functions inherited from daq::IDecoder
virtual	~IDecoder () noexcept=default
	Virtual Destructor. More...
virtual void	setupEvent (art::Event const &event)
	Preparation to process a new event. More...

Private Types
using	nanoseconds = util::quantities::nanosecond
using	TriggerCollection = std::vector< raw::ExternalTrigger >
using	TriggerPtr = std::unique_ptr< TriggerCollection >
using	RelativeTriggerCollection = std::vector< raw::Trigger >
using	BeamGateInfoCollection = std::vector< sim::BeamGateInfo >
using	BeamGateInfoPtr = std::unique_ptr< BeamGateInfoCollection >
using	ExtraInfoPtr = std::unique_ptr< sbn::ExtraTriggerInfo >
using	microseconds = util::quantities::microsecond
using	nanoseconds = util::quantities::nanosecond
using	TriggerCollection = std::vector< raw::ExternalTrigger >
using	TriggerPtr = std::unique_ptr< TriggerCollection >
using	RelativeTriggerCollection = std::vector< raw::Trigger >
using	BeamGateInfoCollection = std::vector< sim::BeamGateInfo >
using	BeamGateInfoPtr = std::unique_ptr< BeamGateInfoCollection >
using	ExtraInfoPtr = std::unique_ptr< sbn::ExtraTriggerInfo >

Private Member Functions
icarus::ICARUSTriggerUDPFragment	makeTriggerFragment (artdaq::Fragment const &fragment) const
	Creates a ICARUSTriggerInfo from a generic fragment. More...
icarus::ICARUSTriggerInfo	parseTriggerString (std::string_view data) const
	Parses the trigger data packet with the "standard" parser. More...
icarus::ICARUSTriggerV2Fragment	makeTriggerFragment (artdaq::Fragment const &fragment) const
	Creates a ICARUSTriggerInfo from a generic fragment. More...
icarus::ICARUSTriggerInfo	parseTriggerString (std::string_view data) const
	Parses the trigger data packet with the "standard" parser. More...
icarus::KeyValuesData	parseTriggerStringAsCSV (std::string const &data) const
	Parses the trigger data packet with a CSV parser. More...

Static Private Member Functions
static std::string_view	firstLine (std::string const &s, std::string const &endl="\0\n\r"s)
static std::uint64_t	makeTimestamp (unsigned int s, unsigned int ns)
	Combines second and nanosecond counts into a 64-bit timestamp. More...
static long long int	timestampDiff (std::uint64_t a, std::uint64_t b)
	Returns the difference a - b. More...
static std::string_view	firstLine (std::string const &s, std::string const &endl="\0\n\r"s)
static std::uint64_t	makeTimestamp (unsigned int s, unsigned int ns)
	Combines second and nanosecond counts into a 64-bit timestamp. More...
static long long int	timestampDiff (std::uint64_t a, std::uint64_t b)
	Returns the difference a - b. More...
static std::uint64_t	encodeLVDSbits (short int cryostat, short int connector, std::uint64_t connectorWord)
static sim::BeamType_t	simGateType (sbn::triggerSource source)
	Returns the beam type corresponding to the specified trigger source. More...

Private Attributes
TriggerPtr	fTrigger
TriggerPtr	fPrevTrigger
std::unique_ptr < RelativeTriggerCollection >	fRelTrigger
ExtraInfoPtr	fTriggerExtra
BeamGateInfoPtr	fBeamGateInfo
bool	fDiagnosticOutput
	Produces large number of diagnostic messages, use with caution! More...
bool	fDebug
	Use this for debugging this tool. More...
long	fLastEvent = 0
detinfo::DetectorTimings const	fDetTimings
	Detector clocks and timings. More...
art::InputTag	fTriggerConfigTag
	Data product with hardware trigger configuration. More...
icarus::TriggerConfiguration const *	fTriggerConfiguration = nullptr
	Cached pointer to the trigger configuration of the current run, if any. More...

Static Private Attributes
static std::string const	CurrentTriggerInstanceName {}
	Name of the data product instance for the current trigger. More...
static std::string const	PreviousTriggerInstanceName { "previous" }
	Name of the data product instance for the previous trigger. More...
static constexpr double	UnknownBeamTime = std::numeric_limits<double>::max()
static constexpr nanoseconds	BNBgateDuration { 1600. }
static constexpr nanoseconds	NuMIgateDuration { 9500. }

Detailed Description

Tool decoding the trigger information from DAQ.

Produces:

• std::vector<raw::ExternalTrigger> containing the absolute trigger time stamp from the White Rabbit system, and a trigger count; it always includes a single entry (zero might be supported).

• std::vector<raw::Trigger> containing:

  • TriggerTime(): the relative time of the trigger as reported in the White Rabbit timestamp, measured in the electronics time scale (for ICARUS it will always be detinfo::DetectorClocksData::TriggerTime()).
  • BeamGateTime(): relative time of the announced arrival of the beam (currently not available) also in electronics time scale.
  • TriggerCount(): the trigger count from the beginning of the run.
  • TriggerBits(): includes the beam(s) with an open gate when the trigger happened (currently only one beam gate per trigger); definitions are in sbn::beamType namespace.

  It always includes a single entry (zero might be supported).

• std::vector<sim::BeamGateInfo> containing information on the "main" beam gate associated to each trigger (a way to say that if by any chance there are more than one bits set for the trigger, this gate will pick only one of them):
  • Start(): relative time of the announced arrival of the beam (currently not available), in simulation time scale.
  • Width(): duration of the gate, in nanoseconds; currently set to a nominal value.
  • BeamType(): the type of the beam gate being described (BNB, NuMI).
• sbn::ExtraTriggerInfo: the most complete collection of information, duplicating also some from the other data products. Some of the information is not available yet: if a count is not available, its value is set to 0 (which is an invalid value because their valid range starts with 1 since they include the current event), and if a timestamp is not available it is set to sbn::ExtraTriggerInfo::NoTimestamp; these two conditions can be checked with static methods sbn::ExtraTriggerInfo::isValidTimestamp() and sbn::ExtraTriggerInfo::isValidCount() respectively. Note that differently from the usual, this is a single object, not a collection; also, this data product has no instance name. The information already available includes:
  • sourceType: the type of beam or trigger source, a value from sbn::triggerSource (equivalent to raw::Trigger::TriggerBits(), but in the form of an enumerator rather than a bit mask).
  • triggerTimestamp: same as raw::ExternalTrigger::GetTrigTime() (nanoseconds from the Epoch, Coordinated Universal Time).
  • beamGateTimestamp: absolute time of the beam gate opening as reported by the trigger hardware, directly comparable with triggerTimestamp (same scale and unit).
  • triggerID: same as raw::ExternalTrigger::GetTrigID(). Should match the event number.
  • gateID: the count of gates since the beginning of the run, as reported by the trigger hardware.

Besides the main data product (empty instance name) an additional std::vector<raw::ExternalTrigger> data product with instance name "previous" is also produced, which relays the same kind of information but for the previous trigger. This information also comes from the trigger DAQ. If no previous trigger is available, this collection will be empty.

Timestamps and corrections

The reference trigger time is driven by the trigger fragment time, which is expected to have been derived from the actual trigger time from the White Rabbit system properly corrected to UTC by the board reader.

All absolute timestamps are corrected to be on that same scale. The absolute timestamps related to the White Rabbit time are added an offset to achieve this correction; this offset is stored in the data product (sbn::ExtraTriggerInfo::WRtimeToTriggerTime).

Produces:

• std::vector<raw::ExternalTrigger> containing the absolute trigger time stamp from the White Rabbit system, and a trigger count; it always includes a single entry (zero might be supported).

• std::vector<raw::Trigger> containing:

  • TriggerTime(): the relative time of the trigger as reported in the White Rabbit timestamp, measured in the electronics time scale (for ICARUS it will always be detinfo::DetectorClocksData::TriggerTime()).
  • BeamGateTime(): relative time of the announced arrival of the beam, also in electronics time scale.
  • TriggerCount(): the trigger count from the beginning of the run.
  • TriggerBits(): includes the beam(s) with an open gate when the trigger happened (currently only one beam gate per trigger); definitions are in sbn::beamType namespace.

  It always includes a single entry (zero might be supported).

• std::vector<sim::BeamGateInfo> containing information on the "main" beam gate associated to each trigger (a way to say that if by any chance there are more than one bits set for the trigger, this gate will pick only one of them):
  • Start(): relative time of the announced arrival of the beam, in simulation time scale.
  • Width(): duration of the gate, in nanoseconds; read from trigger configuration if specified (TrigConfigLabel), set to 0 otherwise.
  • BeamType(): the type of the beam gate being described (BNB, NuMI).

• sbn::ExtraTriggerInfo: the most complete collection of information, duplicating also some from the other data products. Note that differently from the usual, this is a single object, not a collection; also, this data product has no instance name. The information already available includes:

  • sourceType: the type of beam or trigger source, a value from sbn::triggerSource (equivalent to raw::Trigger::TriggerBits(), but in the form of an enumerator rather than a bit mask). Also called gate type.
  • triggerTimestamp: same as raw::ExternalTrigger::GetTrigTime() (nanoseconds from the Epoch, Coordinated Universal Time).
  • beamGateTimestamp: absolute time of the beam gate opening as reported by the trigger hardware, directly comparable with triggerTimestamp (same scale and unit).
  • enableGateTimestamp: absolute time of the enable gate opening as reported by the trigger hardware, directly comparable with triggerTimestamp (same scale and unit). This is the gate that enables the generation of trigger primitives and the off-spill readout of PMT. Its duration can be found in the trigger configuration data product (icarus::TriggerConfiguration).
  • triggerID: same as raw::ExternalTrigger::GetTrigID(). Should match the event number.
  • gateID: the count of gates since the beginning of the run, as reported by the trigger hardware.
  • gateCountFromPreviousTrigger: number of gates since the last trigger: specifically, if this trigger is e.g. from off-beam BNB gate, this is the number of off-beam BNB gates from the last off-beam BNB trigger (minimum number is 1, since that gate is included).
  • previousTriggerTimestamp: absolute timestamp of the previous trigger from this source. For example, if this trigger is from an off-beam BNB gate, this represents the previous off-beam BNB trigger.
  • gateCount: total number of gates of this type (triggered or not) from the beginning of the run (minimum 1 since this one is included). For example, if this trigger is from an off-beam BNB gate, this is the number of off-beam BNB gates from the beginning of the run.
  • triggerCount: total number of triggers from gates of this type from the beginning of the run (minimum 1 since this one is included). For example, if this trigger is from an off-beam BNB gate, this is the number of off-beam BNB triggers from the beginning of the run.
  • anyTriggerCountFromPreviousTrigger: number of triggers that occurred since the last trigger of this time (the one with timestamp previousTriggerTimestamp). For example, if this trigger is from an off-beam BNB gate, this is the number of triggers from any gate (including also e.g. off-beam NuMI, BNB, calibration...) that occurred from the previous off-beam BNB trigger.
  • anyGateCountFromAnyPreviousTrigger: how many gates have passed since the last trigger (reported by anyPreviousTriggerTimestamp). The minimum value is 1.
  • anyPreviousTriggerTimestamp: absolute timestamp of the previous trigger (from any source). For example, if this trigger is from an off-beam BNB gate, and the previous was from a NuMI gate, this represents that previous (NuMI) trigger.
  • anyPreviousTriggerSourceType: the type of gate of the previous trigger (the one reported by anyPreviousTriggerTimestamp).
  • WRtimeToTriggerTime (nanoseconds): correction added to the GPS/White Rabbit time to obtain the trigger timestamp (normally it's the conversion from TAI to NTP timestamps).
  • triggerLocationBits: whether the trigger came from the east or west cryostat (currently the triggers combine the two opposite PMT walls, so there is no TPC-level granularity).
  • cryostats: information per cryostat (east first, then west). Note however that only the cryostats that are mentioned in triggerLocationBits have the information filled.
    • triggerCount: number of triggers in this cryostat fired during the trigger window; only the first one becomes the global trigger, but we still keep the count of how many happen. Its value is 0 when trigger happened from elsewhere.

    • LVDSstatus: information per PMT wall (i.e. TPC; east first, then west) of the LVDS signals of the discriminated PMT pairs at the time of the global trigger. All bits are 0 when trigger happened elsewhere. Otherwise, the encoding is currently implemented in terms of hardware connectors as follows:

      • east wall: 00<C3P2><C3P1><C3P0>00<C2P2><C2P1><C2P0>
      • west wall: 00<C1P2><C1P1><C1P0>00<C0P2><C0P1><C0P0>

      For the expected matching with PMT, see the documentation of sbn::ExtraTriggerInfo::CryostatInfo::LVDSstatus.

  Information may be missing. If a count is not available, its value is set to 0 (which is an invalid value because their valid range starts with 1 since they include the current event), and if a timestamp is not available it is set to sbn::ExtraTriggerInfo::NoTimestamp; these two conditions can be checked with static methods sbn::ExtraTriggerInfo::isValidTimestamp() and sbn::ExtraTriggerInfo::isValidCount() respectively.

Besides the main data product (empty instance name) an additional std::vector<raw::ExternalTrigger> data product with instance name "previous" is also produced, which relays the same kind of information but for the previous trigger. This information also comes from the trigger DAQ. If no previous trigger is available, this collection will be empty.

Timestamps and corrections

The reference trigger time is driven by the trigger fragment time, which is expected to have been derived from the actual trigger time from the White Rabbit system properly corrected to UTC by the board reader.

All absolute timestamps are corrected to be on that same scale. The absolute timestamps related to the White Rabbit time are added an offset to achieve this correction; this offset is stored in the data product (sbn::ExtraTriggerInfo::WRtimeToTriggerTime).

Configuration

• TrigConfigLabel (input tag, mandatory): tag of the trigger configuration data product (see icarus::TriggerConfigurationExtractor module) to be used. Specifying its tag is mandatory, but if it is explicitly specified empty, the decoder will try to work around its absence.
• DiagnosticOutput (flag, default: false): prints on console trigger data diagnostics (including a full dump of the parsed content).
• Debug (flag, default: false): prints on console decoding debug information, including a dump of the trigger data fragment.

Definition at line 128 of file TriggerDecoder_tool.cc.

Member Typedef Documentation

using daq::TriggerDecoder::BeamGateInfoCollection = std::vector<sim::BeamGateInfo>

private

Definition at line 144 of file TriggerDecoder_tool.cc.

using daq::TriggerDecoder::BeamGateInfoCollection = std::vector<sim::BeamGateInfo>

private

Definition at line 230 of file TriggerDecoderV2_tool.cc.

using daq::TriggerDecoder::BeamGateInfoPtr = std::unique_ptr<BeamGateInfoCollection>

private

Definition at line 145 of file TriggerDecoder_tool.cc.

using daq::TriggerDecoder::BeamGateInfoPtr = std::unique_ptr<BeamGateInfoCollection>

private

Definition at line 231 of file TriggerDecoderV2_tool.cc.

using daq::TriggerDecoder::ExtraInfoPtr = std::unique_ptr<sbn::ExtraTriggerInfo>

private

Definition at line 146 of file TriggerDecoder_tool.cc.

using daq::TriggerDecoder::ExtraInfoPtr = std::unique_ptr<sbn::ExtraTriggerInfo>

private

Definition at line 232 of file TriggerDecoderV2_tool.cc.

using daq::TriggerDecoder::microseconds = util::quantities::microsecond

private

Definition at line 213 of file TriggerDecoderV2_tool.cc.

using daq::TriggerDecoder::nanoseconds = util::quantities::nanosecond

private

Definition at line 130 of file TriggerDecoder_tool.cc.

using daq::TriggerDecoder::nanoseconds = util::quantities::nanosecond

private

Definition at line 214 of file TriggerDecoderV2_tool.cc.

using daq::TriggerDecoder::RelativeTriggerCollection = std::vector<raw::Trigger>

private

Definition at line 143 of file TriggerDecoder_tool.cc.

using daq::TriggerDecoder::RelativeTriggerCollection = std::vector<raw::Trigger>

private

Definition at line 229 of file TriggerDecoderV2_tool.cc.

using daq::TriggerDecoder::TriggerCollection = std::vector<raw::ExternalTrigger>

private

Definition at line 141 of file TriggerDecoder_tool.cc.

using daq::TriggerDecoder::TriggerCollection = std::vector<raw::ExternalTrigger>

private

Definition at line 227 of file TriggerDecoderV2_tool.cc.

using daq::TriggerDecoder::TriggerPtr = std::unique_ptr<TriggerCollection>

private

Definition at line 142 of file TriggerDecoder_tool.cc.

using daq::TriggerDecoder::TriggerPtr = std::unique_ptr<TriggerCollection>

private

Definition at line 228 of file TriggerDecoderV2_tool.cc.

Constructor & Destructor Documentation

daq::TriggerDecoder::TriggerDecoder ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 205 of file TriggerDecoder_tool.cc.

    : fDetTimings
      { art::ServiceHandle<detinfo::DetectorClocksService>()->DataForJob() }
  {
    this->configure(pset);
  }

daq::TriggerDecoder::TriggerDecoder ( fhicl::ParameterSet const &  pset )

explicit

Member Function Documentation

void daq::TriggerDecoder::configure ( const fhicl::ParameterSet &  )

overridevirtual

Interface for configuring the particular algorithm tool.

Parameters

ParameterSet

The input set of parameters for configuration

Implements daq::IDecoder.

Definition at line 223 of file TriggerDecoder_tool.cc.

  {
    fDiagnosticOutput = pset.get<bool>("DiagnosticOutput", false);
    fDebug = pset.get<bool>("Debug", false);
    return;
  }

virtual void daq::TriggerDecoder::configure ( const fhicl::ParameterSet &  )

overridevirtual

Interface for configuring the particular algorithm tool.

Parameters

ParameterSet

The input set of parameters for configuration

Implements daq::IDecoder.

void daq::TriggerDecoder::consumes ( art::ConsumesCollector &  )

overridevirtual

Declare to the framework what you expect to read.

Reimplemented from daq::IDecoder.

Definition at line 314 of file TriggerDecoderV2_tool.cc.

                                                               {
    collector.consumes<icarus::TriggerConfiguration, art::InRun>
      (fTriggerConfigTag);
  }

std::uint64_t daq::TriggerDecoder::encodeLVDSbits ( short int  cryostat, short int  connector, std::uint64_t  connectorWord  )

staticprivate

Encodes the connectorWord LVDS bits from the specified cryostat and connector into the format required by sbn::ExtraTriggerInfo.

Definition at line 755 of file TriggerDecoderV2_tool.cc.

  {
    /*
     * Encoding of the LVDS channels from the trigger:
     * * east wall:  `00<C0P2><C0P1><C0P0>00<C1P2><C1P1><C1P0>`
     * * west wall:  `00<C2P2><C2P1><C2P0>00<C3P2><C3P1><C3P0>`
     * The prescription from `sbn::ExtraTriggerInfo` translates into:
     * * east wall:  `00<C3P2><C3P1><C3P0>00<C2P2><C2P1><C2P0>`
     * * west wall:  `00<C1P2><C1P1><C1P0>00<C0P2><C0P1><C0P0>`
     * Therefore, the two 32-bit half-words need to be swapped
     * This holds for both cryostats, and both walls.  
     */

    std::uint64_t lsw = connectorWord & 0xFFFFFFFFULL;
    std::uint64_t msw = connectorWord >> 32ULL;
    assert(connectorWord == ((msw << 32ULL) | lsw));
    std::swap(lsw, msw);
    return (msw << 32ULL) | lsw;
  } // TriggerDecoder::encodeLVDSbits()

std::string_view daq::TriggerDecoder::firstLine ( std::string const &  s, std::string const &  endl = "\0\n\r"s  )

staticprivate

Definition at line 485 of file TriggerDecoder_tool.cc.

  {
    return { s.data(), std::min(s.find_first_of(endl), s.size()) };
  }

static std::string_view daq::TriggerDecoder::firstLine ( std::string const &  s, std::string const &  endl = "\0\n\r"s  )

staticprivate

void daq::TriggerDecoder::initializeDataProducts ( )

overridevirtual

Initialize any data products the tool will output.

Implements daq::IDecoder.

Definition at line 230 of file TriggerDecoder_tool.cc.

  {
    //use until different object chosen 
    //fTrigger = new raw::Trigger();
    fTrigger = std::make_unique<TriggerCollection>();
    fPrevTrigger = std::make_unique<TriggerCollection>();
    fRelTrigger = std::make_unique<RelativeTriggerCollection>();
    fBeamGateInfo = BeamGateInfoPtr(new BeamGateInfoCollection);
    fTriggerExtra = std::make_unique<sbn::ExtraTriggerInfo>();
    return;
  }

virtual void daq::TriggerDecoder::initializeDataProducts ( )

overridevirtual

Initialize any data products the tool will output.

Implements daq::IDecoder.

static std::uint64_t daq::TriggerDecoder::makeTimestamp ( unsigned int  s, unsigned int  ns  )

inlinestaticprivate

Combines second and nanosecond counts into a 64-bit timestamp.

Definition at line 192 of file TriggerDecoder_tool.cc.

      { return s * 1000000000ULL + ns; }

static std::uint64_t daq::TriggerDecoder::makeTimestamp ( unsigned int  s, unsigned int  ns  )

inlinestaticprivate

Combines second and nanosecond counts into a 64-bit timestamp.

Definition at line 285 of file TriggerDecoderV2_tool.cc.

      { return s * 1000000000ULL + ns; }

icarus::ICARUSTriggerV2Fragment daq::TriggerDecoder::makeTriggerFragment ( artdaq::Fragment const &  fragment ) const

private

Creates a ICARUSTriggerInfo from a generic fragment.

Definition at line 244 of file TriggerDecoder_tool.cc.

  {
    try {
      return icarus::ICARUSTriggerUDPFragment { fragment };
    }
    catch(std::exception const& e) {
      mf::LogSystem("TriggerDecoder")
        << "Error while creating trigger fragment from:\n"
          << sbndaq::dumpFragment(fragment)
        << "\nError message: " << e.what();
      throw;
    }
    catch(...) {
      mf::LogSystem("TriggerDecoder")
        << "Unidentified exception while creating trigger fragment from:"
          << sbndaq::dumpFragment(fragment);
      throw;
    }
  } // TriggerDecoder::parseTriggerString()

icarus::ICARUSTriggerV2Fragment daq::TriggerDecoder::makeTriggerFragment ( artdaq::Fragment const &  fragment ) const

private

Creates a ICARUSTriggerInfo from a generic fragment.

void daq::TriggerDecoder::outputDataProducts ( art::Event &  event )

overridevirtual

Output the data products to the event store.

Parameters

event

The event store objects

Implements daq::IDecoder.

Definition at line 473 of file TriggerDecoder_tool.cc.

  {
    //Place trigger data object into raw data store 
    event.put(std::move(fTrigger), CurrentTriggerInstanceName);
    event.put(std::move(fRelTrigger), CurrentTriggerInstanceName);
    event.put(std::move(fPrevTrigger), PreviousTriggerInstanceName);
    event.put(std::move(fBeamGateInfo), CurrentTriggerInstanceName);
    event.put(std::move(fTriggerExtra));
    return;
  }

virtual void daq::TriggerDecoder::outputDataProducts ( art::Event &  event )

overridevirtual

Output the data products to the event store.

Parameters

event

The event store objects

Implements daq::IDecoder.

icarus::ICARUSTriggerInfo daq::TriggerDecoder::parseTriggerString ( std::string_view  data ) const

private

Parses the trigger data packet with the "standard" parser.

Definition at line 266 of file TriggerDecoder_tool.cc.

  {
    try {
      return icarus::parse_ICARUSTriggerString(data.data());
    }
    catch(std::exception const& e) {
      mf::LogSystem("TriggerDecoder")
        << "Error while running standard parser on " << data.length()
        << "-char long trigger string:\n==>|" << data
        << "|<==\nError message: " << e.what();
      throw;
    }
    catch(...) {
      mf::LogSystem("TriggerDecoder")
        << "Unidentified exception while running standard parser on "
        << data.length() << "-char long trigger string:\n==>|" << data << "|.";
      throw;
    }
  } // TriggerDecoder::parseTriggerString()

icarus::ICARUSTriggerInfo daq::TriggerDecoder::parseTriggerString ( std::string_view  data ) const

private

Parses the trigger data packet with the "standard" parser.

icarus::KeyValuesData daq::TriggerDecoder::parseTriggerStringAsCSV ( std::string const &  data ) const

private

Parses the trigger data packet with a CSV parser.

Definition at line 406 of file TriggerDecoderV2_tool.cc.

  {
    icarus::details::KeyedCSVparser parser;
    parser.addPatterns({
        { "Cryo. (EAST|WEST) Connector . and .", 1U }
        , { "Trigger Type", 1U }
      });
    std::string_view const dataLine = firstLine(data);
    try {
      return parser(dataLine);
    }
    catch(icarus::details::KeyedCSVparser::Error const& e) {
      mf::LogError("TriggerDecoder")
        << "Error parsing " << dataLine.length()
        << "-char long trigger string:\n==>|" << dataLine
        << "|<==\nError message: " << e.what() << std::endl;
      throw;
    }
  } // TriggerDecoder::parseTriggerStringAsCSV()

void daq::TriggerDecoder::process_fragment ( const artdaq::Fragment &  fragment )

overridevirtual

Given a set of recob hits, run DBscan to form 3D clusters.

Parameters

fragment

The artdaq fragment to process

Implements daq::IDecoder.

Definition at line 288 of file TriggerDecoder_tool.cc.

  {
    // artdaq_ts is reworked by the trigger board reader to match the corrected
    // trigger time; to avoid multiple (potentially inconsistent) corrections,
    // the decoder trusts it and references all the times with respect to it.
    uint64_t const artdaq_ts = fragment.timestamp();
    icarus::ICARUSTriggerUDPFragment frag { makeTriggerFragment(fragment) };
    std::string data = frag.GetDataString();
    char *buffer = const_cast<char*>(data.c_str());

    icarus::ICARUSTriggerInfo datastream_info = parseTriggerString(buffer);
    uint64_t const raw_wr_ts // this is raw, unadultered, uncorrected
      = makeTimestamp(frag.getWRSeconds(), frag.getWRNanoSeconds());
    
    // correction (explicitly converted to signed)
    int64_t const WRtimeToTriggerTime
      = static_cast<int64_t>(artdaq_ts) - raw_wr_ts;
    auto const correctWRtime = [WRtimeToTriggerTime](uint64_t time)
      { return time + WRtimeToTriggerTime; };
    assert(correctWRtime(raw_wr_ts) == artdaq_ts);
    
    // --- END ---- TEMPORARY --------------------------------------------------
    int gate_type = datastream_info.gate_type;
    long delta_gates_bnb [[maybe_unused]] = frag.getDeltaGatesBNB();
    long delta_gates_numi [[maybe_unused]] = frag.getDeltaGatesOther(); //this is actually NuMI due to abrupt changes in trigger board logic
    long delta_gates_other [[maybe_unused]] = frag.getDeltaGatesNuMI();
    uint64_t lastTrigger = 0;
    
    // --- BEGIN -- TEMPORARY --------------------------------------------------
    // remove this part when the beam gate timestamp is available via fragment
    // or via the parser
    auto const parsedData = icarus::details::KeyedCSVparser{}(firstLine(data));
    unsigned int beamgate_count { std::numeric_limits<unsigned int>::max() };
    std::uint64_t beamgate_ts { artdaq_ts }; // we cheat
    /* [20210717, petrillo@slac.stanford.edu] `(pBeamGateInfo->nValues() == 3)`:
     * this is an attempt to "support" a few Run0 runs (6017 to roughly 6043)
     * which have the beam gate information truncated; this workaround should
     * be removed when there is enough ICARUS data that these runs become
     * uninteresting.
     */
    if (auto pBeamGateInfo = parsedData.findItem("Beam_TS");
      pBeamGateInfo && (pBeamGateInfo->nValues() == 3)
    ) {
      // if gate information is found, it must be complete
      beamgate_count = pBeamGateInfo->getNumber<unsigned int>(0U);
      
      uint64_t const raw_bg_ts = makeTimestamp( // raw and uncorrected too
        pBeamGateInfo->getNumber<unsigned int>(1U),
        pBeamGateInfo->getNumber<unsigned int>(2U)
        );
      
      // assuming the raw times from the fragment are on the same time scale
      // (same offset corrections)
      beamgate_ts += raw_bg_ts - raw_wr_ts;
      
    } // if has gate information
    // --- END ---- TEMPORARY --------------------------------------------------
    
    if(fDiagnosticOutput || fDebug)
    {
      std::cout << "Full Timestamp = " << artdaq_ts
        << "\nBeam gate " << beamgate_count << " at "
        << (beamgate_ts/1'000'000'000) << "." << std::setfill('0')
        << std::setw(9) << (beamgate_ts%1'000'000'000) << std::setfill(' ')
        << " s (" << timestampDiff(beamgate_ts, artdaq_ts)
        << " ns relative to trigger)" << std::endl;
      
      // note that this parsing is independent from the one used above
      std::string_view const dataLine = firstLine(data);
      try {
        auto const parsedData = icarus::details::KeyedCSVparser{}(dataLine);
        std::cout << "Parsed data (from " << dataLine.size() << " characters): "
          << parsedData << std::endl;
      }
      catch(icarus::details::KeyedCSVparser::Error const& e) {
        mf::LogError("TriggerDecoder")
          << "Error parsing " << dataLine.length()
          << "-char long trigger string:\n==>|" << dataLine
          << "|<==\nError message: " << e.what() << std::endl;
        throw;
      }
      
      if (fDebug) { // this grows tiresome quickly when processing many events
        std::cout << "Trigger packet content:\n" << dataLine
          << "\nFull trigger fragment dump:"
          << sbndaq::dumpFragment(fragment) << std::endl;
      }
    }
    
    //
    // extra trigger info
    //
    sbn::triggerSource beamGateBit;
    switch (gate_type) {
      case TriggerGateTypes::BNB:         beamGateBit = sbn::triggerSource::BNB;         break;
      case TriggerGateTypes::NuMI:        beamGateBit = sbn::triggerSource::NuMI;        break;
      case TriggerGateTypes::OffbeamBNB:  beamGateBit = sbn::triggerSource::OffbeamBNB;  break;
      case TriggerGateTypes::OffbeamNuMI: beamGateBit = sbn::triggerSource::OffbeamNuMI; break;
      default:                            beamGateBit = sbn::triggerSource::Unknown;
    } // switch gate_type
    
    fTriggerExtra->sourceType = beamGateBit;
    fTriggerExtra->triggerTimestamp = artdaq_ts;
    fTriggerExtra->beamGateTimestamp = beamgate_ts;
    fTriggerExtra->triggerID = datastream_info.wr_event_no;
    fTriggerExtra->gateID = datastream_info.gate_id;
    /* TODO (may need to add WRtimeToTriggerTime to some timestamps):
    fTriggerExtra->triggerCount
    fTriggerExtra->gateCount
    fTriggerExtra->gateCountFromPreviousTrigger
    fTriggerExtra->anyTriggerCountFromPreviousTrigger
    fTriggerExtra->anyGateCountFromPreviousTrigger
    fTriggerExtra->anyPreviousTriggerSourceType
    fTriggerExtra->anyGateCountFromAnyPreviousTrigger
    fTriggerExtra->previousTriggerTimestamp
    fTriggerExtra->anyPreviousTriggerTimestamp
    */
    fTriggerExtra->WRtimeToTriggerTime = WRtimeToTriggerTime;
    
    //
    // absolute time trigger (raw::ExternalTrigger)
    //
    fTrigger->emplace_back
      (fTriggerExtra->triggerID, fTriggerExtra->triggerTimestamp);
    
    //
    // previous absolute time trigger (raw::ExternalTrigger)
    //
    if(fTriggerExtra->triggerID == 1)
    {
      fLastEvent = 0;
    }
    else 
    {
      fLastEvent = fTriggerExtra->triggerID - 1;
      lastTrigger = frag.getLastTimestampBNB();
      fPrevTrigger->emplace_back(fLastEvent, lastTrigger);
    }
    
    //
    // beam gate
    //
    // beam gate - trigger: hope it's negative...
    nanoseconds const gateStartFromTrigger{
      static_cast<double>(timestampDiff
        (fTriggerExtra->beamGateTimestamp, fTriggerExtra->triggerTimestamp)
        )
      }; // narrowing!!
    auto const elecGateStart = fDetTimings.TriggerTime() + gateStartFromTrigger;
    auto const simGateStart = fDetTimings.toSimulationTime(elecGateStart);
    switch (gate_type) {
      case TriggerGateTypes::BNB:
        fBeamGateInfo->emplace_back
          (simGateStart.value(), BNBgateDuration.value(), sim::kBNB);
        break;
      case TriggerGateTypes::NuMI:
        fBeamGateInfo->emplace_back
          (simGateStart.value(), NuMIgateDuration.value(), sim::kNuMI);
        break;
      case TriggerGateTypes::OffbeamBNB:
        fBeamGateInfo->emplace_back
          (simGateStart.value(), BNBgateDuration.value(), sim::kBNB);
        break;
      case TriggerGateTypes::OffbeamNuMI:
        fBeamGateInfo->emplace_back
          (simGateStart.value(), NuMIgateDuration.value(), sim::kNuMI);
        break;
      default:
        mf::LogWarning("TriggerDecoder") << "Unsupported gate type #" << gate_type;
    } // switch gate_type
    
    //
    // relative time trigger (raw::Trigger)
    //
    fRelTrigger->emplace_back(
      static_cast<unsigned int>(datastream_info.wr_event_no), // counter
      fDetTimings.TriggerTime().value(),                      // trigger_time
      elecGateStart.value(),                                  // beamgate_time
      mask(beamGateBit)                                       // bits
      );
    
    //Once we have full trigger data object, set up and place information into there
    return;
  }

virtual void daq::TriggerDecoder::process_fragment ( const artdaq::Fragment &  fragment )

overridevirtual

Given a set of recob hits, run DBscan to form 3D clusters.

Parameters

fragment

The artdaq fragment to process

Implements daq::IDecoder.

void daq::TriggerDecoder::produces ( art::ProducesCollector &  )

overridevirtual

The space point building should output the hit collection for those hits which combine to form space points - a nice noise filter!

Implements daq::IDecoder.

Definition at line 213 of file TriggerDecoder_tool.cc.

  {
    collector.produces<TriggerCollection>(CurrentTriggerInstanceName);
    collector.produces<TriggerCollection>(PreviousTriggerInstanceName);
    collector.produces<RelativeTriggerCollection>(CurrentTriggerInstanceName);
    collector.produces<BeamGateInfoCollection>(CurrentTriggerInstanceName);
    collector.produces<sbn::ExtraTriggerInfo>(CurrentTriggerInstanceName);
  }

virtual void daq::TriggerDecoder::produces ( art::ProducesCollector &  )

overridevirtual

The space point building should output the hit collection for those hits which combine to form space points - a nice noise filter!

Implements daq::IDecoder.

void daq::TriggerDecoder::setupRun ( art::Run const &  run )

overridevirtual

Preparation to process a new run.

To be called on every art run transition.

Reimplemented from daq::IDecoder.

Definition at line 427 of file TriggerDecoderV2_tool.cc.

                                                 {
    
    fTriggerConfiguration = fTriggerConfigTag.empty()
      ? nullptr
      : &(run.getProduct<icarus::TriggerConfiguration>(fTriggerConfigTag))
      ;
    
  } // TriggerDecoder::setupRun()

sim::BeamType_t daq::TriggerDecoder::simGateType ( sbn::triggerSource  source )

staticprivate

Returns the beam type corresponding to the specified trigger source.

Definition at line 776 of file TriggerDecoderV2_tool.cc.

  {
    switch (source) {
      case sbn::triggerSource::BNB:
      case sbn::triggerSource::OffbeamBNB:
        return sim::kBNB;
      case sbn::triggerSource::NuMI:
      case sbn::triggerSource::OffbeamNuMI:
        return sim::kNuMI;
      case sbn::triggerSource::Calib:
        return sim::kUnknown;
      default:
        mf::LogWarning("TriggerDecoder") << "Unsupported trigger source " << name(source);
        return sim::kUnknown;
    } // switch source
  } // TriggerDecoder::simGateType()

static long long int daq::TriggerDecoder::timestampDiff ( std::uint64_t  a, std::uint64_t  b  )

inlinestaticprivate

Returns the difference a - b.

Definition at line 195 of file TriggerDecoder_tool.cc.

      { return static_cast<long long int>(a) - static_cast<long long int>(b); }

static long long int daq::TriggerDecoder::timestampDiff ( std::uint64_t  a, std::uint64_t  b  )

inlinestaticprivate

Returns the difference a - b.

Definition at line 288 of file TriggerDecoderV2_tool.cc.

      { return static_cast<long long int>(a) - static_cast<long long int>(b); }

Member Data Documentation

static constexpr nanoseconds daq::TriggerDecoder::BNBgateDuration { 1600. }

staticprivate

Definition at line 185 of file TriggerDecoder_tool.cc.

std::string const daq::TriggerDecoder::CurrentTriggerInstanceName {}

staticprivate

Name of the data product instance for the current trigger.

Definition at line 170 of file TriggerDecoder_tool.cc.

BeamGateInfoPtr daq::TriggerDecoder::fBeamGateInfo

private

Definition at line 151 of file TriggerDecoder_tool.cc.

bool daq::TriggerDecoder::fDebug

private

Use this for debugging this tool.

Definition at line 153 of file TriggerDecoder_tool.cc.

detinfo::DetectorTimings const daq::TriggerDecoder::fDetTimings

private

Detector clocks and timings.

Definition at line 160 of file TriggerDecoder_tool.cc.

bool daq::TriggerDecoder::fDiagnosticOutput

private

Produces large number of diagnostic messages, use with caution!

Definition at line 152 of file TriggerDecoder_tool.cc.

long daq::TriggerDecoder::fLastEvent = 0

private

Definition at line 158 of file TriggerDecoder_tool.cc.

TriggerPtr daq::TriggerDecoder::fPrevTrigger

private

Definition at line 148 of file TriggerDecoder_tool.cc.

std::unique_ptr< RelativeTriggerCollection > daq::TriggerDecoder::fRelTrigger

private

Definition at line 149 of file TriggerDecoder_tool.cc.

TriggerPtr daq::TriggerDecoder::fTrigger

private

Definition at line 147 of file TriggerDecoder_tool.cc.

art::InputTag daq::TriggerDecoder::fTriggerConfigTag

private

Data product with hardware trigger configuration.

Definition at line 238 of file TriggerDecoderV2_tool.cc.

icarus::TriggerConfiguration const* daq::TriggerDecoder::fTriggerConfiguration = nullptr

private

Cached pointer to the trigger configuration of the current run, if any.

Definition at line 247 of file TriggerDecoderV2_tool.cc.

ExtraInfoPtr daq::TriggerDecoder::fTriggerExtra

private

Definition at line 150 of file TriggerDecoder_tool.cc.

static constexpr nanoseconds daq::TriggerDecoder::NuMIgateDuration { 9500. }

staticprivate

Definition at line 186 of file TriggerDecoder_tool.cc.

std::string const daq::TriggerDecoder::PreviousTriggerInstanceName { "previous" }

staticprivate

Name of the data product instance for the previous trigger.

Definition at line 173 of file TriggerDecoder_tool.cc.

static constexpr double daq::TriggerDecoder::UnknownBeamTime = std::numeric_limits<double>::max()

staticprivate

Definition at line 175 of file TriggerDecoder_tool.cc.

---

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

• TriggerDecoder_tool.cc
• TriggerDecoderV2_tool.cc