Merge pull request #48002 from cerminar/151X_calodev_v2

[L1T] Restructure handling of Calorimeter input to Correlator Layer-1 + new TkElectrons in barrel (Phase-2)

Author: cmsbuild

DataFormats/L1TCorrelator/src/TkEm.cc

@@ -5,8 +5,6 @@
 //
 
 #include "DataFormats/L1TCorrelator/interface/TkEm.h"
-// FIXME: can remove
-#include "DataFormats/Common/interface/RefToPtr.h"
 
 using namespace l1t;
 

DataFormats/L1TParticleFlow/interface/PFCandidate.h

@@ -2,9 +2,7 @@
 #define DataFormats_L1TParticleFlow_PFCandidate_h
 
 #include <vector>
-#include "DataFormats/L1Trigger/interface/L1Candidate.h"
 #include "DataFormats/L1TMuonPhase2/interface/SAMuon.h"
-#include "DataFormats/L1TParticleFlow/interface/PFCluster.h"
 #include "DataFormats/L1TParticleFlow/interface/PFTrack.h"
 #include "DataFormats/L1Trigger/interface/RegionalOutput.h"
 
@@ -13,6 +11,7 @@ namespace l1t {
   class PFCandidate : public L1Candidate {
   public:
     typedef l1t::SAMuonRef MuonRef;
+    typedef edm::Ptr<l1t::L1Candidate> L1CandPtr;
     enum ParticleType { ChargedHadron = 0, Electron = 1, NeutralHadron = 2, Photon = 3, Muon = 4 };
 
     PFCandidate() {}
@@ -37,8 +36,8 @@ namespace l1t {
     const PFTrackRef& pfTrack() const { return trackRef_; }
     void setPFTrack(const PFTrackRef& ref) { trackRef_ = ref; }
 
-    const PFClusterRef& pfCluster() const { return clusterRef_; }
-    void setPFCluster(const PFClusterRef& ref) { clusterRef_ = ref; }
+    const L1CandPtr& caloPtr() const { return caloPtr_; }
+    void setCaloPtr(const L1CandPtr& ptr) { caloPtr_ = ptr; }
 
     const MuonRef& muon() const { return muonRef_; }
     void setMuon(const MuonRef& ref) { muonRef_ = ref; }
@@ -71,7 +70,7 @@ namespace l1t {
     void setEncodedPuppi64(uint64_t encodedPuppi64) { encodedPuppi64_ = encodedPuppi64; }
 
   private:
-    PFClusterRef clusterRef_;
+    L1CandPtr caloPtr_;
     PFTrackRef trackRef_;
     MuonRef muonRef_;
     float dxy_, puppiWeight_, caloEta_, caloPhi_;

DataFormats/L1TParticleFlow/interface/PFCluster.h

@@ -2,8 +2,11 @@
 #define DataFormats_L1TParticleFlow_PFCluster_h
 
 #include <vector>
+#include <variant>
 #include "DataFormats/L1Trigger/interface/L1Candidate.h"
 #include "DataFormats/Common/interface/Ref.h"
+#include "DataFormats/L1TParticleFlow/interface/layer1_objs.h"
+#include <ap_int.h>
 
 namespace l1t {
 
@@ -22,14 +25,13 @@ namespace l1t {
               float ptError = 0,
               int hwpt = 0,
               int hweta = 0,
-              int hwphi = 0,
-              float absZBarycenter = 0.,
-              float sigmaRR = 0.)
+              int hwphi = 0)
         : L1Candidate(PolarLorentzVector(pt, eta, phi, 0), hwpt, hweta, hwphi, /*hwQuality=*/isEM ? 1 : 0),
           hOverE_(hOverE),
           ptError_(ptError),
-          absZBarycenter_(absZBarycenter),
-          sigmaRR_(sigmaRR) {
+          encoding_(HWEncoding::None),
+          digiDataW0_(0),
+          digiDataW1_(0) {
       setPdgId(isEM ? 22 : 130);  // photon : non-photon(K0)
     }
     PFCluster(
@@ -38,15 +40,12 @@ namespace l1t {
       setPdgId(isEM ? 22 : 130);  // photon : non-photon(K0)
     }
 
+    enum class HWEncoding { None = 0, Had = 1, Em = 2 };
+
     float hOverE() const { return hOverE_; }
     void setHOverE(float hOverE) { hOverE_ = hOverE; }
 
-    void setSigmaRR(float sigmaRR) { sigmaRR_ = sigmaRR; }
-    float absZBarycenter() const { return absZBarycenter_; }
-
-    void setAbsZBarycenter(float absZBarycenter) { absZBarycenter_ = absZBarycenter; }
-    float sigmaRR() const { return sigmaRR_; }
-
+    // NOTE: this might not be consistent with the value stored in the HW digi
     float emEt() const {
       if (hOverE_ == -1)
         return 0;
@@ -70,18 +69,43 @@ namespace l1t {
     void setIsEM(bool isEM) { setHwQual(isEM); }
     unsigned int hwEmID() const { return hwQual(); }
 
-    float egVsPionMVAOut() const { return egVsPionMVAOut_; }
-    void setEgVsPionMVAOut(float egVsPionMVAOut) { egVsPionMVAOut_ = egVsPionMVAOut; }
+    std::variant<l1ct::HadCaloObj, l1ct::EmCaloObj> caloDigiObj() const {
+      switch (encoding_) {
+        case HWEncoding::Had:
+          return l1ct::HadCaloObj::unpack(binaryWord<l1ct::HadCaloObj::BITWIDTH>());
+        case HWEncoding::Em:
+          return l1ct::EmCaloObj::unpack(binaryWord<l1ct::EmCaloObj::BITWIDTH>());
+        default:
+          throw std::runtime_error("No encoding for this cluster");
+      }
+    }
+
+    void setCaloDigi(const l1ct::HadCaloObj& obj) { setBinaryWord(obj.pack(), HWEncoding::Had); }
+
+    void setCaloDigi(const l1ct::EmCaloObj& obj) { setBinaryWord(obj.pack(), HWEncoding::Em); }
 
-    float egVsPUMVAOut() const { return egVsPUMVAOut_; }
-    void setEgVsPUMVAOut(float egVsPUMVAOut) { egVsPUMVAOut_ = egVsPUMVAOut; }
+    HWEncoding encoding() const { return encoding_; }
 
   private:
-    float hOverE_, ptError_, egVsPionMVAOut_, egVsPUMVAOut_;
-    // HGC dedicated quantities (0ed by default)
-    float absZBarycenter_, sigmaRR_;
+    float hOverE_, ptError_;
 
     ConstituentsAndFractions constituents_;
+
+    template <int N>
+    void setBinaryWord(ap_uint<N> word, HWEncoding encoding) {
+      digiDataW0_ = word;
+      digiDataW1_ = (word >> 64);
+      encoding_ = encoding;
+    }
+
+    template <int N>
+    ap_uint<N> binaryWord() const {
+      return ap_uint<N>(digiDataW0_) | (ap_uint<N>(digiDataW1_) << 64);
+    }
+
+    HWEncoding encoding_;
+    uint64_t digiDataW0_;
+    uint64_t digiDataW1_;
   };
 
   typedef std::vector<l1t::PFCluster> PFClusterCollection;

DataFormats/L1TParticleFlow/interface/bit_encoding.h

@@ -2,6 +2,8 @@
 #define DATAFORMATS_L1TPARTICLEFLOW_ENCODING_H
 
 #include <cassert>
+#include <type_traits>
+
 #include "DataFormats/L1TParticleFlow/interface/datatypes.h"
 
 template <typename U, typename T>
@@ -28,64 +30,210 @@ inline void unpack_bool_from_bits(const U& u, unsigned int& start, bool& data) {
   data = u[start++];
 }
 
-template <unsigned int N, unsigned int OFFS = 0, typename T, int NB>
+// Enum to define different packing strategies for data encoding
+// DEFAULT: Standard packing
+// BARREL: Packing strategy for barrel region
+// ENDCAP: Packing strategy for endcap region
+enum class PackingStrategy { DEFAULT, BARREL, ENDCAP };
+
+// Default case: Calls T::unpack()
+template <typename T,
+          int NB,
+          PackingStrategy METHOD = PackingStrategy::DEFAULT,
+          typename std::enable_if<METHOD == PackingStrategy::DEFAULT, int>::type = 0>
+inline auto unpack_helper(const ap_uint<NB>& data) {
+  static_assert(T::BITWIDTH <= NB, "NB Type is too small for the object");
+  return T::unpack(data);
+}
+
+// Specialization for BARREL
+template <typename T,
+          int NB,
+          PackingStrategy METHOD,
+          typename std::enable_if<METHOD == PackingStrategy::BARREL, int>::type = 0>
+inline auto unpack_helper(const ap_uint<NB>& data) {
+  static_assert(T::BITWIDTH_BARREL <= NB, "NB Type is too small for the object");
+  return T::unpack_barrel(data);
+}
+
+// Specialization for ENDCAP
+template <typename T,
+          int NB,
+          PackingStrategy METHOD,
+          typename std::enable_if<METHOD == PackingStrategy::ENDCAP, int>::type = 0>
+inline auto unpack_helper(const ap_uint<NB>& data) {
+  static_assert(T::BITWIDTH_ENDCAP <= NB, "NB Type is too small for the object");
+  return T::unpack_endcap(data);
+}
+
+// Default case: Calls T::unpack()
+template <typename T,
+          int NB,
+          PackingStrategy METHOD = PackingStrategy::DEFAULT,
+          typename std::enable_if<METHOD == PackingStrategy::DEFAULT, int>::type = 0>
+inline auto unpack_slim_helper(const ap_uint<NB>& data) {
+  static_assert(T::BITWIDTH_SLIM <= NB, "NB Type is too small for the object");
+  return T::unpack(data);
+}
+
+// Specialization for BARREL
+template <typename T,
+          int NB,
+          PackingStrategy METHOD,
+          typename std::enable_if<METHOD == PackingStrategy::BARREL, int>::type = 0>
+inline auto unpack_slim_helper(const ap_uint<NB>& data) {
+  static_assert(T::BITWIDTH_BARREL_SLIM <= NB, "NB Type is too small for the object");
+  return T::unpack_barrel(data);
+}
+
+// Specialization for ENDCAP
+template <typename T,
+          int NB,
+          PackingStrategy METHOD,
+          typename std::enable_if<METHOD == PackingStrategy::ENDCAP, int>::type = 0>
+inline auto unpack_slim_helper(const ap_uint<NB>& data) {
+  static_assert(T::BITWIDTH_ENDCAP_SLIM <= NB, "NB Type is too small for the object");
+  return T::unpack_endcap(data);
+}
+
+// Default case: Calls T::unpack()
+template <typename T,
+          int NB,
+          PackingStrategy METHOD = PackingStrategy::DEFAULT,
+          typename std::enable_if<METHOD == PackingStrategy::DEFAULT, int>::type = 0>
+inline auto pack_helper(const T& obj) {
+  static_assert(T::BITWIDTH <= NB, "NB Type is too small for the object");
+  return obj.pack();
+}
+
+// Specialization for BARREL
+template <typename T,
+          int NB,
+          PackingStrategy METHOD,
+          typename std::enable_if<METHOD == PackingStrategy::BARREL, int>::type = 0>
+inline auto pack_helper(const T& obj) {
+  static_assert(T::BITWIDTH_BARREL <= NB, "NB Type is too small for the object");
+  return obj.pack_barrel();
+}
+
+// Specialization for ENDCAP
+template <typename T,
+          int NB,
+          PackingStrategy METHOD,
+          typename std::enable_if<METHOD == PackingStrategy::ENDCAP, int>::type = 0>
+inline auto pack_helper(const T& obj) {
+  static_assert(T::BITWIDTH_ENDCAP <= NB, "NB Type is too small for the object");
+  return obj.pack_endcap();
+}
+
+// Default case: Calls T::unpack()
+template <typename T,
+          int NB,
+          PackingStrategy METHOD = PackingStrategy::DEFAULT,
+          typename std::enable_if<METHOD == PackingStrategy::DEFAULT, int>::type = 0>
+inline auto pack_slim_helper(const T& obj) {
+  static_assert(T::BITWIDTH_SLIM <= NB, "NB Type is too small for the object");
+  return obj.pack_slim();
+}
+
+// Specialization for BARREL
+template <typename T,
+          int NB,
+          PackingStrategy METHOD,
+          typename std::enable_if<METHOD == PackingStrategy::BARREL, int>::type = 0>
+inline auto pack_slim_helper(const T& obj) {
+  static_assert(T::BITWIDTH_BARREL_SLIM <= NB, "NB Type is too small for the object");
+  return obj.pack_barrel_slim();
+}
+
+// Specialization for ENDCAP
+template <typename T,
+          int NB,
+          PackingStrategy METHOD,
+          typename std::enable_if<METHOD == PackingStrategy::ENDCAP, int>::type = 0>
+inline auto pack_slim_helper(const T& obj) {
+  static_assert(T::BITWIDTH_ENDCAP_SLIM <= NB, "NB Type is too small for the object");
+  return obj.pack_endcap_slim();
+}
+
+template <unsigned int N, PackingStrategy METHOD = PackingStrategy::DEFAULT, unsigned int OFFS = 0, typename T, int NB>
 inline void l1pf_pattern_pack(const T objs[N], ap_uint<NB> data[]) {
 #ifdef __SYNTHESIS__
 #pragma HLS inline
 #pragma HLS inline region recursive
 #endif
-  assert(T::BITWIDTH <= NB);
   for (unsigned int i = 0; i < N; ++i) {
 #ifdef __SYNTHESIS__
 #pragma HLS unroll
 #endif
-    data[i + OFFS] = objs[i].pack();
+    data[i + OFFS] = pack_helper<T, NB, METHOD>(objs[i]);
   }
 }
 
-template <unsigned int N, unsigned int OFFS = 0, typename T, int NB>
+// overlaod for default strategy
+template <unsigned int N, unsigned int OFFS, typename T, int NB>
+inline void l1pf_pattern_pack(const T objs[N], ap_uint<NB> data[]) {
+  l1pf_pattern_pack<N, PackingStrategy::DEFAULT, OFFS, T, NB>(objs, data);
+}
+
+template <unsigned int N, PackingStrategy METHOD = PackingStrategy::DEFAULT, unsigned int OFFS = 0, typename T, int NB>
 inline void l1pf_pattern_unpack(const ap_uint<NB> data[], T objs[N]) {
 #ifdef __SYNTHESIS__
 #pragma HLS inline
 #pragma HLS inline region recursive
 #endif
-  assert(T::BITWIDTH <= NB);
   for (unsigned int i = 0; i < N; ++i) {
 #ifdef __SYNTHESIS__
 #pragma HLS unroll
 #endif
-    objs[i] = T::unpack(data[i + OFFS]);
+    objs[i] = unpack_helper<T, NB, METHOD>(data[i + OFFS]);
   }
 }
 
-template <unsigned int N, unsigned int OFFS = 0, typename T, int NB>
+// overlaod for default strategy
+template <unsigned int N, unsigned int OFFS, typename T, int NB>
+inline void l1pf_pattern_unpack(const ap_uint<NB> data[], T objs[N]) {
+  l1pf_pattern_unpack<N, PackingStrategy::DEFAULT, OFFS, T, NB>(data, objs);
+}
+
+template <unsigned int N, PackingStrategy METHOD = PackingStrategy::DEFAULT, unsigned int OFFS = 0, typename T, int NB>
 inline void l1pf_pattern_pack_slim(const T objs[N], ap_uint<NB> data[]) {
 #ifdef __SYNTHESIS__
 #pragma HLS inline
 #pragma HLS inline region recursive
 #endif
-  assert(T::BITWIDTH_SLIM <= NB);
   for (unsigned int i = 0; i < N; ++i) {
 #ifdef __SYNTHESIS__
 #pragma HLS unroll
 #endif
-    data[i + OFFS] = objs[i].pack_slim();
+    data[i + OFFS] = pack_slim_helper<T, NB, METHOD>(objs[i]);
   }
 }
 
-template <unsigned int N, unsigned int OFFS = 0, typename T, int NB>
+// overlaod for default strategy
+template <unsigned int N, unsigned int OFFS, typename T, int NB>
+inline void l1pf_pattern_pack_slim(const T objs[N], ap_uint<NB> data[]) {
+  l1pf_pattern_pack_slim<N, PackingStrategy::DEFAULT, OFFS, T, NB>(objs, data);
+}
+
+template <unsigned int N, PackingStrategy METHOD = PackingStrategy::DEFAULT, unsigned int OFFS = 0, typename T, int NB>
 inline void l1pf_pattern_unpack_slim(const ap_uint<NB> data[], T objs[N]) {
 #ifdef __SYNTHESIS__
 #pragma HLS inline
 #pragma HLS inline region recursive
 #endif
-  assert(T::BITWIDTH_SLIM <= NB);
   for (unsigned int i = 0; i < N; ++i) {
 #ifdef __SYNTHESIS__
 #pragma HLS unroll
 #endif
-    objs[i] = T::unpack(data[i + OFFS]);
+    objs[i] = unpack_slim_helper<T, NB, METHOD>(data[i + OFFS]);
   }
 }
 
+// overlaod for default strategy
+template <unsigned int N, unsigned int OFFS, typename T, int NB>
+inline void l1pf_pattern_unpack_slim(const ap_uint<NB> data[], T objs[N]) {
+  l1pf_pattern_unpack_slim<N, PackingStrategy::DEFAULT, OFFS, T, NB>(data, objs);
+}
+
 #endif