Merge pull request cms-sw#37880 from a-kapoor/pfID_for_eleInExtendedEta

Particle flow identification of electrons in extended eta
theochatzis · May 14, 2022 · 7642c50 · 7642c50
2 parents e0e5d86 + 48ce095
commit 7642c50
Show file tree

Hide file tree

Showing 14 changed files with 120 additions and 84 deletions.
diff --git a/HLTrigger/Configuration/python/HLT_75e33/modules/particleFlowTmpBarrel_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/modules/particleFlowTmpBarrel_cfi.py
@@ -5,7 +5,6 @@
     GedPhotonValueMap = cms.InputTag("gedPhotonsTmp","valMapPFEgammaCandToPhoton"),
     PFEGammaCandidates = cms.InputTag("particleFlowEGamma"),
     PFEGammaFiltersParameters = cms.PSet(
-        allowEEEinPF = cms.bool(False),
         electronDnnBkgThresholds = cms.PSet(
             electronDnnBkgHighPtBarrelThr = cms.double(0.8),
             electronDnnBkgHighPtEndcapThr = cms.double(0.75),

diff --git a/RecoEgamma/EgammaElectronAlgos/src/GsfElectronAlgo.cc b/RecoEgamma/EgammaElectronAlgos/src/GsfElectronAlgo.cc
@@ -55,7 +55,7 @@ GsfElectronAlgo::HeavyObjectCache::HeavyObjectCache(const edm::ParameterSet& con
     dconfig.outputTensorName = pset_dnn.getParameter<std::string>("outputTensorName");
     dconfig.modelsFiles = pset_dnn.getParameter<std::vector<std::string>>("modelsFiles");
     dconfig.scalersFiles = pset_dnn.getParameter<std::vector<std::string>>("scalersFiles");
-    dconfig.outputDim = pset_dnn.getParameter<uint>("outputDim");
+    dconfig.outputDim = pset_dnn.getParameter<std::vector<unsigned int>>("outputDim");
     const auto useEBModelInGap = pset_dnn.getParameter<bool>("useEBModelInGap");
     iElectronDNNEstimator = std::make_unique<ElectronDNNEstimator>(dconfig, useEBModelInGap);
   }

diff --git a/RecoEgamma/EgammaElectronProducers/plugins/GsfElectronProducer.cc b/RecoEgamma/EgammaElectronProducers/plugins/GsfElectronProducer.cc
@@ -35,6 +35,7 @@ namespace {
                      const GsfElectronAlgo::HeavyObjectCache* hoc,
                      reco::VertexCollection const& vertices,
                      bool dnnPFidEnabled,
+                     float extetaboundary,
                      const std::vector<tensorflow::Session*>& tfSessions) {
     std::vector<GsfElectron::MvaOutput> mva_outputs(electrons.size());
     size_t iele = 0;
@@ -58,11 +59,20 @@ namespace {
         const auto& values = dnn_ele_pfid[jele];
         // get the previous values
         auto& mvaOutput = mva_outputs[jele];
-        mvaOutput.dnn_e_sigIsolated = values[0];
-        mvaOutput.dnn_e_sigNonIsolated = values[1];
-        mvaOutput.dnn_e_bkgNonIsolated = values[2];
-        mvaOutput.dnn_e_bkgTau = values[3];
-        mvaOutput.dnn_e_bkgPhoton = values[4];
+
+        if (abs(el.superCluster()->eta()) <= extetaboundary) {
+          mvaOutput.dnn_e_sigIsolated = values[0];
+          mvaOutput.dnn_e_sigNonIsolated = values[1];
+          mvaOutput.dnn_e_bkgNonIsolated = values[2];
+          mvaOutput.dnn_e_bkgTau = values[3];
+          mvaOutput.dnn_e_bkgPhoton = values[4];
+        } else {
+          mvaOutput.dnn_e_sigIsolated = values[0];
+          mvaOutput.dnn_e_sigNonIsolated = 0.0;
+          mvaOutput.dnn_e_bkgNonIsolated = values[1];
+          mvaOutput.dnn_e_bkgTau = 0.0;
+          mvaOutput.dnn_e_bkgPhoton = values[2];
+        }
         el.setMvaOutput(mvaOutput);
         jele++;
       }
@@ -151,6 +161,7 @@ class GsfElectronProducer : public edm::stream::EDProducer<edm::GlobalCache<GsfE
   const bool resetMvaValuesUsingPFCandidates_;
 
   bool dnnPFidEnabled_;
+  float extetaboundary_;
 
   std::vector<tensorflow::Session*> tfSessions_;
 };
@@ -289,19 +300,27 @@ void GsfElectronProducer::fillDescriptions(edm::ConfigurationDescriptions& descr
   {
     edm::ParameterSetDescription psd1;
     psd1.add<bool>("enabled", false);
+    psd1.add<double>("extetaboundary", 2.65);
     psd1.add<std::string>("inputTensorName", "FirstLayer_input");
     psd1.add<std::string>("outputTensorName", "sequential/FinalLayer/Softmax");
-    psd1.add<uint>("outputDim", 5);  // Number of output nodes of DNN
+
     psd1.add<std::vector<std::string>>(
         "modelsFiles",
-        {"RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/v1/lowpT/lowpT_modelDNN.pb",
-         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/v1/highpTEB/highpTEB_modelDNN.pb",
-         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/v1/highpTEE/highpTEE_modelDNN.pb"});
+        {"RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/lowpT/lowpT_modelDNN.pb",
+         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/highpTEB/highpTEB_modelDNN.pb",
+         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/highpTEE/highpTEE_modelDNN.pb",
+         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta1/modelDNN.pb",
+         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta2/modelDNN.pb"});
     psd1.add<std::vector<std::string>>(
         "scalersFiles",
-        {"RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/v1/lowpT/lowpT_scaler.txt",
-         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/v1/highpTEB/highpTEB_scaler.txt",
-         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/v1/highpTEE/highpTEE_scaler.txt"});
+        {"RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/lowpT/lowpT_scaler.txt",
+         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/highpTEB/highpTEB_scaler.txt",
+         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/highpTEE/highpTEE_scaler.txt",
+         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta1/scaler.txt",
+         "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta2/scaler.txt"});
+    psd1.add<std::vector<unsigned int>>("outputDim",  //Number of output nodes for the above models
+                                        {5, 5, 5, 5, 3});
+
     psd1.add<bool>("useEBModelInGap", true);
     // preselection parameters
     desc.add<edm::ParameterSetDescription>("EleDNNPFid", psd1);
@@ -414,6 +433,7 @@ GsfElectronProducer::GsfElectronProducer(const edm::ParameterSet& cfg, const Gsf
   // Config for PFID dnn
   const auto& pset_dnn = cfg.getParameter<edm::ParameterSet>("EleDNNPFid");
   dnnPFidEnabled_ = pset_dnn.getParameter<bool>("enabled");
+  extetaboundary_ = pset_dnn.getParameter<double>("extetaboundary");
 
   strategyCfg_.useDefaultEnergyCorrection = cfg.getParameter<bool>("useDefaultEnergyCorrection");
 
@@ -724,7 +744,8 @@ void GsfElectronProducer::produce(edm::Event& event, const edm::EventSetup& setu
     for (auto& el : electrons) {
       el.setMvaInput(gsfMVAInputMap.find(el.gsfTrack())->second);  // set Run2 MVA inputs
     }
-    setMVAOutputs(electrons, globalCache(), event.get(inputCfg_.vtxCollectionTag), dnnPFidEnabled_, tfSessions_);
+    setMVAOutputs(
+        electrons, globalCache(), event.get(inputCfg_.vtxCollectionTag), dnnPFidEnabled_, extetaboundary_, tfSessions_);
   }
 
   // all electrons

diff --git a/RecoEgamma/EgammaElectronProducers/python/gedGsfElectrons_cfi.py b/RecoEgamma/EgammaElectronProducers/python/gedGsfElectrons_cfi.py
@@ -26,12 +26,17 @@
         modelsFiles = [
             "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/lowpT/lowpT_modelDNN.pb",
             "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/EB_highpT/barrel_highpT_modelDNN.pb",
-            "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/EE_highpT/endcap_highpT_modelDNN.pb"
+            "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/EE_highpT/endcap_highpT_modelDNN.pb",
+            "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta1/modelDNN.pb",
+            "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta2/modelDNN.pb"
         ],
         scalersFiles = [
             "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/lowpT/lowpT_scaler.txt",
             "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/EB_highpT/barrel_highpT_scaler.txt",
-            "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/EE_highpT/endcap_highpT_scaler.txt"
+            "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/EE_highpT/endcap_highpT_scaler.txt",
+            "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta1/scaler.txt",
+            "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta2/scaler.txt"
+
         ]
     )    
 )
@@ -53,4 +58,4 @@
 from Configuration.Eras.Modifier_run3_common_cff import run3_common
 run3_common.toModify(gedGsfElectronsTmp.EleDNNPFid,
     enabled = True
-)
+)
diff --git a/RecoEgamma/EgammaPhotonProducers/python/gedPhotons_cfi.py b/RecoEgamma/EgammaPhotonProducers/python/gedPhotons_cfi.py
@@ -113,7 +113,7 @@
                     'RecoEgamma/PhotonIdentification/data/Photon_PFID_dnn/v1/EB/EB_scaler.txt',
                     'RecoEgamma/PhotonIdentification/data/Photon_PFID_dnn/v1/EE/EE_scaler.txt'
         ),
-        outputDim = cms.uint32(1),
+        outputDim = cms.vuint32(1,1),
         useEBModelInGap = cms.bool(True)
     ),
 

diff --git a/RecoEgamma/EgammaPhotonProducers/python/photons_cfi.py b/RecoEgamma/EgammaPhotonProducers/python/photons_cfi.py
@@ -104,7 +104,7 @@
                     'RecoEgamma/PhotonIdentification/data/Photon_PFID_dnn/v1/EB/EB_scaler.txt',
                     'RecoEgamma/PhotonIdentification/data/Photon_PFID_dnn/v1/EE/EE_scaler.txt'
         ),
-        outputDim = cms.uint32(1),
+        outputDim = cms.vuint32(1,1),
         useEBModelInGap = cms.bool(True)
     ),
     pfECALClusIsolCfg = cms.PSet(

diff --git a/RecoEgamma/EgammaPhotonProducers/src/GEDPhotonProducer.cc b/RecoEgamma/EgammaPhotonProducers/src/GEDPhotonProducer.cc
@@ -66,7 +66,7 @@ class CacheData {
       config.outputTensorName = pset_dnn.getParameter<std::string>("outputTensorName");
       config.modelsFiles = pset_dnn.getParameter<std::vector<std::string>>("modelsFiles");
       config.scalersFiles = pset_dnn.getParameter<std::vector<std::string>>("scalersFiles");
-      config.outputDim = pset_dnn.getParameter<uint>("outputDim");
+      config.outputDim = pset_dnn.getParameter<std::vector<unsigned int>>("outputDim");
       const auto useEBModelInGap = pset_dnn.getParameter<bool>("useEBModelInGap");
       photonDNNEstimator = std::make_unique<PhotonDNNEstimator>(config, useEBModelInGap);
     }

diff --git a/RecoEgamma/EgammaTools/interface/EgammaDNNHelper.h b/RecoEgamma/EgammaTools/interface/EgammaDNNHelper.h
@@ -19,7 +19,7 @@ namespace egammaTools {
     std::string outputTensorName;
     std::vector<std::string> modelsFiles;
     std::vector<std::string> scalersFiles;
-    uint outputDim = 1;
+    std::vector<unsigned int> outputDim;
   };
 
   struct ScalerConfiguration {

diff --git a/RecoEgamma/EgammaTools/src/EgammaDNNHelper.cc b/RecoEgamma/EgammaTools/src/EgammaDNNHelper.cc
@@ -42,7 +42,7 @@ void EgammaDNNHelper::initScalerFiles(const std::vector<std::string>& availableV
     std::ifstream inputfile_scaler{edm::FileInPath(scaler_file).fullPath()};
     int ninputs = 0;
     if (inputfile_scaler.fail()) {
-      throw cms::Exception("MissingFile") << "Scaler file for Electron PFid DNN not found";
+      throw cms::Exception("MissingFile") << "Scaler file for PFid DNN not found";
     } else {
       // Now read mean, scale factors for each variable
       float par1, par2;
@@ -159,15 +159,19 @@ std::vector<std::vector<float>> EgammaDNNHelper::evaluate(const std::vector<std:
     if (counts[m] == 0)
       continue;  //Skip model witout inputs
     std::vector<tensorflow::Tensor> output;
-    LogDebug("EgammaDNNHelper") << "Run model: " << m << " with " << counts[m] << " electrons";
+    LogDebug("EgammaDNNHelper") << "Run model: " << m << " with " << counts[m] << "objects";
     tensorflow::run(sessions[m], {{cfg_.inputTensorName, input_tensors[m]}}, {cfg_.outputTensorName}, &output);
     // Get the output and save the ElectronDNNEstimator::outputDim numbers along with the ele index
     const auto& r = output[0].tensor<float, 2>();
     // Iterate on the list of elements in the batch --> many electrons
+    LogDebug("EgammaDNNHelper") << "Model " << m << " has " << cfg_.outputDim[m] << " nodes!";
     for (uint b = 0; b < counts[m]; b++) {
-      std::vector<float> result(cfg_.outputDim);
-      for (size_t k = 0; k < cfg_.outputDim; k++)
+      //auto outputDim=cfg_.outputDim;
+      std::vector<float> result(cfg_.outputDim[m]);
+      for (size_t k = 0; k < cfg_.outputDim[m]; k++) {
         result[k] = r(b, k);
+        LogDebug("EgammaDNNHelper") << "For Object " << b + 1 << " : Node " << k + 1 << " score = " << r(b, k);
+      }
       // Get the original index of the electorn in the original order
       const auto cand_index = indexMap[m][b];
       outputs.push_back(std::make_pair(cand_index, result));

diff --git a/RecoEgamma/ElectronIdentification/interface/ElectronDNNEstimator.h b/RecoEgamma/ElectronIdentification/interface/ElectronDNNEstimator.h
@@ -31,6 +31,8 @@ class ElectronDNNEstimator {
   static constexpr float ptThreshold = 10.;
   static constexpr float ecalBarrelMaxEtaWithGap = 1.566;
   static constexpr float ecalBarrelMaxEtaNoGap = 1.485;
+  static constexpr float endcapBoundary = 2.5;
+  static constexpr float extEtaBoundary = 2.65;
 
 private:
   const egammaTools::EgammaDNNHelper dnnHelper_;

diff --git a/RecoEgamma/ElectronIdentification/src/ElectronDNNEstimator.cc b/RecoEgamma/ElectronIdentification/src/ElectronDNNEstimator.cc
@@ -9,19 +9,28 @@
 
 using namespace std::placeholders;
 
-inline uint electronModelSelector(const std::map<std::string, float>& vars, float ptThr, float etaThr) {
+inline uint electronModelSelector(
+    const std::map<std::string, float>& vars, float ptThr, float etaThr, float endcapBoundary, float extEtaBoundary) {
   /* 
   Selection of the model to be applied on the electron based on pt/eta cuts or whatever selection
   */
   const auto pt = vars.at("pt");
   const auto absEta = std::abs(vars.at("eta"));
-  if (pt < ptThr)
-    return 0;
-  else {
-    if (absEta <= etaThr) {
-      return 1;
-    } else {
-      return 2;
+  if (absEta <= endcapBoundary) {
+    if (pt < ptThr)
+      return 0;
+    else {
+      if (absEta <= etaThr) {
+        return 1;
+      } else {
+        return 2;
+      }
+    }
+  } else {
+    if (absEta < extEtaBoundary)
+      return 3;
+    else {
+      return 4;
     }
   }
 }
@@ -32,7 +41,9 @@ ElectronDNNEstimator::ElectronDNNEstimator(const egammaTools::DNNConfiguration&
                            _1,
                            ElectronDNNEstimator::ptThreshold,
                            (useEBModelInGap) ? ElectronDNNEstimator::ecalBarrelMaxEtaWithGap
-                                             : ElectronDNNEstimator::ecalBarrelMaxEtaNoGap),
+                                             : ElectronDNNEstimator::ecalBarrelMaxEtaNoGap,
+                           ElectronDNNEstimator::endcapBoundary,
+                           ElectronDNNEstimator::extEtaBoundary),
                  ElectronDNNEstimator::dnnAvaibleInputs),
       useEBModelInGap_(useEBModelInGap) {}
 
@@ -69,6 +80,8 @@ const std::vector<std::string> ElectronDNNEstimator::dnnAvaibleInputs = {
      "full5x5_e1x5_ratio_full5x5_e5x5",
      "full5x5_r9",
      "gsfTrack.trackerLayersWithMeasurement",
+     "gsfTrack.numberOfValidPixelBarrelHits",
+     "gsfTrack.numberOfValidPixelEndcapHits",
      "superCluster.energy",
      "superCluster.rawEnergy",
      "superClusterFbrem",
@@ -119,6 +132,8 @@ std::map<std::string, float> ElectronDNNEstimator::getInputsVars(const reco::Gsf
   variables["full5x5_e1x5_ratio_full5x5_e5x5"] = ele.full5x5_e1x5() / ele.full5x5_e5x5();
   variables["full5x5_r9"] = ele.full5x5_r9();
   variables["gsfTrack.trackerLayersWithMeasurement"] = ele.gsfTrack()->hitPattern().trackerLayersWithMeasurement();
+  variables["gsfTrack.numberOfValidPixelBarrelHits"] = ele.gsfTrack()->hitPattern().numberOfValidPixelBarrelHits();
+  variables["gsfTrack.numberOfValidPixelEndcapHits"] = ele.gsfTrack()->hitPattern().numberOfValidPixelEndcapHits();
   variables["superCluster.energy"] = ele.superCluster()->energy();
   variables["superCluster.rawEnergy"] = ele.superCluster()->rawEnergy();
   variables["superClusterFbrem"] = ele.superClusterFbrem();

diff --git a/RecoParticleFlow/PFProducer/interface/PFEGammaFilters.h b/RecoParticleFlow/PFProducer/interface/PFEGammaFilters.h
@@ -32,7 +32,6 @@ class PFEGammaFilters {
 
 private:
   bool passGsfElePreSelWithOnlyConeHadem(const reco::GsfElectron &) const;
-  bool thisEleIsNotAllowedInPF(const reco::GsfElectron &, bool) const;
 
   // Photon selections
   const float ph_Et_;
@@ -47,6 +46,8 @@ class PFEGammaFilters {
   const bool useElePFidDNN_;
   const bool usePhotonPFidDNN_;
   const bool useEBModelInGap_;
+  const float endcapBoundary_;
+  const float extEtaBoundary_;
   const float ele_iso_pt_;
   const float ele_iso_mva_eb_;
   const float ele_iso_mva_ee_;
@@ -57,18 +58,21 @@ class PFEGammaFilters {
   float ele_dnnLowPtThr_;
   float ele_dnnHighPtBarrelThr_;
   float ele_dnnHighPtEndcapThr_;
+  float ele_dnnExtEta1Thr_;
+  float ele_dnnExtEta2Thr_;
   // Thresholds for DNN Bkg ele pfid
   float ele_dnnBkgLowPtThr_;
   float ele_dnnBkgHighPtBarrelThr_;
   float ele_dnnBkgHighPtEndcapThr_;
+  float ele_dnnBkgExtEta1Thr_;
+  float ele_dnnBkgExtEta2Thr_;
   // Threshold for DNN photon pfid
   float photon_dnnBarrelThr_;
   float photon_dnnEndcapThr_;
 
   const int ele_missinghits_;
   const float ele_ecalDrivenHademPreselCut_;
   const float ele_maxElePtForOnlyMVAPresel_;
-  const bool allowEEEinPF_;
   float ele_maxNtracks_;
   float ele_maxHcalE_;
   float ele_maxTrackPOverEele_;

diff --git a/RecoParticleFlow/PFProducer/python/particleFlow_cff.py b/RecoParticleFlow/PFProducer/python/particleFlow_cff.py
@@ -10,22 +10,22 @@
 
 particleFlowTmp = particleFlow.clone()
 
-## temporary for 12_1; EtaExtendedEles do not enter PF because ID/regression of EEEs are not ready yet
-## In 12_2, we expect to have EEE's ID/regression, then this switch can flip to True
-particleFlowTmp.PFEGammaFiltersParameters.allowEEEinPF = cms.bool(False)
-
 # Thresholds for e/gamma PFID DNN 
 # Thresholds for electron: Sig_isolated+Sig_nonIsolated
 particleFlowTmp.PFEGammaFiltersParameters.electronDnnThresholds = cms.PSet(
             electronDnnHighPtBarrelThr = cms.double(0.068),
             electronDnnHighPtEndcapThr = cms.double(0.056),
-            electronDnnLowPtThr = cms.double(0.075) 
+            electronDnnLowPtThr = cms.double(0.075), 
+            electronDnnExtEta1Thr = cms.double(0.113604), 
+            electronDnnExtEta2Thr = cms.double(0.118044) 
         )
 # Thresholds for electron: Bkg_nonIsolated
 particleFlowTmp.PFEGammaFiltersParameters.electronDnnBkgThresholds = cms.PSet(
             electronDnnBkgHighPtBarrelThr = cms.double(0.8),
             electronDnnBkgHighPtEndcapThr = cms.double(0.75),
-            electronDnnBkgLowPtThr = cms.double(0.75) 
+            electronDnnBkgLowPtThr = cms.double(0.75), 
+            electronDnnBkgExtEta1Thr = cms.double(0.7), 
+            electronDnnBkgExtEta2Thr = cms.double(0.85) 
         )
 # Thresholds for photons
 particleFlowTmp.PFEGammaFiltersParameters.photonDnnThresholds = cms.PSet(