Add CaloSummary/CICADA Unpacker

Fix format

Remove debug statement

Author: aloeliger

EventFilter/L1TRawToDigi/plugins/implementations_stage2/CaloSummaryUnpacker.cc

@@ -0,0 +1,47 @@
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "EventFilter/L1TRawToDigi/plugins/UnpackerFactory.h"
+
+#include "L1Trigger/L1TCalorimeter/interface/CaloTools.h"
+
+#include "L1TObjectCollections.h"
+
+#include "CaloSummaryUnpacker.h"
+#include "GTSetup.h"
+
+#include <cmath>
+
+float l1t::stage2::CaloSummaryUnpacker::processBitsToScore(const unsigned int bitsArray[]) {
+  float constructedScore = 0.0;
+  //All bits have been shifted to just left of the decimal point
+  //We need to convert them to float, shift them back to their proper position
+  //And then add them into the total
+  //The proper power is 4(-(bitIndex+1) + numCICADAWords/2)
+  // 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)));
+  }
+  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};
+
+  auto res_ = static_cast<L1TObjectCollections*>(coll)->getCICADAScore();
+
+  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
+      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
+    }
+  }
+  *res_ = processBitsToScore(cicadaBits);
+
+  return true;
+}
+
+DEFINE_L1T_UNPACKER(l1t::stage2::CaloSummaryUnpacker);

EventFilter/L1TRawToDigi/plugins/implementations_stage2/CaloSummaryUnpacker.h

@@ -0,0 +1,23 @@
+#ifndef L1T_PACKER_STAGE2_CaloSummaryUnpacker_H
+#define L1T_PACKER_STAGE2_CaloSummaryUnpacker_H
+
+#include "EventFilter/L1TRawToDigi/interface/Unpacker.h"
+
+namespace l1t {
+  namespace stage2 {
+    class CaloSummaryUnpacker : public Unpacker {
+    public:
+      CaloSummaryUnpacker() = default;
+      ~CaloSummaryUnpacker() override = default;
+
+      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 cicadaBitsPattern =
+          0xF0000000;  //first 4 bits of the first 4 words/frames are CICADA
+    };
+  }  // namespace stage2
+}  // namespace l1t
+#endif

EventFilter/L1TRawToDigi/plugins/implementations_stage2/GTCollections.cc

@@ -12,6 +12,7 @@ namespace l1t {
       event_.put(std::move(zdcsums_[0]), "EtSumZDC");
       event_.put(std::move(jets_[0]), "Jet");
       event_.put(std::move(taus_[0]), "Tau");
+      event_.put(std::move(cicadaScore_), "CICADAScore");
       for (int i = 1; i < 6; ++i) {
         event_.put(std::move(muons_[i]), "Muon" + std::to_string(i + 1));
         event_.put(std::move(muonShowers_[i]), "MuonShower" + std::to_string(i + 1));

EventFilter/L1TRawToDigi/plugins/implementations_stage2/GTCollections.h

@@ -18,7 +18,10 @@ namespace l1t {
     class GTCollections : public L1TObjectCollections {
     public:
       GTCollections(edm::Event& e)
-          : L1TObjectCollections(e), algBlk_(new GlobalAlgBlkBxCollection()), extBlk_(new GlobalExtBlkBxCollection()) {
+          : L1TObjectCollections(e),
+            cicadaScore_(std::make_unique<float>(0.0)),
+            algBlk_(new GlobalAlgBlkBxCollection()),
+            extBlk_(new GlobalExtBlkBxCollection()) {
         std::generate(muons_.begin(), muons_.end(), [] { return std::make_unique<MuonBxCollection>(); });
         std::generate(
             muonShowers_.begin(), muonShowers_.end(), [] { return std::make_unique<MuonShowerBxCollection>(); });
@@ -40,6 +43,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 GlobalAlgBlkBxCollection* getAlgs() { return algBlk_.get(); };
       inline GlobalExtBlkBxCollection* getExts() { return extBlk_.get(); };
@@ -52,6 +56,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<GlobalAlgBlkBxCollection> algBlk_;
       std::unique_ptr<GlobalExtBlkBxCollection> extBlk_;

EventFilter/L1TRawToDigi/plugins/implementations_stage2/GTSetup.cc

@@ -9,6 +9,7 @@
 #include "EventFilter/L1TRawToDigi/plugins/implementations_stage2/ZDCUnpacker.h"
 #include "EventFilter/L1TRawToDigi/plugins/implementations_stage2/JetUnpacker.h"
 #include "EventFilter/L1TRawToDigi/plugins/implementations_stage2/TauUnpacker.h"
+#include "EventFilter/L1TRawToDigi/plugins/implementations_stage2/CaloSummaryUnpacker.h"
 
 #include "GTSetup.h"
 
@@ -64,6 +65,7 @@ namespace l1t {
       prod.produces<EtSumBxCollection>("EtSumZDC");
       prod.produces<JetBxCollection>("Jet");
       prod.produces<TauBxCollection>("Tau");
+      prod.produces<float>("CICADAScore");
       prod.produces<GlobalAlgBlkBxCollection>();
       prod.produces<GlobalExtBlkBxCollection>();
       for (int i = 2; i < 7; ++i) {  // Collections from boards 2-6
@@ -91,6 +93,8 @@ namespace l1t {
       auto zdc_unp = static_pointer_cast<l1t::stage2::ZDCUnpacker>(UnpackerFactory::get()->make("stage2::ZDCUnpacker"));
       auto jet_unp = static_pointer_cast<l1t::stage2::JetUnpacker>(UnpackerFactory::get()->make("stage2::JetUnpacker"));
       auto tau_unp = static_pointer_cast<l1t::stage2::TauUnpacker>(UnpackerFactory::get()->make("stage2::TauUnpacker"));
+      auto caloSummary_unp = static_pointer_cast<l1t::stage2::CaloSummaryUnpacker>(
+          UnpackerFactory::get()->make("stage2::CaloSummaryUnpacker"));
 
       if (fw >= 0x10f2) {
         etsum_unp = static_pointer_cast<l1t::stage2::EtSumUnpacker>(
@@ -126,6 +130,7 @@ namespace l1t {
         res[16] = tau_unp;
         res[18] = tau_unp;
         res[20] = etsum_unp;
+        res[22] = caloSummary_unp;
 
         if (amc == 1) {  // only unpack first uGT board for the external signal inputs (single copy)
           res[24] = ext_unp;

EventFilter/L1TRawToDigi/plugins/implementations_stage2/L1TObjectCollections.h

@@ -26,6 +26,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 EcalTrigPrimDigiCollection* getEcalDigisBx(const unsigned int copy) { return nullptr; };
     };