Compatibility with new electronics simulation

DataFormats/L1THGCal/interface/HGCalTowerID.h

@@ -28,15 +28,16 @@ namespace l1t {
 
     unsigned short rawId() const { return rawId_; }
 
-  private:
-    uint32_t rawId_;
     static const int subDetMask = 0x1;  // two for now 0 is HGC and 1 is HFNose
     static const int subDetShift = 16;
     static const int zsideMask = 0x1;
     static const int zsideShift = 15;
     static const int coordMask = 0x007F;
     static const int coord1Shift = 7;
     static const int coord2Shift = 0;
+
+  private:
+    uint32_t rawId_;
   };
 
   struct HGCalTowerCoord {

DataFormats/L1THGCal/interface/HGCalTowerMap.h

@@ -22,7 +22,7 @@ namespace l1t {
 
     const HGCalTowerMap& operator+=(const HGCalTowerMap& map);
 
-    bool addEt(short bin_id, float etEm, float etHad);
+    bool addEt(const std::unordered_map<unsigned short, float>& towerIDandShares, float etEm, float etHad);
 
     unsigned nTowers() const { return towerMap_.size(); }
     const std::unordered_map<unsigned short, l1t::HGCalTower>& towers() const { return towerMap_; }

DataFormats/L1THGCal/src/HGCalTowerMap.cc

@@ -30,12 +30,13 @@ const HGCalTowerMap& HGCalTowerMap::operator+=(const HGCalTowerMap& map) {
   return *this;
 }
 
-bool HGCalTowerMap::addEt(short bin_id, float etEm, float etHad) {
-  auto this_tower = towerMap_.find(bin_id);
-  if (this_tower == towerMap_.end())
-    return false;
-  this_tower->second.addEtEm(etEm);
-  this_tower->second.addEtHad(etHad);
-
+bool HGCalTowerMap::addEt(const std::unordered_map<unsigned short, float>& towerIDandShares, float etEm, float etHad) {
+  for (const auto& towerIDandShare : towerIDandShares) {
+    auto this_tower = towerMap_.find(towerIDandShare.first);
+    if (this_tower == towerMap_.end())
+      return false;
+    this_tower->second.addEtEm(etEm * towerIDandShare.second);
+    this_tower->second.addEtHad(etHad * towerIDandShare.second);
+  }
   return true;
 }

L1Trigger/L1THGCal/BuildFile.xml

@@ -5,6 +5,7 @@
 <use name="Geometry/Records"/>
 <use name="DataFormats/L1THGCal"/>
 <use name="SimDataFormats/CaloTest"/>
+<use name="SimCalorimetry/HGCalSimAlgos"/>
 <use name="PhysicsTools/TensorFlow" />
 <use name="json" />
 <export>

L1Trigger/L1THGCal/interface/HGCalAlgoWrapperBase.h

@@ -0,0 +1,43 @@
+#ifndef __L1Trigger_L1THGCal_HGCalAlgoWrapperBase_h__
+#define __L1Trigger_L1THGCal_HGCalAlgoWrapperBase_h__
+
+#include "L1Trigger/L1THGCal/interface/HGCalAlgoWrapperBaseT.h"
+#include "L1Trigger/L1THGCal/interface/HGCalTriggerGeometryBase.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#include "DataFormats/L1THGCal/interface/HGCalCluster.h"
+#include "DataFormats/L1THGCal/interface/HGCalMulticluster.h"
+
+#include "DataFormats/L1THGCal/interface/HGCalTowerMap.h"
+
+typedef HGCalAlgoWrapperBaseT<
+    std::pair<const std::vector<edm::Ptr<l1t::HGCalCluster>>, const std::vector<std::pair<GlobalPoint, double>>>,
+    std::pair<l1t::HGCalMulticlusterBxCollection&, l1t::HGCalClusterBxCollection&>,
+    std::pair<const HGCalTriggerGeometryBase* const, const edm::ParameterSet&>>
+    HGCalHistoClusteringWrapperBase;
+
+typedef HGCalAlgoWrapperBaseT<std::vector<edm::Ptr<l1t::HGCalTowerMap>>,
+                              l1t::HGCalTowerBxCollection,
+                              std::pair<const HGCalTriggerGeometryBase* const, const edm::ParameterSet&>>
+    HGCalTowerMapsWrapperBase;
+
+typedef HGCalAlgoWrapperBaseT<l1t::HGCalMulticlusterBxCollection,
+                              l1t::HGCalMulticlusterBxCollection,
+                              std::pair<const HGCalTriggerGeometryBase* const, const edm::ParameterSet&>>
+    HGCalStage2FilteringWrapperBase;
+
+typedef HGCalAlgoWrapperBaseT<std::vector<edm::Ptr<l1t::HGCalTriggerCell>>,
+                              std::vector<edm::Ptr<l1t::HGCalTriggerCell>>,
+                              std::tuple<const HGCalTriggerGeometryBase* const, const unsigned&, const uint32_t&>>
+    HGCalStage1TruncationWrapperBase;
+
+#include "FWCore/PluginManager/interface/PluginFactory.h"
+typedef edmplugin::PluginFactory<HGCalHistoClusteringWrapperBase*(const edm::ParameterSet&)>
+    HGCalHistoClusteringWrapperBaseFactory;
+typedef edmplugin::PluginFactory<HGCalTowerMapsWrapperBase*(const edm::ParameterSet&)> HGCalTowerMapsWrapperBaseFactory;
+typedef edmplugin::PluginFactory<HGCalStage2FilteringWrapperBase*(const edm::ParameterSet&)>
+    HGCalStage2FilteringWrapperBaseFactory;
+typedef edmplugin::PluginFactory<HGCalStage1TruncationWrapperBase*(const edm::ParameterSet&)>
+    HGCalStage1TruncationWrapperBaseFactory;
+
+#endif

L1Trigger/L1THGCal/interface/HGCalAlgoWrapperBaseT.h

@@ -0,0 +1,23 @@
+#ifndef __L1Trigger_L1THGCal_HGCalAlgoWrapperBaseT_h__
+#define __L1Trigger_L1THGCal_HGCalAlgoWrapperBaseT_h__
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include <string>
+
+template <typename InputCollection, typename OutputCollection, typename Tparam>
+class HGCalAlgoWrapperBaseT {
+public:
+  HGCalAlgoWrapperBaseT(const edm::ParameterSet& conf) : name_(conf.getParameter<std::string>("AlgoName")) {}
+
+  virtual ~HGCalAlgoWrapperBaseT() {}
+
+  virtual void configure(const Tparam& parameters) = 0;
+  virtual void process(const InputCollection& inputCollection, OutputCollection& outputCollection) const = 0;
+
+  const std::string& name() const { return name_; }
+
+private:
+  const std::string name_;
+};
+
+#endif

L1Trigger/L1THGCal/interface/HGCalProcessorBase.h

@@ -19,24 +19,28 @@ typedef HGCalProcessorBaseT<HGCalDigiCollection, l1t::HGCalTriggerCellBxCollecti
 typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalTriggerCellBxCollection>,
                             std::tuple<l1t::HGCalTriggerCellBxCollection,
                                        l1t::HGCalTriggerSumsBxCollection,
-                                       l1t::HGCalConcentratorDataBxCollection> >
+                                       l1t::HGCalConcentratorDataBxCollection>>
     HGCalConcentratorProcessorBase;
 typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalTriggerCellBxCollection>, l1t::HGCalClusterBxCollection>
     HGCalBackendLayer1ProcessorBase;
+typedef HGCalProcessorBaseT<std::pair<uint32_t, std::vector<edm::Ptr<l1t::HGCalTriggerCell>>>,
+                            std::vector<edm::Ptr<l1t::HGCalTriggerCell>>>
+    HGCalBackendStage1ProcessorBase;
 typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalClusterBxCollection>,
-                            std::pair<l1t::HGCalMulticlusterBxCollection, l1t::HGCalClusterBxCollection> >
+                            std::pair<l1t::HGCalMulticlusterBxCollection, l1t::HGCalClusterBxCollection>>
     HGCalBackendLayer2ProcessorBase;
 typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalTriggerSumsBxCollection>, l1t::HGCalTowerMapBxCollection>
     HGCalTowerMapProcessorBase;
 typedef HGCalProcessorBaseT<
-    std::pair<edm::Handle<l1t::HGCalTowerMapBxCollection>, edm::Handle<l1t::HGCalClusterBxCollection> >,
+    std::pair<edm::Handle<l1t::HGCalTowerMapBxCollection>, edm::Handle<l1t::HGCalClusterBxCollection>>,
     l1t::HGCalTowerBxCollection>
     HGCalTowerProcessorBase;
 
 #include "FWCore/PluginManager/interface/PluginFactory.h"
 typedef edmplugin::PluginFactory<HGCalVFEProcessorBase*(const edm::ParameterSet&)> HGCalVFEProcessorBaseFactory;
 typedef edmplugin::PluginFactory<HGCalConcentratorProcessorBase*(const edm::ParameterSet&)> HGCalConcentratorFactory;
 typedef edmplugin::PluginFactory<HGCalBackendLayer1ProcessorBase*(const edm::ParameterSet&)> HGCalBackendLayer1Factory;
+typedef edmplugin::PluginFactory<HGCalBackendStage1ProcessorBase*(const edm::ParameterSet&)> HGCalBackendStage1Factory;
 typedef edmplugin::PluginFactory<HGCalBackendLayer2ProcessorBase*(const edm::ParameterSet&)> HGCalBackendLayer2Factory;
 typedef edmplugin::PluginFactory<HGCalTowerMapProcessorBase*(const edm::ParameterSet&)> HGCalTowerMapFactory;
 typedef edmplugin::PluginFactory<HGCalTowerProcessorBase*(const edm::ParameterSet&)> HGCalTowerFactory;

L1Trigger/L1THGCal/interface/HGCalTriggerCellCalibration.h

@@ -5,23 +5,30 @@
 
 #include "DataFormats/L1THGCal/interface/HGCalTriggerCell.h"
 #include "L1Trigger/L1THGCal/interface/HGCalTriggerTools.h"
+#include "SimCalorimetry/HGCalSimAlgos/interface/HGCalSiNoiseMap.h"
+#include "SimCalorimetry/HGCalSimAlgos/interface/HGCalSciNoiseMap.h"
 
 class HGCalTriggerCellCalibration {
 public:
-  HGCalTriggerCellCalibration(const edm::ParameterSet& conf);
-  void setGeometry(const HGCalTriggerGeometryBase* const geom) { triggerTools_.setGeometry(geom); }
+  HGCalTriggerCellCalibration(const edm::ParameterSet& conf, DetId::Detector det);
+  void setGeometry(const HGCalTriggerGeometryBase* const geom);
   void calibrateInMipT(l1t::HGCalTriggerCell&) const;
   void calibrateMipTinGeV(l1t::HGCalTriggerCell&) const;
   void calibrateInGeV(l1t::HGCalTriggerCell&) const;
 
 private:
+  DetId::Detector detector_;
+
   double lsb_;
   std::vector<double> fCperMIP_;
   std::vector<double> chargeCollectionEfficiency_;
   std::vector<double> thicknessCorrection_;
   std::vector<double> dEdX_weights_;
 
   HGCalTriggerTools triggerTools_;
+  bool old_digi_ = false;
+  mutable HGCalSiNoiseMap<HGCSiliconDetId> noise_map_;
+  mutable HGCalSciNoiseMap noise_map_sci_;
 };
 
 #endif

L1Trigger/L1THGCal/interface/HGCalTriggerTowerGeometryHelper.h

@@ -15,6 +15,7 @@
 #include "L1Trigger/L1THGCal/interface/HGCalTriggerTools.h"
 #include "DataFormats/L1THGCal/interface/HGCalTriggerCell.h"
 #include "DataFormats/L1THGCal/interface/HGCalTriggerSums.h"
+#include "DataFormats/ForwardDetId/interface/HGCalTriggerModuleDetId.h"
 
 #include <vector>
 #include <unordered_map>
@@ -32,17 +33,29 @@ class HGCalTriggerTowerGeometryHelper {
 
   void setGeometry(const HGCalTriggerGeometryBase* const geom) { triggerTools_.setGeometry(geom); }
 
+  unsigned packLayerSubdetWaferId(int subdet, int layer, int moduleU, int moduleV) const;
+  unsigned packTowerIDandShare(int towerEta, int towerPhi, int towerShare) const;
+  void unpackTowerIDandShare(unsigned towerIDandShare, int& towerEta_raw, int& towerPhi_raw, int& towerShare) const;
+  int moveToCorrectSector(int towerPhi_raw, int sector) const;
+  void reverseXaxis(int& towerPhi) const;
+
   const std::vector<l1t::HGCalTowerCoord>& getTowerCoordinates() const;
 
   unsigned short getTriggerTowerFromEtaPhi(const float& eta, const float& phi) const;
-  unsigned short getTriggerTower(const l1t::HGCalTriggerCell&) const;
-  unsigned short getTriggerTower(const l1t::HGCalTriggerSums&) const;
+  std::unordered_map<unsigned short, float> getTriggerTower(const l1t::HGCalTriggerCell&) const;
+  std::unordered_map<unsigned short, float> getTriggerTower(const l1t::HGCalTriggerSums&) const;
 
   const bool isNose() { return doNose_; }
 
 private:
+  static const int towerShareMask = 0x7F;
+  static const int towerShareShift = 14;
+  static const int signMask = 0x1;
+  static const int sign1Shift = 21;
+  static const int sign2Shift = 22;
   std::vector<l1t::HGCalTowerCoord> tower_coords_;
   std::unordered_map<unsigned, short> cells_to_trigger_towers_;
+  std::unordered_map<unsigned, std::vector<unsigned>> modules_to_trigger_towers_;
 
   bool doNose_;
   double minEta_;
@@ -55,6 +68,13 @@ class HGCalTriggerTowerGeometryHelper {
   std::vector<double> binsEta_;
   std::vector<double> binsPhi_;
 
+  bool splitModuleSum_;
+  int splitDivisorSilic_;
+  int splitDivisorScint_;
+  int rotate180Deg_;
+  int rotate120Deg_;
+  int reverseX_;
+
   HGCalTriggerTools triggerTools_;
 };
 

L1Trigger/L1THGCal/interface/backend/HGCalBackendLayer1Processor.h

@@ -0,0 +1,24 @@
+#ifndef __L1Trigger_L1THGCal_HGCalBackendLayer1Processor_h__
+#define __L1Trigger_L1THGCal_HGCalBackendLayer1Processor_h__
+
+#include "L1Trigger/L1THGCal/interface/HGCalProcessorBase.h"
+
+#include "DataFormats/L1THGCal/interface/HGCalTriggerCell.h"
+#include "DataFormats/L1THGCal/interface/HGCalCluster.h"
+
+#include "L1Trigger/L1THGCal/interface/backend/HGCalStage1TruncationImpl.h"
+#include "L1Trigger/L1THGCal/interface/backend/HGCalClusteringDummyImpl.h"
+
+class HGCalBackendLayer1Processor : public HGCalBackendLayer1ProcessorBase {
+public:
+  HGCalBackendLayer1Processor(const edm::ParameterSet& conf);
+
+  void run(const edm::Handle<l1t::HGCalTriggerCellBxCollection>& collHandle,
+           l1t::HGCalClusterBxCollection& collCluster2D) override;
+
+private:
+  std::unique_ptr<HGCalClusteringDummyImpl> clusteringDummy_;
+  std::unique_ptr<HGCalStage1TruncationImpl> truncation_;
+};
+
+#endif

L1Trigger/L1THGCal/interface/backend/HGCalBackendStage1Processor.h

@@ -0,0 +1,25 @@
+#ifndef __L1Trigger_L1THGCal_HGCalBackendStage1Processor_h__
+#define __L1Trigger_L1THGCal_HGCalBackendStage1Processor_h__
+
+#include "L1Trigger/L1THGCal/interface/HGCalProcessorBase.h"
+#include "L1Trigger/L1THGCal/interface/HGCalAlgoWrapperBase.h"
+
+#include "DataFormats/L1THGCal/interface/HGCalTriggerCell.h"
+#include "DataFormats/L1THGCal/interface/HGCalCluster.h"
+
+#include "L1Trigger/L1THGCal/interface/backend/HGCalStage1TruncationImpl.h"
+#include "L1Trigger/L1THGCal/interface/backend/HGCalClusteringDummyImpl.h"
+
+class HGCalBackendStage1Processor : public HGCalBackendStage1ProcessorBase {
+public:
+  HGCalBackendStage1Processor(const edm::ParameterSet& conf);
+
+  void run(const std::pair<uint32_t, std::vector<edm::Ptr<l1t::HGCalTriggerCell>>>& fpga_id_tcs,
+           std::vector<edm::Ptr<l1t::HGCalTriggerCell>>& truncated_tcs) override;
+
+private:
+  std::unique_ptr<HGCalStage1TruncationWrapperBase> truncationWrapper_;
+  const edm::ParameterSet conf_;
+};
+
+#endif

L1Trigger/L1THGCal/interface/backend/HGCalCluster_SA.h

@@ -0,0 +1,61 @@
+#ifndef L1Trigger_L1THGCal_HGCalCluster_SA_h
+#define L1Trigger_L1THGCal_HGCalCluster_SA_h
+
+#include <vector>
+
+namespace l1thgcfirmware {
+
+  class HGCalCluster {
+  public:
+    HGCalCluster(float x,
+                 float y,
+                 float z,
+                 int zside,
+                 unsigned int layer,
+                 float eta,
+                 float phi,
+                 float pt,
+                 float mipPt,
+                 unsigned int index_cmssw)
+        : x_(x),
+          y_(y),
+          z_(z),
+          zside_(zside),
+          layer_(layer),
+          eta_(eta),
+          phi_(phi),
+          pt_(pt),
+          mipPt_(mipPt),
+          index_cmssw_(index_cmssw) {}
+
+    ~HGCalCluster(){};
+
+    float x() const { return x_; }
+    float y() const { return y_; }
+    float z() const { return z_; }
+    float zside() const { return zside_; }
+    unsigned int layer() const { return layer_; }
+    float eta() const { return eta_; }
+    float phi() const { return phi_; }
+    float pt() const { return pt_; }
+    float mipPt() const { return mipPt_; }
+    unsigned int index_cmssw() const { return index_cmssw_; }
+
+  private:
+    float x_;
+    float y_;
+    float z_;
+    int zside_;
+    unsigned int layer_;
+    float eta_;
+    float phi_;
+    float pt_;
+    float mipPt_;
+    unsigned int index_cmssw_;
+  };
+
+  typedef std::vector<HGCalCluster> HGCalClusterSACollection;
+
+}  // namespace l1thgcfirmware
+
+#endif