Merge pull request cms-sw#33974 from dildick/from-CMSSW_12_0_X_2021-05-28-1100

Prep work for the Run-3 GEM-CSC integrated local trigger (III)

Author: cmsbuild

DataFormats/CSCDigi/interface/CSCConstants.h

@@ -94,6 +94,8 @@ class CSCConstants {
     NUM_HALF_STRIPS_ME32 = NUM_CFEBS_ME32 * NUM_HALF_STRIPS_PER_CFEB,  // 160
     NUM_HALF_STRIPS_ME41 = NUM_CFEBS_ME41 * NUM_HALF_STRIPS_PER_CFEB,  // 160
     NUM_HALF_STRIPS_ME42 = NUM_CFEBS_ME42 * NUM_HALF_STRIPS_PER_CFEB,  // 160
+    // useful for the comparator code algorithm
+    INVALID_HALF_STRIP = 65535
   };
 
   // CSCs have 6 layers. The key (reference) layer is the third layer
@@ -103,7 +105,10 @@ class CSCConstants {
   enum Pattern_Info {
     NUM_ALCT_PATTERNS = 3,
     ALCT_PATTERN_WIDTH = 5,
+    // Run-1 and Run-2 CSC trigger patterns
     NUM_CLCT_PATTERNS = 11,
+    // Run-3 CSC trigger patterns
+    NUM_CLCT_PATTERNS_RUN3 = 5,
     CLCT_PATTERN_WIDTH = 11,
     // Max number of wires participating in a pattern
     MAX_WIRES_IN_PATTERN = 14,

L1Trigger/CSCTriggerPrimitives/interface/CSCALCTCrossCLCT.h

@@ -32,23 +32,50 @@ class CSCCLCTDigi;
 
 class CSCALCTCrossCLCT {
 public:
-  CSCALCTCrossCLCT(unsigned endcap, unsigned station, unsigned ring, bool isganged, const edm::ParameterSet& luts);
+  CSCALCTCrossCLCT(
+      unsigned endcap, unsigned station, unsigned ring, bool ignoreAlctCrossClct, const edm::ParameterSet& conf);
 
-  // check if an ALCT can cross a CLCT. Not always the case for ME1/1
-  bool doesALCTCrossCLCT(const CSCALCTDigi& a, const CSCCLCTDigi& c, bool ignoreAlctCrossClct) const;
+  /*
+    Calculate the 4-bit code for the best LCT and second LCT. Each code corresponds
+    to a unique combination for best and second best. Not each combation is valid.
+    Valid best LCT codes are:   11, 12, 21, 22, and 0
+    Valid second LCT codes are: 12, 21, 22, and 0
+    When a code is nonzero, the first index is the ALCT. The second index is the CLCT.
+
+    This feature was originally added by Vadim Khotilovich in LS1 to potentially improve the
+    quality of the LCTs sent to the track-finder. Generally the track-finders
+    request all information to be sent. Even if the resulting LCT is potentially
+    unphysical. Therefore, this function is not used.
+  */
+  void calculateLCTCodes(const CSCALCTDigi& a1,
+                         const CSCCLCTDigi& c1,
+                         const CSCALCTDigi& a2,
+                         const CSCCLCTDigi& c2,
+                         unsigned& bestLCTCode,
+                         unsigned& secondLCTCode) const;
+
+  /*
+    Check if an ALCT can cross a CLCT. Most of the time it can. Only in ME1/1 there are
+    special cases when they do not. This function is typically not used though, as the
+    EMTF prefers to receive all stubs. However, there is an option to discard unphysical matches.
+  */
+  bool doesALCTCrossCLCT(const CSCALCTDigi& a, const CSCCLCTDigi& c) const;
 
 private:
+  // check if a wiregroup cross a halfstrip
   bool doesWiregroupCrossHalfStrip(int wg, int keystrip) const;
 
   unsigned endcap_;
   unsigned station_;
   unsigned ring_;
-  bool isganged_;
+  bool gangedME1a_;
+  bool ignoreAlctCrossClct_;
 
   // strings to paths of LUTs
   std::vector<std::string> wgCrossHsME1aFiles_;
   std::vector<std::string> wgCrossHsME1aGangedFiles_;
   std::vector<std::string> wgCrossHsME1bFiles_;
+  std::vector<std::string> lctCombinationCodeFiles_;
 
   // unique pointers to the luts
   std::unique_ptr<CSCLUTReader> wg_cross_min_hs_ME1a_;
@@ -57,6 +84,8 @@ class CSCALCTCrossCLCT {
   std::unique_ptr<CSCLUTReader> wg_cross_max_hs_ME1a_ganged_;
   std::unique_ptr<CSCLUTReader> wg_cross_min_hs_ME1b_;
   std::unique_ptr<CSCLUTReader> wg_cross_max_hs_ME1b_;
+  std::unique_ptr<CSCLUTReader> code_to_best_lct_;
+  std::unique_ptr<CSCLUTReader> code_to_second_lct_;
 };
 
 #endif

L1Trigger/CSCTriggerPrimitives/interface/CSCAnodeLCTProcessor.h

@@ -74,10 +74,10 @@ class CSCAnodeLCTProcessor : public CSCBaseboard {
   void run(const std::vector<int> wire[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_WIREGROUPS]);
 
   /** Returns vector of ALCTs in the read-out time window, if any. */
-  std::vector<CSCALCTDigi> readoutALCTs(int nMaxALCTs = CSCConstants::MAX_ALCTS_READOUT) const;
+  std::vector<CSCALCTDigi> readoutALCTs() const;
 
   /** Returns vector of all found ALCTs, if any. */
-  std::vector<CSCALCTDigi> getALCTs(unsigned nMaxALCTs = CSCConstants::MAX_ALCTS_READOUT) const;
+  std::vector<CSCALCTDigi> getALCTs() const;
 
   /** read out pre-ALCTs */
   std::vector<CSCALCTPreTriggerDigi> preTriggerDigis() const { return thePreTriggerDigis; }
@@ -104,9 +104,6 @@ class CSCAnodeLCTProcessor : public CSCBaseboard {
   /** Second best LCTs in this chamber, as found by the processor. */
   CSCALCTDigi secondALCT[CSCConstants::MAX_ALCT_TBINS];
 
-  /** LCTs in this chamber, as found by the processor. */
-  std::vector<std::vector<CSCALCTDigi> > ALCTContainer_;
-
   CSCShowerDigi shower_;
 
   /** Access routines to wire digis. */

L1Trigger/CSCTriggerPrimitives/interface/CSCCathodeLCTProcessor.h

@@ -36,6 +36,7 @@
 #include "L1Trigger/CSCTriggerPrimitives/interface/CSCBaseboard.h"
 #include "L1Trigger/CSCTriggerPrimitives/interface/CSCLUTReader.h"
 #include "L1Trigger/CSCTriggerPrimitives/interface/LCTQualityControl.h"
+#include "L1Trigger/CSCTriggerPrimitives/interface/ComparatorCodeLUT.h"
 
 #include <vector>
 #include <array>
@@ -99,11 +100,6 @@ class CSCCathodeLCTProcessor : public CSCBaseboard {
   /** Second best LCT in this chamber, as found by the processor. */
   CSCCLCTDigi secondCLCT[CSCConstants::MAX_CLCT_TBINS];
 
-  // unique pointers to the luts
-  std::array<std::unique_ptr<CSCLUTReader>, 5> lutpos_;
-  std::array<std::unique_ptr<CSCLUTReader>, 5> lutslope_;
-  std::array<std::unique_ptr<CSCLUTReader>, 5> lutpatconv_;
-
   /** Access routines to comparator digis. */
   bool getDigis(const CSCComparatorDigiCollection* compdc);
   void getDigis(const CSCComparatorDigiCollection* compdc, const CSCDetId& id);
@@ -138,9 +134,6 @@ class CSCCathodeLCTProcessor : public CSCBaseboard {
                       const unsigned int bx_time,
                       std::map<int, std::map<int, CSCCLCTDigi::ComparatorContainer> >& hits_in_patterns);
 
-  // enum used in the comparator code logic
-  enum CLCT_CompCode { INVALID_HALFSTRIP = 65535 };
-
   void cleanComparatorContainer(CSCCLCTDigi& lct) const;
 
   /* Mark the half-strips around the best half-strip as busy */
@@ -156,17 +149,6 @@ class CSCCathodeLCTProcessor : public CSCBaseboard {
   void dumpDigis(
       const std::vector<int> strip[CSCConstants::NUM_LAYERS][CSCConstants::MAX_NUM_HALF_STRIPS_RUN2_TRIGGER]) const;
 
-  // --------Functions for the comparator code algorith for Run-3 ---------//
-  //calculates the id based on location of hits
-  int calculateComparatorCode(const std::array<std::array<int, 3>, 6>& halfStripPattern) const;
-
-  // sets the 1/4 and 1/8 strip bits given a floating point position offset
-  void assignPositionCC(const unsigned offset, std::tuple<int16_t, bool, bool>& returnValue) const;
-
-  // runs the CCLUT procedure
-  void runCCLUT(CSCCLCTDigi& digi) const;
-
-  unsigned convertSlopeToRun2Pattern(const unsigned slope) const;
   //--------------------------- Member variables -----------------------------
 
   /* best pattern Id for a given half-strip */
@@ -249,6 +231,9 @@ class CSCCathodeLCTProcessor : public CSCBaseboard {
 
   /* quality control */
   std::unique_ptr<LCTQualityControl> qualityControl_;
+
+  /* comparator-code lookup table algorithm */
+  std::unique_ptr<ComparatorCodeLUT> cclut_;
 };
 
 #endif

L1Trigger/CSCTriggerPrimitives/interface/CSCGEMMatcher.h

@@ -0,0 +1,159 @@
+#ifndef L1Trigger_CSCTriggerPrimitives_CSCGEMMatcher
+#define L1Trigger_CSCTriggerPrimitives_CSCGEMMatcher
+
+/** \class CSCGEMMatcher
+ *
+ * Helper class to check if an ALCT or CLCT matches with a GEMInternalCluster
+ *
+ * \author Sven Dildick (Rice University)
+ *
+ */
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#include <string>
+#include <vector>
+
+class CSCLUTReader;
+class CSCALCTDigi;
+class CSCCLCTDigi;
+class GEMInternalCluster;
+
+class CSCGEMMatcher {
+public:
+  typedef std::vector<GEMInternalCluster> GEMInternalClusters;
+
+  CSCGEMMatcher(int endcap,
+                unsigned station,
+                unsigned chamber,
+                const edm::ParameterSet& tmbParams,
+                const edm::ParameterSet& luts);
+
+  // calculate the bending angle
+  unsigned calculateGEMCSCBending(const CSCCLCTDigi& clct, const GEMInternalCluster& cluster) const;
+
+  // match by BX
+
+  // coincidences
+  void matchingClustersBX(const CSCALCTDigi& alct,
+                          const GEMInternalClusters& clusters,
+                          GEMInternalClusters& selected) const;
+
+  // coincidences
+  void matchingClustersBX(const CSCCLCTDigi& clct,
+                          const GEMInternalClusters& clusters,
+                          GEMInternalClusters& selected) const;
+
+  // coincidences or single clusters
+  void matchingClustersBX(const CSCALCTDigi& alct,
+                          const CSCCLCTDigi& clct,
+                          const GEMInternalClusters& clusters,
+                          GEMInternalClusters& selected) const;
+
+  // match by location
+
+  // coincidences
+  void matchingClustersLoc(const CSCALCTDigi& alct,
+                           const GEMInternalClusters& clusters,
+                           GEMInternalClusters& selected) const;
+
+  // coincidences
+  void matchingClustersLoc(const CSCCLCTDigi& clct,
+                           const GEMInternalClusters& clusters,
+                           GEMInternalClusters& selected) const;
+
+  // match by 1/2-strip
+  bool matchedClusterLocHS(const CSCCLCTDigi& clct, const GEMInternalCluster& cluster) const;
+
+  // match by 1/8-strip
+  bool matchedClusterLocES(const CSCCLCTDigi& clct, const GEMInternalCluster& cluster) const;
+
+  // coincidences or single clusters
+  void matchingClustersLoc(const CSCALCTDigi& alct,
+                           const CSCCLCTDigi& clct,
+                           const GEMInternalClusters& clusters,
+                           GEMInternalClusters& selected) const;
+
+  // match by BX and location
+
+  // coincidences
+  void matchingClustersBXLoc(const CSCALCTDigi& alct,
+                             const GEMInternalClusters& clusters,
+                             GEMInternalClusters& selected) const;
+
+  // coincidences
+  void matchingClustersBXLoc(const CSCCLCTDigi& clct,
+                             const GEMInternalClusters& clusters,
+                             GEMInternalClusters& selected) const;
+
+  // coincidences or single clusters
+  void matchingClustersBXLoc(const CSCALCTDigi& alct,
+                             const CSCCLCTDigi& clct,
+                             const GEMInternalClusters& clusters,
+                             GEMInternalClusters& selected) const;
+
+  // best matching clusters
+  void bestClusterBXLoc(const CSCALCTDigi& alct, const GEMInternalClusters& clusters, GEMInternalCluster& best) const;
+
+  // coincidences
+  void bestClusterBXLoc(const CSCCLCTDigi& clct, const GEMInternalClusters& clusters, GEMInternalCluster& best) const;
+
+  // coincidences or single clusters
+  void bestClusterBXLoc(const CSCALCTDigi& alct,
+                        const CSCCLCTDigi& clct,
+                        const GEMInternalClusters& clusters,
+                        GEMInternalCluster& best) const;
+
+private:
+  // calculate slope correction
+  int CSCGEMSlopeCorrector(const bool isFacing, const bool isL1orCopad, const int cscSlope) const;
+
+  unsigned endcap_;
+  unsigned station_;
+  unsigned ring_;
+  unsigned chamber_;
+  bool isEven_;
+
+  unsigned maxDeltaBXALCTGEM_;
+  unsigned maxDeltaBXCLCTGEM_;
+
+  unsigned maxDeltaHsEven_;
+  unsigned maxDeltaHsOdd_;
+  unsigned maxDeltaHsEvenME1a_;
+  unsigned maxDeltaHsOddME1a_;
+
+  bool assign_gem_csc_bending_;
+
+  // strings to paths of LUTs
+  std::vector<std::string> gemCscSlopeCorrectionFiles_;
+  std::vector<std::string> esDiffToSlopeME1aFiles_;
+  std::vector<std::string> esDiffToSlopeME1bFiles_;
+  std::vector<std::string> esDiffToSlopeME21Files_;
+
+  // unique pointers to the luts
+  std::unique_ptr<CSCLUTReader> gem_csc_slope_corr_L1_ME11_even_;
+  std::unique_ptr<CSCLUTReader> gem_csc_slope_corr_L2_ME11_even_;
+  std::unique_ptr<CSCLUTReader> gem_csc_slope_corr_L1_ME11_odd_;
+  std::unique_ptr<CSCLUTReader> gem_csc_slope_corr_L2_ME11_odd_;
+
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L1_ME1b_even_;
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L2_ME1b_even_;
+
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L1_ME1b_odd_;
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L2_ME1b_odd_;
+
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L1_ME1a_even_;
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L2_ME1a_even_;
+
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L1_ME1a_odd_;
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L2_ME1a_odd_;
+
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L1_ME21_even_;
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L2_ME21_even_;
+
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L1_ME21_odd_;
+  std::unique_ptr<CSCLUTReader> es_diff_slope_L2_ME21_odd_;
+};
+
+#endif

L1Trigger/CSCTriggerPrimitives/interface/CSCTriggerPrimitivesBuilder.h

@@ -69,9 +69,7 @@ class CSCTriggerPrimitivesBuilder {
              const CSCComparatorDigiCollection* compdc,
              const GEMPadDigiClusterCollection* gemPadClusters,
              CSCALCTDigiCollection& oc_alct,
-             CSCALCTDigiCollection& oc_alct_all,
              CSCCLCTDigiCollection& oc_clct,
-             CSCCLCTDigiCollection& oc_clct_all,
              CSCALCTPreTriggerDigiCollection& oc_alctpretrigger,
              CSCCLCTPreTriggerDigiCollection& oc_clctpretrigger,
              CSCCLCTPreTriggerCollection& oc_pretrig,

L1Trigger/CSCTriggerPrimitives/interface/ComparatorCodeLUT.h

@@ -0,0 +1,60 @@
+#ifndef L1Trigger_CSCTriggerPrimitives_ComparatorCodeLUT
+#define L1Trigger_CSCTriggerPrimitives_ComparatorCodeLUT
+
+/** \class ComparatorCodeLUT
+ *
+ * Helper class to calculate for the comparator code
+ * algorithm for Phase-2.
+ *
+ * \author Sven Dildick (Rice University)
+ *
+ */
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "DataFormats/CSCDigi/interface/CSCConstants.h"
+#include "DataFormats/CSCDigi/interface/CSCCLCTDigi.h"
+#include "L1Trigger/CSCTriggerPrimitives/interface/CSCLUTReader.h"
+#include "L1Trigger/CSCTriggerPrimitives/interface/CSCPatternBank.h"
+
+#include <vector>
+#include <string>
+
+class CSCCLCTDigi;
+
+class ComparatorCodeLUT {
+public:
+  typedef std::array<std::array<int, 3>, CSCConstants::NUM_LAYERS> pattern;
+
+  // constructor
+  ComparatorCodeLUT(const edm::ParameterSet& conf);
+
+  // runs the CCLUT procedure
+  void run(CSCCLCTDigi& digi, unsigned numCFEBs) const;
+
+private:
+  //calculates the id based on location of hits
+  int calculateComparatorCode(const pattern& halfStripPattern) const;
+
+  unsigned convertSlopeToRun2Pattern(const unsigned slope) const;
+
+  // sets the 1/4 and 1/8 strip bits given a floating point position offset
+  void assignPositionCC(const unsigned offset, std::tuple<int16_t, bool, bool>& returnValue) const;
+
+  // actual LUT used
+  CSCPatternBank::LCTPatterns clct_pattern_ = {};
+
+  std::vector<std::string> positionLUTFiles_;
+  std::vector<std::string> slopeLUTFiles_;
+  std::vector<std::string> patternConversionLUTFiles_;
+
+  // unique pointers to the luts
+  std::array<std::unique_ptr<CSCLUTReader>, CSCConstants::NUM_CLCT_PATTERNS_RUN3> lutpos_;
+  std::array<std::unique_ptr<CSCLUTReader>, CSCConstants::NUM_CLCT_PATTERNS_RUN3> lutslope_;
+  std::array<std::unique_ptr<CSCLUTReader>, CSCConstants::NUM_CLCT_PATTERNS_RUN3> lutpatconv_;
+
+  // verbosity level
+  unsigned infoV_;
+};
+
+#endif