Update CICADA unpacker draft to unpack all available BXs

Author: aloeliger

EventFilter/L1TRawToDigi/BuildFile.xml

@@ -4,6 +4,7 @@
 <use name="DataFormats/RPCDigi"/>
 <use name="DataFormats/L1DTTrackFinder"/>
 <use name="DataFormats/L1TMuon"/>
+<use name="DataFormats/L1CaloTrigger"/>
 <use name="EventFilter/RPCRawToDigi"/>
 <use name="boost_regex"/>
 <export>

EventFilter/L1TRawToDigi/plugins/implementations_stage2/CaloSummaryUnpacker.cc

@@ -5,6 +5,8 @@
 
 #include "L1TObjectCollections.h"
 
+#include "DataFormats/L1CaloTrigger/interface/CICADA.h"
+
 #include "CaloSummaryUnpacker.h"
 #include "GTSetup.h"
 
@@ -19,27 +21,45 @@ float l1t::stage2::CaloSummaryUnpacker::processBitsToScore(const unsigned int bi
   // i.e. shift bitIndex to max out at half the number of CICADA words (indexed at 0) then count down
   //And we shift by 4 bits a time, hence the factor of 4
   for (unsigned short bitIndex = 0; bitIndex < numCICADAWords; ++bitIndex) {
-    constructedScore += ((float)bitsArray[bitIndex]) * pow(2.0, 4 * (numCICADAWords / 2 - (bitIndex + 1)));
+    constructedScore += ((float)bitsArray[bitIndex]) * pow(2.0, 4 * ((numCICADAWords / 2) - (bitIndex + 1)));
   }
   return constructedScore;
 }
 
 bool l1t::stage2::CaloSummaryUnpacker::unpack(const Block& block, UnpackerCollections* coll) {
   LogDebug("L1T") << "Block ID  = " << block.header().getID() << " size = " << block.header().getSize();
-  //convert to float and then multiply by a factor based on the index?
-  unsigned int cicadaBits[numCICADAWords] = {0, 0, 0, 0};
+
+  //Just a few things to help us handle the number of BXs
+  //Strictly, we should generally get five BXs, starting at -2, and going to 2
+  //With the central BX at 0. The frames count up from -2
+  int nBX = int(ceil(block.header().getSize() / nFramesPerEvent));
+  int firstBX = (nBX / 2) - nBX + 1;
+  int lastBX = nBX / 2;
+  int processedBXs = 0; //This will just help us keep track of what words we are grabbing
+  
 
   auto res_ = static_cast<L1TObjectCollections*>(coll)->getCICADAScore();
+  res_ -> setBXRange(firstBX, lastBX);
+
+  for (int bx = firstBX; bx <= lastBX; ++bx){
+    //convert to float and then multiply by a factor based on the index?
+    unsigned int cicadaBits[numCICADAWords] = {0, 0, 0, 0};
 
-  for (unsigned int wordNum = 0; wordNum < nFrames; ++wordNum) {
-    uint32_t raw_data = block.payload().at(wordNum);
-    if (wordNum < numCICADAWords) {  // check the first 4 frames for CICADA bits
+    for (unsigned int wordNum = 0; wordNum < numCICADAWords; ++wordNum) {
+      unsigned short wordLocation = processedBXs*nFramesPerEvent + wordNum; //Calculate the location of the needed CICADA word based on how many BXs we have already handled, and how many words of CICADA we have already grabbed.
+      //Frame 0 of a bx are the most significant integer bits
+      //Frame 1 of a bx are the least significant integer bits
+      //Frame 2 of a bx are the most significant decimal bits
+      //Frame 3 of a bx are the lest significant decimal bits
+      //Frames 4&5 are unused (by CICADA), they are reserved.
+      uint32_t raw_data = block.payload().at(wordLocation);
       cicadaBits[wordNum] =
-          (cicadaBitsPattern & raw_data) >>
-          28;  //The 28 shifts the extracted bits over to the start of the 32 bit result data for easier working with
+	(cicadaBitsPattern & raw_data) >>
+	28;  //The 28 shifts the extracted bits over to the start of the 32 bit result data for easier working with later
     }
+    res_->push_back(bx, processBitsToScore(cicadaBits)); //Now we insert CICADA into the proper BX, after a quick utility constructs a number from the 4 sets of bits.
+    ++processedBXs; //index BXs
   }
-  *res_ = processBitsToScore(cicadaBits);
 
   return true;
 }

EventFilter/L1TRawToDigi/plugins/implementations_stage2/CaloSummaryUnpacker.h

@@ -12,9 +12,9 @@ namespace l1t {
 
       bool unpack(const Block& block, UnpackerCollections* coll) override;
       float processBitsToScore(const unsigned int[]);
-
+      
       static constexpr unsigned short numCICADAWords = 4;  // We have 4 words/frames that contain CICADA bits
-      static constexpr unsigned int nFrames = 6;           //My understanding is that we give 6 32 bit words to uGT
+      static constexpr unsigned int nFramesPerEvent = 6;           //Calo Summary outputs 6 32 bit words (or frames in uGT parlance) per event.
       static constexpr unsigned int cicadaBitsPattern =
           0xF0000000;  //first 4 bits of the first 4 words/frames are CICADA
     };

EventFilter/L1TRawToDigi/plugins/implementations_stage2/GTCollections.h

@@ -6,6 +6,7 @@
 #include "DataFormats/L1Trigger/interface/Jet.h"
 #include "DataFormats/L1Trigger/interface/Tau.h"
 #include "DataFormats/L1Trigger/interface/Muon.h"
+#include "DataFormats/L1CaloTrigger/interface/CICADA.h"
 
 #include "DataFormats/L1TGlobal/interface/GlobalAlgBlk.h"
 #include "DataFormats/L1TGlobal/interface/GlobalExtBlk.h"
@@ -19,7 +20,7 @@ namespace l1t {
     public:
       GTCollections(edm::Event& e)
           : L1TObjectCollections(e),
-            cicadaScore_(std::make_unique<float>(0.0)),
+            cicadaScore_(std::make_unique<CICADABxCollection>()),
             algBlk_(new GlobalAlgBlkBxCollection()),
             extBlk_(new GlobalExtBlkBxCollection()) {
         std::generate(muons_.begin(), muons_.end(), [] { return std::make_unique<MuonBxCollection>(); });
@@ -43,7 +44,7 @@ namespace l1t {
       inline EtSumBxCollection* getZDCSums(const unsigned int copy) override { return zdcsums_[copy].get(); };
       inline JetBxCollection* getJets(const unsigned int copy) override { return jets_[copy].get(); };
       inline TauBxCollection* getTaus(const unsigned int copy) override { return taus_[copy].get(); };
-      inline float* getCICADAScore() override { return cicadaScore_.get(); };
+      inline CICADABxCollection* getCICADAScore() override { return cicadaScore_.get(); };
 
       inline GlobalAlgBlkBxCollection* getAlgs() { return algBlk_.get(); };
       inline GlobalExtBlkBxCollection* getExts() { return extBlk_.get(); };
@@ -56,7 +57,7 @@ namespace l1t {
       std::array<std::unique_ptr<EtSumBxCollection>, 6> zdcsums_;
       std::array<std::unique_ptr<JetBxCollection>, 6> jets_;
       std::array<std::unique_ptr<TauBxCollection>, 6> taus_;
-      std::unique_ptr<float> cicadaScore_;
+      std::unique_ptr<CICADABxCollection> cicadaScore_;
 
       std::unique_ptr<GlobalAlgBlkBxCollection> algBlk_;
       std::unique_ptr<GlobalExtBlkBxCollection> extBlk_;

EventFilter/L1TRawToDigi/plugins/implementations_stage2/L1TObjectCollections.h

@@ -7,6 +7,7 @@
 #include "DataFormats/L1Trigger/interface/Tau.h"
 #include "DataFormats/L1Trigger/interface/Muon.h"
 #include "DataFormats/L1Trigger/interface/MuonShower.h"
+#include "DataFormats/L1CaloTrigger/interface/CICADA.h"
 
 #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
 
@@ -26,7 +27,7 @@ namespace l1t {
       virtual EtSumBxCollection* getZDCSums(const unsigned int copy) { return nullptr; }
       virtual JetBxCollection* getJets(const unsigned int copy) { return nullptr; }
       virtual TauBxCollection* getTaus(const unsigned int copy) { return nullptr; }
-      virtual float* getCICADAScore() { return nullptr; }
+      virtual CICADABxCollection* getCICADAScore() { return nullptr; }
 
       virtual EcalTrigPrimDigiCollection* getEcalDigisBx(const unsigned int copy) { return nullptr; };
     };