[EMCAL-729] Add compression of trigger bits

Reduction from 32 bit to 16 bit filtering the most
relevant triggers for EMCAL. For the moment
2 triggers are propagated
- Physics trigger
- Calib trigger
In case other triggers will be included in the
compressed output, they need to be appended.

In addition the unit test is adapted (proper
reference, check for compressed and uncompressed
bits)

Author: mfasDa

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(); }
   };
 
   //_______________________________________________