[EMCAL-729] Add compression of trigger bits

DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/TriggerRecord.h

@@ -43,19 +43,27 @@ class TriggerRecord
 
   void setBCData(const BCData& data) { mBCData = data; }
   void setTriggerBits(uint32_t triggerbits) { mTriggerBits = triggerbits; }
+  void setTriggerBitsCompressed(uint16_t triggerbits);
   void setDataRange(int firstentry, int nentries) { mDataRange.set(firstentry, nentries); }
   void setIndexFirstObject(int firstentry) { mDataRange.setFirstEntry(firstentry); }
   void setNumberOfObjects(int nentries) { mDataRange.setEntries(nentries); }
 
   const BCData& getBCData() const { return mBCData; }
   BCData& getBCData() { return mBCData; }
   uint32_t getTriggerBits() const { return mTriggerBits; }
+  uint16_t getTriggerBitsCompressed() const;
   int getNumberOfObjects() const { return mDataRange.getEntries(); }
   int getFirstEntry() const { return mDataRange.getFirstEntry(); }
 
   void printStream(std::ostream& stream) const;
 
  private:
+  /// \enum TriggerBitsCoded_t
+  /// \brief Position of trigger classes in compressed format
+  enum TriggerBitsCoded_t {
+    PHYSTRIGGER, ///< Physics trigger
+    CALIBTRIGGER ///< Calib trigger
+  };
   BCData mBCData;        /// Bunch crossing data of the trigger
   DataRange mDataRange;  /// Index of the triggering event (event index and first entry in the container)
   uint32_t mTriggerBits; /// Trigger bits as from the Raw Data Header

DataFormats/Detectors/EMCAL/src/TriggerRecord.cxx

@@ -12,13 +12,37 @@
 #include <bitset>
 #include <iostream>
 #include "DataFormatsEMCAL/TriggerRecord.h"
+#include "CommonConstants/Triggers.h"
 
 namespace o2
 {
 
 namespace emcal
 {
 
+uint16_t TriggerRecord::getTriggerBitsCompressed() const
+{
+  uint16_t result(0);
+  if (mTriggerBits & o2::trigger::PhT) {
+    result |= 1 << TriggerBitsCoded_t::PHYSTRIGGER;
+  }
+  if (mTriggerBits & o2::trigger::Cal) {
+    result |= 1 << TriggerBitsCoded_t::CALIBTRIGGER;
+  }
+  return result;
+}
+
+void TriggerRecord::setTriggerBitsCompressed(uint16_t triggerbits)
+{
+  mTriggerBits = 0;
+  if (triggerbits & (1 << TriggerBitsCoded_t::PHYSTRIGGER)) {
+    mTriggerBits |= o2::trigger::PhT;
+  }
+  if (triggerbits & (1 << TriggerBitsCoded_t::CALIBTRIGGER)) {
+    mTriggerBits |= o2::trigger::Cal;
+  }
+}
+
 void TriggerRecord::printStream(std::ostream& stream) const
 {
   stream << "Data for bc " << getBCData().bc << ", orbit " << getBCData().orbit << ", Triggers " << std::bitset<sizeof(mTriggerBits) * 8>(mTriggerBits) << ", starting from entry " << getFirstEntry() << " with " << getNumberOfObjects() << " objects";

Detectors/CTF/test/test_ctf_io_emcal.cxx

@@ -45,7 +45,7 @@ BOOST_AUTO_TEST_CASE(CTFTest)
       cells.emplace_back(tower, en, timeCell, (ChannelType_t)stat);
       tower += 1 + gRandom->Integer(100);
     }
-    uint32_t trigBits = gRandom->Integer(0xffff); // we store only 16 bits
+    uint32_t trigBits = gRandom->Integer(0xFFFFFFFF); // will be converted internally to uint16_t by the coder
     triggers.emplace_back(ir, trigBits, start, cells.size() - start);
   }
 
@@ -95,8 +95,8 @@ BOOST_AUTO_TEST_CASE(CTFTest)
   sw.Stop();
   LOG(info) << "Decompressed in " << sw.CpuTime() << " s";
 
-  BOOST_CHECK(triggersD.size() == triggers.size());
-  BOOST_CHECK(cellsD.size() == cells.size());
+  BOOST_CHECK_EQUAL(triggersD.size(), triggers.size());
+  BOOST_CHECK_EQUAL(cellsD.size(), cells.size());
   LOG(info) << " BOOST_CHECK triggersD.size() " << triggersD.size() << " triggers.size() " << triggers.size()
             << " BOOST_CHECK(cellsD.size() " << cellsD.size() << " cells.size()) " << cells.size();
 
@@ -106,18 +106,29 @@ BOOST_AUTO_TEST_CASE(CTFTest)
     LOG(debug) << " Orig.TriggerRecord " << i << " " << dor.getBCData() << " " << dor.getFirstEntry() << " " << dor.getNumberOfObjects();
     LOG(debug) << " Deco.TriggerRecord " << i << " " << ddc.getBCData() << " " << ddc.getFirstEntry() << " " << ddc.getNumberOfObjects();
 
-    BOOST_CHECK(dor.getBCData() == ddc.getBCData());
-    BOOST_CHECK(dor.getNumberOfObjects() == ddc.getNumberOfObjects());
-    BOOST_CHECK(dor.getFirstEntry() == ddc.getFirstEntry());
-    BOOST_CHECK(dor.getTriggerBits() == ddc.getTriggerBits());
+    BOOST_CHECK_EQUAL(dor.getBCData(), ddc.getBCData());
+    BOOST_CHECK_EQUAL(dor.getNumberOfObjects(), ddc.getNumberOfObjects());
+    BOOST_CHECK_EQUAL(dor.getFirstEntry(), ddc.getFirstEntry());
+    BOOST_CHECK_EQUAL(dor.getTriggerBitsCompressed(), ddc.getTriggerBitsCompressed()); // Need to be compared to the filtered trigger bit set
+    // Check for the function getTriggerBits
+    // As the compessed version has trigger bits discarded,
+    // reference must be constructed again from compressed
+    // trigger bits. Otherwise the reconstructed object is
+    // compared to the uncompressed version and the test will
+    // obviously fail due to the bits which are removed.
+    // Therefore a copy is needed to modify the trigger bits
+    // storing only the compressed one
+    auto triggerbittest = triggers[i];
+    triggerbittest.setTriggerBitsCompressed(triggerbittest.getTriggerBitsCompressed());
+    BOOST_CHECK_EQUAL(triggerbittest.getTriggerBits(), ddc.getTriggerBits());
   }
 
   for (size_t i = 0; i < cells.size(); i++) {
     const auto& cor = cells[i];
     const auto& cdc = cellsD[i];
-    BOOST_CHECK(cor.getPackedTowerID() == cdc.getPackedTowerID());
-    BOOST_CHECK(cor.getPackedTime() == cdc.getPackedTime());
-    BOOST_CHECK(cor.getPackedEnergy() == cdc.getPackedEnergy());
-    BOOST_CHECK(cor.getPackedCellStatus() == cdc.getPackedCellStatus());
+    BOOST_CHECK_EQUAL(cor.getPackedTowerID(), cdc.getPackedTowerID());
+    BOOST_CHECK_EQUAL(cor.getPackedTime(), cdc.getPackedTime());
+    BOOST_CHECK_EQUAL(cor.getPackedEnergy(), cdc.getPackedEnergy());
+    BOOST_CHECK_EQUAL(cor.getPackedCellStatus(), cdc.getPackedCellStatus());
   }
 }

Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h

@@ -141,6 +141,7 @@ void CTFCoder::decode(const CTF::base& ec, VTRG& trigVec, VCELL& cellVec)
   o2::InteractionRecord ir(header.firstBC, header.firstOrbit);
 
   Cell cell;
+  TriggerRecord trg;
   for (uint32_t itrig = 0; itrig < header.nTriggers; itrig++) {
     // restore TrigRecord
     if (orbitInc[itrig]) {  // non-0 increment => new orbit
@@ -156,8 +157,10 @@ void CTFCoder::decode(const CTF::base& ec, VTRG& trigVec, VCELL& cellVec)
       cellVec.emplace_back(cell);
       cellCount++;
     }
-    uint32_t trigBits = trigger[itrig];
-    trigVec.emplace_back(ir, trigBits, firstEntry, entries[itrig]);
+    trg.setBCData(ir);
+    trg.setDataRange(firstEntry, entries[itrig]);
+    trg.setTriggerBitsCompressed(trigger[itrig]);
+    trigVec.emplace_back(trg);
   }
   assert(cellCount == header.nCells);
 }

Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFHelper.h

@@ -135,7 +135,7 @@ class CTFHelper
   {
    public:
     using _Iter<Iter_trigger, TriggerRecord, uint16_t>::_Iter;
-    value_type operator*() const { return uint16_t(mData[mIndex].getTriggerBits() & 0xffff); }
+    value_type operator*() const { return mData[mIndex].getTriggerBitsCompressed(); }
   };
 
   //_______________________________________________