Add anti-electron tauID for phase2

CommonTools/RecoAlgos/plugins/ElectronCollectionMerger.cc

@@ -0,0 +1,18 @@
+/* \class ElectronCollectionMerger
+ *
+ * Producer of merged Electron collection
+ *
+ * \author: Michal Bluj, NCBJ, Poland
+ *
+ */
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "CommonTools/UtilAlgos/interface/Merger.h"
+#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
+#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
+#include "DataFormats/PatCandidates/interface/Electron.h"
+
+typedef Merger<reco::GsfElectronCollection> GsfElectronCollectionMerger;
+DEFINE_FWK_MODULE(GsfElectronCollectionMerger);
+
+typedef Merger<pat::ElectronCollection> PATElectronCollectionMerger;
+DEFINE_FWK_MODULE(PATElectronCollectionMerger);

PhysicsTools/PatAlgos/plugins/PATTauProducer.cc

@@ -32,7 +32,8 @@ PATTauProducer::PATTauProducer(const edm::ParameterSet& iConfig)
                                                 : edm::ParameterSet(),
                 consumesCollector(),
                 false),
-      useUserData_(iConfig.exists("userData")) {
+      useUserData_(iConfig.exists("userData")),
+      posAtECalEntranceComputer_(consumesCollector()) {
   firstOccurence_ = true;
   // initialize the configurables
   baseTauToken_ = consumes<edm::View<reco::BaseTau>>(iConfig.getParameter<edm::InputTag>("tauSource"));

PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py

@@ -360,7 +360,8 @@ def miniAOD_customizeCommon(process):
         toKeep = ['deepTau2017v2p1']
     )
     from Configuration.Eras.Modifier_phase2_common_cff import phase2_common #Phase2 Tau MVA
-    phase2_common.toModify(tauIdEmbedder.toKeep, func=lambda t:t.append('newDMPhase2v1')) #Phase2 Tau MVA
+    phase2_common.toModify(tauIdEmbedder.toKeep, func=lambda t:t.append('newDMPhase2v1')) #Phase2 Tau isolation MVA
+    phase2_common.toModify(tauIdEmbedder.toKeep, func=lambda t:t.append('againstElePhase2v1')) #Phase2 Tau anti-e MVA
     tauIdEmbedder.runTauID()
     addToProcessAndTask(_noUpdatedTauName, process.slimmedTaus.clone(),process,task)
     delattr(process, 'slimmedTaus')
@@ -374,6 +375,10 @@ def miniAOD_customizeCommon(process):
         process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2raw.PATTauProducer=_noUpdatedTauName
         process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2.PATTauProducer=_noUpdatedTauName
         task.add(process.rerunIsolationMVADBnewDMwLTPhase2Task)
+    if 'againstElePhase2v1' in tauIdEmbedder.toKeep:
+        process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Raw.PATTauProducer=_noUpdatedTauName
+        process.patTauDiscriminationByElectronRejectionMVA6Phase2v1.PATTauProducer=_noUpdatedTauName
+        task.add(process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Task)
 
     #-- Rerun tauID against dead ECal towers to taus for the various re-MiniAOD eras
     # to enable default behoviour with leading track extrapolation to ECAL

RecoTauTag/Configuration/python/loadRecoTauTagMVAsFromPrepDB_cfi.py

@@ -429,7 +429,41 @@
                 label = cms.untracked.string("RecoTauTag_antiElectronMVA6%s_%s_WP%s" % (antiElectronDiscrMVA6_2017_version, gbrForestName, WP))
             )
         )
-
+
+# MVA6 phase2
+antiElectronDiscrMVA_phase2_categories = {
+     '0' : "gbr_NoEleMatch_woGwoGSF_BL",
+     '2' : "gbr_NoEleMatch_wGwoGSF_BL",
+     '5' : "gbr_woGwGSF_BL",
+     '7' : "gbr_wGwGSF_BL",
+     '8' : "gbr_NoEleMatch_woGwoGSF_FWEC",
+     '9' : "gbr_NoEleMatch_woGwoGSF_VFWEC",
+    '10' : "gbr_NoEleMatch_wGwoGSF_FWEC",
+    '11' : "gbr_NoEleMatch_wGwoGSF_VFWEC",
+    '13' : "gbr_woGwGSF_FWEC",
+    '14' : "gbr_woGwGSF_VFWEC",
+    '15' : "gbr_wGwGSF_FWEC",
+    '16' : "gbr_wGwGSF_VFWEC"
+}
+antiElectronDiscrMVA_phase2_WPs = [ "Eff98", "Eff90", "Eff80", "Eff70", "Eff60" ]
+antiElectronDiscrMVA_phase2_version = "v1"
+for category, gbrForestName in antiElectronDiscrMVA_phase2_categories.items():
+    loadRecoTauTagMVAsFromPrepDB.toGet.append(
+        cms.PSet(
+            record = cms.string('GBRWrapperRcd'),
+            tag = cms.string("RecoTauTag_antiElectronPhase2MVA6%s_%s" % (antiElectronDiscrMVA_phase2_version, gbrForestName)),
+            label = cms.untracked.string("RecoTauTag_antiElectronPhase2MVA6%s_%s" % (antiElectronDiscrMVA_phase2_version, gbrForestName))
+        )
+    )
+    for WP in antiElectronDiscrMVA_phase2_WPs:
+        loadRecoTauTagMVAsFromPrepDB.toGet.append(
+            cms.PSet(
+                record = cms.string('PhysicsTGraphPayloadRcd'),
+                tag = cms.string("RecoTauTag_antiElectronPhase2MVA6%s_%s_WP%s" % (antiElectronDiscrMVA_phase2_version, gbrForestName, WP)),
+                label = cms.untracked.string("RecoTauTag_antiElectronPhase2MVA6%s_%s_WP%s" % (antiElectronDiscrMVA_phase2_version, gbrForestName, WP))
+            )
+        )
+
 ####
 # register anti-muon discriminator MVA
 antiMuonDiscrMVA_WPs = [ "eff99_5", "eff99_0", "eff98_0" ]

RecoTauTag/RecoTau/BuildFile.xml

@@ -1,6 +1,7 @@
 <use name="MagneticField/Engine"/>
 <use name="MagneticField/Records"/>
 <use name="Geometry/CaloTopology"/>
+<use name="Geometry/CaloGeometry"/>
 <use name="CondFormats/EgammaObjects"/>
 <use name="CondFormats/DataRecord"/>
 <use name="CondFormats/EcalObjects"/>
@@ -22,6 +23,7 @@
 <use name="PhysicsTools/JetMCUtils"/>
 <use name="CommonTools/Utils"/>
 <use name="CommonTools/BaseParticlePropagator"/>
+<use name="RecoLocalCalo/HGCalRecAlgos"/>
 <use name="roottmva"/>
 <use name="PhysicsTools/TensorFlow"/>
 <export>

RecoTauTag/RecoTau/interface/AntiElectronDeadECAL.h

@@ -34,7 +34,7 @@ class IdealGeometryRecord;
 
 class AntiElectronDeadECAL {
 public:
-  explicit AntiElectronDeadECAL(const edm::ParameterSet&);
+  explicit AntiElectronDeadECAL(const edm::ParameterSet&, edm::ConsumesCollector&&);
   ~AntiElectronDeadECAL();
 
   void beginEvent(const edm::EventSetup&);

RecoTauTag/RecoTau/interface/AntiElectronIDMVA6.h

@@ -13,6 +13,7 @@
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "FWCore/ParameterSet/interface/FileInPath.h"
 
 #include "DataFormats/TauReco/interface/PFTau.h"
@@ -84,44 +85,80 @@ namespace antiElecIDMVA6_blocks {
     float mvaInSigmaEtaEta = 0;
     float mvaInHadEnergy = 0;
     float mvaInDeltaEta = 0;
+    float eSeedClusterOverPout = 0;
+    float superClusterEtaWidth = 0;
+    float superClusterPhiWidth = 0;
+    float sigmaIEtaIEta5x5 = 0;
+    float sigmaIPhiIPhi5x5 = 0;
+    float showerCircularity = 0;
+    float r9 = 0;
+    float hgcalSigmaUU = 0;
+    float hgcalSigmaVV = 0;
+    float hgcalSigmaEE = 0;
+    float hgcalSigmaPP = 0;
+    float hgcalNLayers = 0;
+    float hgcalFirstLayer = 0;
+    float hgcalLastLayer = 0;
+    float hgcalLayerEfrac10 = 0;
+    float hgcalLayerEfrac90 = 0;
+    float hgcalEcEnergyEE = 0;
+    float hgcalEcEnergyFH = 0;
+    float hgcalMeasuredDepth = 0;
+    float hgcalExpectedDepth = 0;
+    float hgcalExpectedSigma = 0;
+    float hgcalDepthCompatibility = 0;
   };
 }  // namespace antiElecIDMVA6_blocks
 
 template <class TauType, class ElectronType>
 class AntiElectronIDMVA6 {
 public:
-  AntiElectronIDMVA6(const edm::ParameterSet&);
+  typedef std::vector<ElectronType> ElectronCollection;
+  typedef edm::Ref<ElectronCollection> ElectronRef;
+
+  AntiElectronIDMVA6(const edm::ParameterSet&, edm::ConsumesCollector&&);
   ~AntiElectronIDMVA6();
 
   void beginEvent(const edm::Event&, const edm::EventSetup&);
 
-  double MVAValue(const antiElecIDMVA6_blocks::TauVars& tauVars,
+  double mvaValue(const antiElecIDMVA6_blocks::TauVars& tauVars,
                   const antiElecIDMVA6_blocks::TauGammaVecs& tauGammaVecs,
                   const antiElecIDMVA6_blocks::ElecVars& elecVars);
 
-  double MVAValue(const antiElecIDMVA6_blocks::TauVars& tauVars,
+  double mvaValue(const antiElecIDMVA6_blocks::TauVars& tauVars,
                   const antiElecIDMVA6_blocks::TauGammaMoms& tauGammaMoms,
                   const antiElecIDMVA6_blocks::ElecVars& elecVars);
 
+  double mvaValuePhase2(const antiElecIDMVA6_blocks::TauVars& tauVars,
+                        const antiElecIDMVA6_blocks::TauGammaMoms& tauGammaMoms,
+                        const antiElecIDMVA6_blocks::ElecVars& elecVars);
+
   // this function can be called for all categories
-  double MVAValue(const TauType& theTau, const ElectronType& theEle);
+  double mvaValue(const TauType& theTau, const ElectronRef& theEleRef);
   // this function can be called for category 1 only !!
-  double MVAValue(const TauType& theTau);
+  double mvaValue(const TauType& theTau);
 
   // overloaded method with explicit tau type to avoid partial imlementation of full class
   antiElecIDMVA6_blocks::TauVars getTauVarsTypeSpecific(const reco::PFTau& theTau);
   antiElecIDMVA6_blocks::TauVars getTauVarsTypeSpecific(const pat::Tau& theTau);
   antiElecIDMVA6_blocks::TauVars getTauVars(const TauType& theTau);
   antiElecIDMVA6_blocks::TauGammaVecs getTauGammaVecs(const TauType& theTau);
-  antiElecIDMVA6_blocks::ElecVars getElecVars(const ElectronType& theEle);
-
-  // track extrapolation to ECAL entrance (used to re-calculate variables that might not be available on miniAOD)
-  bool atECalEntrance(const reco::Candidate* part, math::XYZPoint& pos);
+  antiElecIDMVA6_blocks::ElecVars getElecVars(const ElectronRef& theEleRef);
+  // overloaded method with explicit electron type to avoid partial imlementation of full class
+  void getElecVarsHGCalTypeSpecific(const reco::GsfElectronRef& theEleRef, antiElecIDMVA6_blocks::ElecVars& elecVars);
+  void getElecVarsHGCalTypeSpecific(const pat::ElectronRef& theEleRef, antiElecIDMVA6_blocks::ElecVars& elecVars);
 
 private:
   double dCrackEta(double eta);
   double minimum(double a, double b);
   double dCrackPhi(double phi, double eta);
+  bool energyWeightedEtaAndPhiAtECal(
+      const pat::Tau& theTau,
+      float& eta,
+      float& phi);  // MB: needed only for pat::Tau and called within pat::Tau specific method so also pat::Tau specific
+
+  static constexpr float ecalBarrelEndcapEtaBorder_ = 1.479;
+  static constexpr float ecalEndcapVFEndcapEtaBorder_ = 2.4;
 
   bool isInitialized_;
   bool loadMVAfromDB_;
@@ -135,17 +172,25 @@ class AntiElectronIDMVA6 {
   std::string mvaName_NoEleMatch_wGwoGSF_EC_;
   std::string mvaName_woGwGSF_EC_;
   std::string mvaName_wGwGSF_EC_;
+  std::string mvaName_NoEleMatch_woGwoGSF_VFEC_;
+  std::string mvaName_NoEleMatch_wGwoGSF_VFEC_;
+  std::string mvaName_woGwGSF_VFEC_;
+  std::string mvaName_wGwGSF_VFEC_;
 
   bool usePhiAtEcalEntranceExtrapolation_;
 
-  float* Var_NoEleMatch_woGwoGSF_Barrel_;
-  float* Var_NoEleMatch_wGwoGSF_Barrel_;
-  float* Var_woGwGSF_Barrel_;
-  float* Var_wGwGSF_Barrel_;
-  float* Var_NoEleMatch_woGwoGSF_Endcap_;
-  float* Var_NoEleMatch_wGwoGSF_Endcap_;
-  float* Var_woGwGSF_Endcap_;
-  float* Var_wGwGSF_Endcap_;
+  std::vector<float> var_NoEleMatch_woGwoGSF_Barrel_;
+  std::vector<float> var_NoEleMatch_wGwoGSF_Barrel_;
+  std::vector<float> var_woGwGSF_Barrel_;
+  std::vector<float> var_wGwGSF_Barrel_;
+  std::vector<float> var_NoEleMatch_woGwoGSF_Endcap_;
+  std::vector<float> var_NoEleMatch_wGwoGSF_Endcap_;
+  std::vector<float> var_woGwGSF_Endcap_;
+  std::vector<float> var_wGwGSF_Endcap_;
+  std::vector<float> var_NoEleMatch_woGwoGSF_VFEndcap_;
+  std::vector<float> var_NoEleMatch_wGwoGSF_VFEndcap_;
+  std::vector<float> var_woGwGSF_VFEndcap_;
+  std::vector<float> var_wGwGSF_VFEndcap_;
 
   const GBRForest* mva_NoEleMatch_woGwoGSF_BL_;
   const GBRForest* mva_NoEleMatch_wGwoGSF_BL_;
@@ -155,12 +200,21 @@ class AntiElectronIDMVA6 {
   const GBRForest* mva_NoEleMatch_wGwoGSF_EC_;
   const GBRForest* mva_woGwGSF_EC_;
   const GBRForest* mva_wGwGSF_EC_;
+  const GBRForest* mva_NoEleMatch_woGwoGSF_VFEC_;
+  const GBRForest* mva_NoEleMatch_wGwoGSF_VFEC_;
+  const GBRForest* mva_woGwGSF_VFEC_;
+  const GBRForest* mva_wGwGSF_VFEC_;
 
   std::vector<TFile*> inputFilesToDelete_;
 
+  const bool isPhase2_;
+
   PositionAtECalEntranceComputer positionAtECalEntrance_;
 
-  int verbosity_;
+  std::map<std::string, edm::EDGetTokenT<edm::ValueMap<float>>> electronIds_tokens_;
+  std::map<std::string, edm::Handle<edm::ValueMap<float>>> electronIds_;
+
+  const int verbosity_;
 };
 
 #endif

RecoTauTag/RecoTau/interface/PositionAtECalEntranceComputer.h

@@ -14,11 +14,18 @@
  */
 
 #include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "DataFormats/Candidate/interface/Candidate.h"
+#include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h"
+
+class MagneticField;
+class IdealMagneticFieldRecord;
 
 class PositionAtECalEntranceComputer {
 public:
-  PositionAtECalEntranceComputer();
+  PositionAtECalEntranceComputer(edm::ConsumesCollector&&, bool isPhase2 = false);
+  PositionAtECalEntranceComputer(edm::ConsumesCollector&, bool isPhase2 = false);
   ~PositionAtECalEntranceComputer();
 
   void beginEvent(const edm::EventSetup&);
@@ -27,7 +34,14 @@ class PositionAtECalEntranceComputer {
   reco::Candidate::Point operator()(const reco::Candidate* particle, bool& success) const;
 
 private:
+  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> bField_esToken_;
+  edm::ESGetToken<CaloGeometry, CaloGeometryRecord> caloGeo_esToken_;
   double bField_z_;
+  bool isPhase2_;
+  hgcal::RecHitTools recHitTools_;
+  float hgcalFace_z_;
+  static constexpr float ecalBarrelEndcapEtaBorder_ = 1.479;
+  static constexpr float hgcalHfEtaBorder_ = 3.0;
 };
 
 #endif  // RecoTauTag_RecoTau_PositionAtECalEntranceComputer_h

RecoTauTag/RecoTau/plugins/TauDiscriminationAgainstElectronDeadECAL.cc

@@ -29,7 +29,7 @@ class TauDiscriminationAgainstElectronDeadECAL : public TauDiscriminationProduce
       : TauDiscriminationProducerBase<TauType, TauDiscriminator>::TauDiscriminationProducerBase(cfg),
         moduleLabel_(cfg.getParameter<std::string>("@module_label")),
         verbosity_(cfg.getParameter<int>("verbosity")),
-        antiElectronDeadECAL_(cfg) {}
+        antiElectronDeadECAL_(cfg, edm::EDConsumerBase::consumesCollector()) {}
   ~TauDiscriminationAgainstElectronDeadECAL() override {}
 
   void beginEvent(const edm::Event& evt, const edm::EventSetup& es) override { antiElectronDeadECAL_.beginEvent(es); }