Merge pull request #96 from PetrilloAtWork/feature/gp_adderTrigger

Additions to sbn::ExtraTriggerInfo data product to store ICARUS adder information

Author: miquelnebot

CMakeLists.txt

@@ -28,8 +28,7 @@ cet_cmake_env()
 cet_set_compiler_flags(DIAGS CAUTIOUS
   WERROR
   NO_UNDEFINED
-  EXTRA_FLAGS -pedantic
-  EXTRA_CXX_FLAGS -Wno-unused-local-typedefs
+  EXTRA_FLAGS -pedantic -Wno-unused-local-typedefs
 )
 
 cet_report_compiler_flags(REPORT_THRESHOLD VERBOSE)

sbnobj/Common/Reco/classes.h

@@ -29,6 +29,5 @@
 #include "sbnobj/Common/Reco/CNNScore.h"
 #include "sbnobj/Common/Reco/TPCPMTBarycenterMatch.h"
 
-
 #include <utility>
 #include <vector>

sbnobj/Common/Trigger/ExtraTriggerInfo.cxx

@@ -17,6 +17,25 @@
 // -----------------------------------------------------------------------------
 namespace {
 
+  // ---------------------------------------------------------------------------
+  template <typename Stream, char CharOn = 'x', char CharOff = '-'>
+  class ByteDumper {
+    static constexpr char symbols[2] = { CharOff, CharOn };
+    
+    Stream& out;
+    
+      public:
+    ByteDumper(Stream& out): out{ out } {}
+    
+    void operator() (std::uint8_t bits, std::size_t nBits = 8) const
+      {
+        std::uint8_t mask = 1 << (nBits - 1); // default: 0x80
+        do { out << symbols[(bits & mask)? 1: 0]; } while (mask >>= 1);
+      }
+    
+  }; // ByteDumper
+  
+  
   // ---------------------------------------------------------------------------
   template <typename T = std::uint64_t>
   struct TimestampDumper { T timestamp; };
@@ -71,6 +90,31 @@ namespace {
   }
 
 
+  // ---------------------------------------------------------------------------
+  template <typename T>
+  struct BitDumper { T bits; unsigned int n; };
+  
+  template <typename T>
+  BitDumper<T> dumpBits
+    (T bits, unsigned int n = sizeof(T) * 8) { return { bits, n }; }
+  
+  template <typename T>
+  std::ostream& operator<< (std::ostream& out, BitDumper<T> wrapper) {
+    static auto const bitMask = [](unsigned int n)
+      { return (n == sizeof(T)*8)? ~T{0}: T((1 << n) - 1); };
+    
+    ByteDumper const dumpByte{ out };
+    unsigned int bitsLeft = wrapper.n;
+    while (bitsLeft > 0) { // goes 8 by 8 (fewer on the first iteration)
+      unsigned int const maskBits = (bitsLeft - 1) % 8 + 1;
+      bitsLeft -= maskBits;
+      dumpByte((wrapper.bits >> bitsLeft) & bitMask(maskBits), maskBits);
+    } // while
+    
+    return out;
+  } // operator<< (LVDSmaskDumper)
+  
+  
   // ---------------------------------------------------------------------------
 
   struct LVDSmaskDumper { std::uint64_t bits; };
@@ -80,32 +124,22 @@ namespace {
   std::ostream& operator<< (std::ostream& out, LVDSmaskDumper wrapper) {
     std::uint64_t const bits { wrapper.bits };
 
-    auto dumpBoard = [&out](std::uint8_t bits)
-      {
-        static constexpr char symbols[2] = { '-', 'x' };
-	std::uint8_t mask = 0x80;
-        do { out << symbols[(bits & mask)? 1: 0]; } while (mask >>= 1);
-      };
     auto boardBits = [](std::uint64_t bits, short int board) -> std::uint8_t
       { return static_cast<std::uint8_t>((bits >> (board * 8)) & 0xFF); };
 
-    // positions 3 and 7 are empty 
-    dumpBoard(boardBits(bits, 6));
-    out << ' ';
-    dumpBoard(boardBits(bits, 5));
-    out << ' ';
-    dumpBoard(boardBits(bits, 4));
-    out << ' ';
-    out << ' ';
-    dumpBoard(boardBits(bits, 2));
-    out << ' ';
-    dumpBoard(boardBits(bits, 1));
-    out << ' ';
-    dumpBoard(boardBits(bits, 0));
+    // positions 3 and 7 are empty
+    out
+      << dumpBits(boardBits(bits, 6)) << ' '
+      << dumpBits(boardBits(bits, 5)) << ' '
+      << dumpBits(boardBits(bits, 4)) << ' '
+      << ' '
+      << dumpBits(boardBits(bits, 2)) << ' '
+      << dumpBits(boardBits(bits, 1)) << ' '
+      << dumpBits(boardBits(bits, 0))
+      ;
 
     return out;
-  } // operator<< (LVDSmaskDumper)            
-
+  } // operator<< (LVDSmaskDumper)
 
 } // local namespace
 
@@ -173,34 +207,41 @@ std::ostream& sbn::operator<< (std::ostream& out, ExtraTriggerInfo const& info)
     for (std::string const& bitName: names(info.triggerLocation()))
       out << " " << bitName;
   }
-  out << "\nWest cryostat: "
-      << info.cryostats[ExtraTriggerInfo::WestCryostat].triggerCount
+  out << "\nEast cryostat: "
+      << info.cryostats[ExtraTriggerInfo::EastCryostat].triggerCount
       << " triggers";
-  if (auto const& cryo = info.cryostats[ExtraTriggerInfo::WestCryostat];
+  if (auto const& cryo = info.cryostats[ExtraTriggerInfo::EastCryostat];
       cryo.hasLVDS()
       ) {
     out
-      << "\n  west wall:  "
-      << dumpLVDSmask(cryo.LVDSstatus[ExtraTriggerInfo::WestPMTwall])
       << "\n  east wall:  "
       << dumpLVDSmask(cryo.LVDSstatus[ExtraTriggerInfo::EastPMTwall])
+      << ", sectors: "
+      << dumpBits(cryo.SectorStatus[ExtraTriggerInfo::EastPMTwall], 6)
+      << "\n  west wall:  "
+      << dumpLVDSmask(cryo.LVDSstatus[ExtraTriggerInfo::WestPMTwall])
+      << ", sectors: "
+      << dumpBits(cryo.SectorStatus[ExtraTriggerInfo::WestPMTwall], 6)
       ;
   }
 
-  out << "\nEast cryostat: "
-      << info.cryostats[ExtraTriggerInfo::EastCryostat].triggerCount
+  out << "\nWest cryostat: "
+      << info.cryostats[ExtraTriggerInfo::WestCryostat].triggerCount
       << " triggers";
-  if (auto const& cryo = info.cryostats[ExtraTriggerInfo::EastCryostat];
+  if (auto const& cryo = info.cryostats[ExtraTriggerInfo::WestCryostat];
       cryo.hasLVDS()
       ) {
     out
-      << "\n  west wall:  "
-      << dumpLVDSmask(cryo.LVDSstatus[ExtraTriggerInfo::WestPMTwall])
       << "\n  east wall:  "
       << dumpLVDSmask(cryo.LVDSstatus[ExtraTriggerInfo::EastPMTwall])
+      << ", sectors: "
+      << dumpBits(cryo.SectorStatus[ExtraTriggerInfo::EastPMTwall], 6)
+      << "\n  west wall:  "
+      << dumpLVDSmask(cryo.LVDSstatus[ExtraTriggerInfo::WestPMTwall])
+      << ", sectors: "
+      << dumpBits(cryo.SectorStatus[ExtraTriggerInfo::WestPMTwall], 6)
       ;
   }
-
 
   return out;
 } // sbn::operator<< (ExtraTriggerInfo)

sbnobj/Common/Trigger/ExtraTriggerInfo.h

@@ -220,6 +220,26 @@ struct sbn::ExtraTriggerInfo {
      */
     std::array<std::uint64_t, MaxWalls> LVDSstatus { 0U, 0U };
 
+    /**
+     * @brief Light level of detector blocks/slices.
+     * 
+     * There is one status per PMT wall (index mnemonic constants: `EastPMTwall`
+     * and `WestPMTwall`).
+     * 
+     * 
+     * ICARUS
+     * -------
+     * 
+     * Analog adder boards serving 15 contiguous channels are discriminated,
+     * and their status at trigger time is reflected here.
+     * 
+     * Each entry describes a PMT wall, that is 6 bits, starting from the most
+     * upstream (south) as the least significant bit.
+     * 
+     * The remaining 10 bits are reserved for future use.
+     */
+    std::array<std::uint16_t, MaxWalls> SectorStatus { 0U, 0U };
+    
     /// Returns whether there is some recorded LVDS activity.
     constexpr bool hasLVDS() const;
 
@@ -248,6 +268,22 @@ struct sbn::ExtraTriggerInfo {
     { return { triggerLocationBits }; }
 
 
+  // the following methods are meant to ease cryostat information in Python.
+  /// Returns information about the specified `cryostat` (e.g. `EastCryostat`).
+  /// @throws std::out_of_range if invalid `cryostat`
+  CryostatInfo const& cryostatInfo(std::size_t cryostat) const
+    { return cryostats.at(cryostat); }
+  
+  /// Returns LVDS states on a PMT `wall` of the specified `cryostat`.
+  /// @throws std::out_of_range if invalid `cryostat` or `wall`
+  std::uint64_t LVDSinfo(std::size_t cryostat, std::size_t wall) const
+    { return cryostatInfo(cryostat).LVDSstatus.at(wall); }
+  
+  /// Returns sector states on a PMT `wall` of the specified `cryostat`.
+  /// @throws std::out_of_range if invalid `cryostat` or `wall`
+  std::uint16_t SectorInfo(std::size_t cryostat, std::size_t wall) const
+    { return cryostatInfo(cryostat).SectorStatus.at(wall); }
+  
   /// @}
   // --- END ---- Trigger topology ---------------------------------------------
 

sbnobj/Common/Trigger/classes_def.xml

@@ -27,7 +27,8 @@
     <enum name="sbn::bits::triggerSource" ClassVersion="10" />
     <enum name="sbn::bits::triggerLocation" ClassVersion="10" />
     <enum name="sbn::bits::triggerType" ClassVersion="10" />
-    <class name="sbn::ExtraTriggerInfo::CryostatInfo" ClassVersion="10" >
+    <class name="sbn::ExtraTriggerInfo::CryostatInfo" ClassVersion="11" >
+     <version ClassVersion="11" checksum="3455337645"/>
      <version ClassVersion="10" checksum="313789291"/>
     </class>
 

sbnobj/ICARUS/PMT/Trigger/Data/CMakeLists.txt

@@ -1,8 +1,8 @@
 cet_make(
   LIBRARIES
+    lardataalg::UtilitiesHeaders
     lardataobj::RawData
     larcorealg::CoreUtils
-    lardataalg::DetectorInfo
     cetlib_except::cetlib_except
   NO_DICTIONARY
   )

sbnobj/ICARUS/PMT/Trigger/Data/OpticalTriggerGate.h

@@ -15,7 +15,6 @@
 #include "sbnobj/ICARUS/PMT/Trigger/Data/ReadoutTriggerGate.h"
 
 // LArSoft libraries
-#include "lardataalg/DetectorInfo/DetectorTimingTypes.h" // detinfo::timescales
 #include "lardataalg/Utilities/quantities/electronics.h" // tick
 #include "lardataobj/RawData/OpDetWaveform.h"
 
@@ -40,7 +39,6 @@ namespace icarus::trigger {
   /// Type of trigger gate data serialized into _art_ data products.
   using OpticalTriggerGateData_t = icarus::trigger::ReadoutTriggerGate
     <TriggerGateTick_t, TriggerGateTicks_t, raw::Channel_t>
-    //   <detinfo::timescales::optical_tick, detinfo::timescales::optical_time_ticks, raw::Channel_t>
     ;
 
 } // namespace icarus::trigger

sbnobj/ICARUS/PMT/Trigger/Data/ReadoutTriggerGate.h

@@ -198,14 +198,24 @@ template <typename Tick, typename TickInterval, typename ChannelIDType>
    */
   ChannelID_t channel() const;
 
-  
   /// Associates the specified channel to this readout gate.
   This_t& addChannel(ChannelID_t const channel);
 
   /// Associates the specified channels to this readout gate.
   This_t& addChannels(std::initializer_list<ChannelID_t> channels)
     { associateChannels(channels); return *this; }
 
+  /// Removes the specified channel from this readout gate.
+  /// Nothing happens if not present.
+  This_t& removeChannel(ChannelID_t const channel);
+  
+  /// Removes the specified channels from this readout gate.
+  /// Nothing happens for the channels that are not present.
+  This_t& removeChannels(std::initializer_list<ChannelID_t> channels);
+  
+  /// Removes all channel numbers from this gate.
+  This_t& resetChannels();
+  
   // --- END Access to channel information -------------------------------------
 
 

sbnobj/ICARUS/PMT/Trigger/Data/ReadoutTriggerGate.tcc

@@ -76,6 +76,40 @@ auto icarus::trigger::ReadoutTriggerGate<Tick, TickInterval, ChannelIDType>::add
 } // icarus::trigger::ReadoutTriggerGate<>::addChannel()
 
 
+//------------------------------------------------------------------------------
+template <typename Tick, typename TickInterval, typename ChannelIDType>
+auto icarus::trigger::ReadoutTriggerGate<Tick, TickInterval, ChannelIDType>::removeChannel
+  (ChannelID_t const channel) -> This_t&
+{
+  auto const iNearest
+    = std::lower_bound(fChannels.begin(), fChannels.end(), channel);
+  if ((iNearest != fChannels.end()) && (*iNearest == channel))
+    fChannels.erase(iNearest);
+  return *this;
+} // icarus::trigger::ReadoutTriggerGate<>::removeChannel()
+
+
+//------------------------------------------------------------------------------
+template <typename Tick, typename TickInterval, typename ChannelIDType>
+auto icarus::trigger::ReadoutTriggerGate<Tick, TickInterval, ChannelIDType>::removeChannels
+  (std::initializer_list<ChannelID_t> channels) -> This_t&
+{
+  // we don't require `channels` to be sorted, so we need to look yo every time.
+  for (ChannelID_t const channel: channels) removeChannel(channel);
+  return *this;
+} // icarus::trigger::ReadoutTriggerGate<>::removeChannels()
+
+
+//------------------------------------------------------------------------------
+template <typename Tick, typename TickInterval, typename ChannelIDType>
+auto icarus::trigger::ReadoutTriggerGate<Tick, TickInterval, ChannelIDType>::resetChannels
+  () -> This_t&
+{
+  fChannels.clear();
+  return *this;
+} // icarus::trigger::ReadoutTriggerGate<>::resetChannels()
+
+
 //------------------------------------------------------------------------------
 template <typename Tick, typename TickInterval, typename ChannelIDType>
 void

sbnobj/ICARUS/PMT/Trigger/Data/TriggerGateData.tcc

@@ -9,9 +9,6 @@
 #ifndef SBNOBJ_ICARUS_PMT_TRIGGER_DATA_TRIGGERGATEDATA_TCC
 #define SBNOBJ_ICARUS_PMT_TRIGGER_DATA_TRIGGERGATEDATA_TCC
 
-// LArSoft libraries
-#include "larcorealg/CoreUtils/StdUtils.h" // util::to_string()
-
 // C/C++ standard libraries
 #include <ostream>
 #include <stdexcept> // std::runtime_error
@@ -269,17 +266,18 @@ void icarus::trigger::TriggerGateData<TK, TI>::openBetween
   // (4) update all the following stati;
   // the "Shift" action stops when a set happens, and stacks with other shifts
   //
+  using std::to_string;
   while (++iStatus != send) {
     switch (iStatus->event) {
       case EventType::Shift: // change the resulting opening
         if ((count < 0) && (iStatus->opening < OpeningCount_t(-count))) {
           throw std::runtime_error(
             "icarus::trigger::TriggerGateData::openBetween(): "
-            "asked to close " + util::to_string(-count)
+            "asked to close " + to_string(-count)
             + " gate counts starting at "
-            + util::to_string(start) + " but at time "
-            + util::to_string(iStatus->tick) + " only "
-            + util::to_string(iStatus->opening) + " are still open"
+            + to_string(start) + " but at time "
+            + to_string(iStatus->tick) + " only "
+            + to_string(iStatus->opening) + " are still open"
             );
         }
         iStatus->opening += count;
@@ -639,10 +637,11 @@ auto icarus::trigger::TriggerGateData<TK, TI>::findLastStatusForTickOrThrow
   auto const iStatus = findLastStatusFor(tick); // status may be before the tick
   if (iStatus) return iStatus.value();
   // this should be not even possible
+  using std::to_string;
   throw std::runtime_error(
-    "icarus::trigger::TriggerGateData: requested time " + util::to_string(tick)
+    "icarus::trigger::TriggerGateData: requested time " + to_string(tick)
     + " is before the gate channel was created (at "
-    + util::to_string(fGateLevel.front().tick)
+    + to_string(fGateLevel.front().tick)
     + ")"
     );
 } // icarus::trigger::TriggerGateData<>::findLastStatusForTickOrThrow()
@@ -656,10 +655,11 @@ auto icarus::trigger::TriggerGateData<TK, TI>::findLastStatusForTickOrThrow
   auto const iStatus = findLastStatusFor(tick); // status may be before the tick
   if (iStatus) return iStatus.value();
   // this should be not even possible
+  using std::to_string;
   throw std::runtime_error(
-    "icarus::trigger::TriggerGateData: requested time " + util::to_string(tick)
+    "icarus::trigger::TriggerGateData: requested time " + to_string(tick)
     + " is before the gate channel was created (at "
-    + util::to_string(fGateLevel.front().tick)
+    + to_string(fGateLevel.front().tick)
     + ")"
     );
 } // icarus::trigger::TriggerGateData<>::findLastStatusForTickOrThrow() const