diff --git a/CommonTools/RecoAlgos/plugins/ElectronCollectionMerger.cc b/CommonTools/RecoAlgos/plugins/ElectronCollectionMerger.cc new file mode 100644 index 0000000000000..7329b562f09a4 --- /dev/null +++ b/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 GsfElectronCollectionMerger; +DEFINE_FWK_MODULE(GsfElectronCollectionMerger); + +typedef Merger PATElectronCollectionMerger; +DEFINE_FWK_MODULE(PATElectronCollectionMerger); diff --git a/PhysicsTools/PatAlgos/plugins/PATTauProducer.cc b/PhysicsTools/PatAlgos/plugins/PATTauProducer.cc index d9d6ec1562b99..120d8815f28f9 100644 --- a/PhysicsTools/PatAlgos/plugins/PATTauProducer.cc +++ b/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>(iConfig.getParameter("tauSource")); diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py index 8571d42bfc8c4..d5d75585e7050 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py +++ b/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 diff --git a/RecoTauTag/Configuration/python/loadRecoTauTagMVAsFromPrepDB_cfi.py b/RecoTauTag/Configuration/python/loadRecoTauTagMVAsFromPrepDB_cfi.py index 2e0dee1dd6ac2..82bfdaea8e6a4 100644 --- a/RecoTauTag/Configuration/python/loadRecoTauTagMVAsFromPrepDB_cfi.py +++ b/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" ] diff --git a/RecoTauTag/RecoTau/BuildFile.xml b/RecoTauTag/RecoTau/BuildFile.xml index ee15b23a648ed..70f6ab5b5d632 100644 --- a/RecoTauTag/RecoTau/BuildFile.xml +++ b/RecoTauTag/RecoTau/BuildFile.xml @@ -1,6 +1,7 @@ + @@ -22,6 +23,7 @@ + diff --git a/RecoTauTag/RecoTau/interface/AntiElectronDeadECAL.h b/RecoTauTag/RecoTau/interface/AntiElectronDeadECAL.h index d37bb1b73b5bd..c2119537beaf9 100644 --- a/RecoTauTag/RecoTau/interface/AntiElectronDeadECAL.h +++ b/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&); diff --git a/RecoTauTag/RecoTau/interface/AntiElectronIDMVA6.h b/RecoTauTag/RecoTau/interface/AntiElectronIDMVA6.h index 16b3cf07d6382..e4d90d0a8a4a5 100644 --- a/RecoTauTag/RecoTau/interface/AntiElectronIDMVA6.h +++ b/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 AntiElectronIDMVA6 { public: - AntiElectronIDMVA6(const edm::ParameterSet&); + typedef std::vector ElectronCollection; + typedef edm::Ref 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 var_NoEleMatch_woGwoGSF_Barrel_; + std::vector var_NoEleMatch_wGwoGSF_Barrel_; + std::vector var_woGwGSF_Barrel_; + std::vector var_wGwGSF_Barrel_; + std::vector var_NoEleMatch_woGwoGSF_Endcap_; + std::vector var_NoEleMatch_wGwoGSF_Endcap_; + std::vector var_woGwGSF_Endcap_; + std::vector var_wGwGSF_Endcap_; + std::vector var_NoEleMatch_woGwoGSF_VFEndcap_; + std::vector var_NoEleMatch_wGwoGSF_VFEndcap_; + std::vector var_woGwGSF_VFEndcap_; + std::vector 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 inputFilesToDelete_; + const bool isPhase2_; + PositionAtECalEntranceComputer positionAtECalEntrance_; - int verbosity_; + std::map>> electronIds_tokens_; + std::map>> electronIds_; + + const int verbosity_; }; #endif diff --git a/RecoTauTag/RecoTau/interface/PositionAtECalEntranceComputer.h b/RecoTauTag/RecoTau/interface/PositionAtECalEntranceComputer.h index 0b167c2568549..e9af27fa03bcf 100644 --- a/RecoTauTag/RecoTau/interface/PositionAtECalEntranceComputer.h +++ b/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 bField_esToken_; + edm::ESGetToken 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 diff --git a/RecoTauTag/RecoTau/plugins/TauDiscriminationAgainstElectronDeadECAL.cc b/RecoTauTag/RecoTau/plugins/TauDiscriminationAgainstElectronDeadECAL.cc index 578a232bb1d67..637b58557934b 100644 --- a/RecoTauTag/RecoTau/plugins/TauDiscriminationAgainstElectronDeadECAL.cc +++ b/RecoTauTag/RecoTau/plugins/TauDiscriminationAgainstElectronDeadECAL.cc @@ -29,7 +29,7 @@ class TauDiscriminationAgainstElectronDeadECAL : public TauDiscriminationProduce : TauDiscriminationProducerBase::TauDiscriminationProducerBase(cfg), moduleLabel_(cfg.getParameter("@module_label")), verbosity_(cfg.getParameter("verbosity")), - antiElectronDeadECAL_(cfg) {} + antiElectronDeadECAL_(cfg, edm::EDConsumerBase::consumesCollector()) {} ~TauDiscriminationAgainstElectronDeadECAL() override {} void beginEvent(const edm::Event& evt, const edm::EventSetup& es) override { antiElectronDeadECAL_.beginEvent(es); } diff --git a/RecoTauTag/RecoTau/plugins/TauDiscriminationAgainstElectronMVA6.cc b/RecoTauTag/RecoTau/plugins/TauDiscriminationAgainstElectronMVA6.cc index b5583fd036b3e..e323a5dbe0355 100644 --- a/RecoTauTag/RecoTau/plugins/TauDiscriminationAgainstElectronMVA6.cc +++ b/RecoTauTag/RecoTau/plugins/TauDiscriminationAgainstElectronMVA6.cc @@ -27,11 +27,17 @@ class TauDiscriminationAgainstElectronMVA6 : public TauDiscriminationProducerBas reco::SingleTauDiscriminatorContainer, TauDiscriminator>::TauDiscriminationProducerBase(cfg), moduleLabel_(cfg.getParameter("@module_label")), - mva_(std::make_unique >(cfg)), + mva_( + std::make_unique>(cfg, edm::EDConsumerBase::consumesCollector())), Electron_token(edm::EDConsumerBase::consumes( - cfg.getParameter("srcElectrons"))), //MB: full specification with prefix mandatory + cfg.getParameter("srcElectrons"))), // MB: full specification with prefix mandatory + positionAtECalEntrance_(PositionAtECalEntranceComputer(edm::EDConsumerBase::consumesCollector(), + cfg.getParameter("isPhase2"))), vetoEcalCracks_(cfg.getParameter("vetoEcalCracks")), - verbosity_(cfg.getParameter("verbosity")) {} + isPhase2_(cfg.getParameter("isPhase2")), + verbosity_(cfg.getParameter("verbosity")) { + deltaREleTauMax_ = (isPhase2_ ? 0.2 : 0.3); + } void beginEvent(const edm::Event& evt, const edm::EventSetup& es) override { mva_->beginEvent(evt, es); @@ -55,7 +61,7 @@ class TauDiscriminationAgainstElectronMVA6 : public TauDiscriminationProducerBas std::pair getTauEtaAtECalEntrance(const pat::TauRef& theTauRef) const; std::string moduleLabel_; - std::unique_ptr > mva_; + std::unique_ptr> mva_; edm::EDGetTokenT Electron_token; edm::Handle electrons_; @@ -63,8 +69,14 @@ class TauDiscriminationAgainstElectronMVA6 : public TauDiscriminationProducerBas PositionAtECalEntranceComputer positionAtECalEntrance_; + static constexpr float ecalBarrelEndcapEtaBorder_ = 1.479; + static constexpr float ecalEndcapVFEndcapEtaBorder_ = 2.4; + bool vetoEcalCracks_; + bool isPhase2_; + float deltaREleTauMax_; + int verbosity_; }; @@ -77,9 +89,7 @@ TauDiscriminationAgainstElectronMVA6::d double category = -1.; bool isGsfElectronMatched = false; - float deltaRDummy = 9.9; - - const float ECalBarrelEndcapEtaBorder = 1.479; + double deltaRDummy = 9.9; std::pair tauEtaAtECalEntrance; if (std::is_same::value || std::is_same::value) @@ -102,22 +112,31 @@ TauDiscriminationAgainstElectronMVA6::d bool hasGsfTrack = false; const reco::CandidatePtr& leadChCand = theTauRef->leadChargedHadrCand(); if (leadChCand.isNonnull()) { - const pat::PackedCandidate* packedLeadChCand = dynamic_cast(leadChCand.get()); - if (packedLeadChCand != nullptr) { - hasGsfTrack = (std::abs(packedLeadChCand->pdgId()) == 11); + if (isPhase2_) { + //MB: for phase-2 has gsf-track reads lead charged cand is pf-electron + hasGsfTrack = (std::abs(leadChCand->pdgId()) == 11); } else { - const reco::PFCandidate* pfLeadChCand = dynamic_cast(leadChCand.get()); - hasGsfTrack = (pfLeadChCand != nullptr && pfLeadChCand->gsfTrackRef().isNonnull()); + const pat::PackedCandidate* packedLeadChCand = dynamic_cast(leadChCand.get()); + if (packedLeadChCand != nullptr) { + hasGsfTrack = (std::abs(packedLeadChCand->pdgId()) == 11); + } else { + const reco::PFCandidate* pfLeadChCand = dynamic_cast(leadChCand.get()); + //pfLeadChCand can not be a nullptr here as it would be imply taus not built either with PFCandidates or PackedCandidates + hasGsfTrack = pfLeadChCand->gsfTrackRef().isNonnull(); + } } } // loop over the electrons + size_t iElec = 0; for (const auto& theElectron : *electrons_) { + edm::Ref theElecRef(electrons_, iElec); + iElec++; if (theElectron.pt() > 10.) { // CV: only take electrons above some minimal energy/Pt into account... double deltaREleTau = deltaR(theElectron.p4(), theTauRef->p4()); - deltaRDummy = deltaREleTau; - if (deltaREleTau < 0.3) { - double mva_match = mva_->MVAValue(*theTauRef, theElectron); + deltaRDummy = std::min(deltaREleTau, deltaRDummy); + if (deltaREleTau < deltaREleTauMax_) { + double mva_match = mva_->mvaValue(*theTauRef, theElecRef); if (!hasGsfTrack) hasGsfTrack = theElectron.gsfTrack().isNonnull(); @@ -132,28 +151,34 @@ TauDiscriminationAgainstElectronMVA6::d } // veto taus that go to ECal crack - if (std::abs(tauEtaAtECalEntrance.first) < ECalBarrelEndcapEtaBorder) { // Barrel + if (std::abs(tauEtaAtECalEntrance.first) < ecalBarrelEndcapEtaBorder_) { // Barrel if (numSignalGammaCandsInSigCone == 0 && hasGsfTrack) { category = 5.; } else if (numSignalGammaCandsInSigCone >= 1 && hasGsfTrack) { category = 7.; } - } else { // Endcap + } else if (!isPhase2_ || std::abs(tauEtaAtECalEntrance.first) < ecalEndcapVFEndcapEtaBorder_) { // Endcap if (numSignalGammaCandsInSigCone == 0 && hasGsfTrack) { category = 13.; } else if (numSignalGammaCandsInSigCone >= 1 && hasGsfTrack) { category = 15.; } + } else { // VeryForwardEndcap + if (numSignalGammaCandsInSigCone == 0 && hasGsfTrack) { + category = 14.; + } else if (numSignalGammaCandsInSigCone >= 1 && hasGsfTrack) { + category = 16.; + } } result.rawValues.at(0) = std::min(result.rawValues.at(0), float(mva_match)); isGsfElectronMatched = true; - } // deltaR < 0.3 + } // deltaR < deltaREleTauMax_ } // electron pt > 10 } // end of loop over electrons if (!isGsfElectronMatched) { - double mva_nomatch = mva_->MVAValue(*theTauRef); + double mva_nomatch = mva_->mvaValue(*theTauRef); // veto taus that go to ECal crack if (vetoEcalCracks_ && @@ -166,18 +191,24 @@ TauDiscriminationAgainstElectronMVA6::d } // veto taus that go to ECal crack - if (std::abs(tauEtaAtECalEntrance.first) < ECalBarrelEndcapEtaBorder) { // Barrel + if (std::abs(tauEtaAtECalEntrance.first) < ecalBarrelEndcapEtaBorder_) { // Barrel if (numSignalGammaCandsInSigCone == 0 && !hasGsfTrack) { category = 0.; } else if (numSignalGammaCandsInSigCone >= 1 && !hasGsfTrack) { category = 2.; } - } else { // Endcap + } else if (!isPhase2_ || std::abs(tauEtaAtECalEntrance.first) < ecalEndcapVFEndcapEtaBorder_) { // Endcap if (numSignalGammaCandsInSigCone == 0 && !hasGsfTrack) { category = 8.; } else if (numSignalGammaCandsInSigCone >= 1 && !hasGsfTrack) { category = 10.; } + } else { // VeryForwardEndcap + if (numSignalGammaCandsInSigCone == 0 && !hasGsfTrack) { + category = 9.; + } else if (numSignalGammaCandsInSigCone >= 1 && !hasGsfTrack) { + category = 11.; + } } result.rawValues.at(0) = std::min(result.rawValues.at(0), float(mva_nomatch)); @@ -224,7 +255,15 @@ TauDiscriminationAgainstElectronMVA6::g const reco::Track* track = nullptr; const reco::PFCandidate* pfCandidate = dynamic_cast(candidate.get()); if (pfCandidate != nullptr) { - etaAtECalEntrance = pfCandidate->positionAtECALEntrance().eta(); + if (!isPhase2_ || std::abs(theTauRef->eta()) < ecalBarrelEndcapEtaBorder_) { // ECal + etaAtECalEntrance = pfCandidate->positionAtECALEntrance().eta(); + } else { // HGCal + bool success = false; + reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success); + if (success) { + etaAtECalEntrance = posAtECal.eta(); + } + } if (pfCandidate->trackRef().isNonnull()) track = pfCandidate->trackRef().get(); else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->innerTrack().isNonnull()) @@ -262,7 +301,37 @@ template std::pair TauDiscriminationAgainstElectronMVA6::getTauEtaAtECalEntrance( const pat::TauRef& theTauRef) const { - return std::pair(theTauRef->etaAtEcalEntrance(), theTauRef->etaAtEcalEntranceLeadChargedCand()); + if (!isPhase2_ || std::abs(theTauRef->eta()) < ecalBarrelEndcapEtaBorder_) { // ECal + return std::pair(theTauRef->etaAtEcalEntrance(), theTauRef->etaAtEcalEntranceLeadChargedCand()); + } else { // HGCal + float tauEtaAtECalEntrance = -99; + float leadChargedCandEtaAtECalEntrance = -99; + float sumEtaTimesEnergy = 0.; + float sumEnergy = 0.; + float leadChargedCandPt = -99; + + for (const auto& candidate : theTauRef->signalCands()) { + float etaAtECalEntrance = candidate->eta(); + bool success = false; + reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success); + if (success) { + etaAtECalEntrance = posAtECal.eta(); + } + const reco::Track* track = candidate->bestTrack(); + if (track != nullptr) { + if (track->pt() > leadChargedCandPt) { + leadChargedCandEtaAtECalEntrance = etaAtECalEntrance; + leadChargedCandPt = track->pt(); + } + } + sumEtaTimesEnergy += etaAtECalEntrance * candidate->energy(); + sumEnergy += candidate->energy(); + } + if (sumEnergy > 0.) { + tauEtaAtECalEntrance = sumEtaTimesEnergy / sumEnergy; + } + return std::pair(tauEtaAtECalEntrance, leadChargedCandEtaAtECalEntrance); + } } template @@ -292,7 +361,29 @@ void TauDiscriminationAgainstElectronMVA6("minMVANoEleMatchWgWOgsfEC", 0.0); desc.add("minMVAWOgWgsfEC", 0.0); desc.add("minMVAWgWgsfEC", 0.0); - desc.add("srcElectrons", edm::InputTag("fixme")); + + desc.ifValue( + edm::ParameterDescription("isPhase2", false, true), + // MB: "srcElectrons" present for both phase-2 and non-phase2 to have a non-empy case for default, i.e. isPhase2=false + false >> (edm::ParameterDescription("srcElectrons", edm::InputTag("fixme"), true)) or + // The following used only for Phase2 + true >> (edm::ParameterDescription("srcElectrons", edm::InputTag("fixme"), true) and + edm::ParameterDescription("mvaName_wGwGSF_VFEC", "gbr_wGwGSF_VFEC", true) and + edm::ParameterDescription("mvaName_woGwGSF_VFEC", "gbr_woGwGSF_VFEC", true) and + edm::ParameterDescription( + "mvaName_NoEleMatch_wGwoGSF_VFEC", "gbr_NoEleMatch_wGwoGSF_VFEC", true) and + edm::ParameterDescription( + "mvaName_NoEleMatch_woGwoGSF_VFEC", "gbr_NoEleMatch_woGwoGSF_VFEC", true) and + edm::ParameterDescription("minMVAWOgWgsfVFEC", 0.0, true) and + edm::ParameterDescription("minMVAWgWgsfVFEC", 0.0, true) and + edm::ParameterDescription("minMVANoEleMatchWgWOgsfVFEC", 0.0, true) and + edm::ParameterDescription("minMVANoEleMatchWOgWOgsfVFEC", 0.0, true))); + + // Relevant only for gsfElectrons for Phase2 + if (std::is_same::value) { + desc.add>("hgcalElectronIDs", std::vector()) + ->setComment("Relevant only for Phase-2"); + } desc.add("vetoEcalCracks", true); desc.add("usePhiAtEcalEntranceExtrapolation", false); desc.add("verbosity", 0); diff --git a/RecoTauTag/RecoTau/python/PATTauDiscriminationAgainstElectronMVA6Phase2_cff.py b/RecoTauTag/RecoTau/python/PATTauDiscriminationAgainstElectronMVA6Phase2_cff.py new file mode 100644 index 0000000000000..7565461c686c4 --- /dev/null +++ b/RecoTauTag/RecoTau/python/PATTauDiscriminationAgainstElectronMVA6Phase2_cff.py @@ -0,0 +1,37 @@ +import FWCore.ParameterSet.Config as cms + +# Electron collection merger +mergedSlimmedElectronsForTauId = cms.EDProducer('PATElectronCollectionMerger', + src = cms.VInputTag('slimmedElectrons', 'slimmedElectronsFromMultiCl') +) +# anti-e phase-2 tauID (Raw) +from RecoTauTag.RecoTau.tauDiscriminationAgainstElectronMVA6Phase2_mvaDefs_cff import mvaNames_phase2, mapping_phase2, workingPoints_phase2 +from RecoTauTag.RecoTau.TauDiscriminatorTools import noPrediscriminants +from RecoTauTag.RecoTau.patTauDiscriminationAgainstElectronMVA6_cfi import * +patTauDiscriminationAgainstElectronMVA6Phase2Raw = patTauDiscriminationAgainstElectronMVA6.clone( + #Note: PATTauProducer has to be set in the final cfg + Prediscriminants = noPrediscriminants, + srcElectrons = "mergedSlimmedElectronsForTauId", + isPhase2 = True, + vetoEcalCracks = False, + **mvaNames_phase2 +) +# anti-e phase-2 tauID (WPs) +from RecoTauTag.RecoTau.patTauDiscriminantCutMultiplexerDefault_cfi import patTauDiscriminantCutMultiplexerDefault +patTauDiscriminationAgainstElectronMVA6Phase2 = patTauDiscriminantCutMultiplexerDefault.clone( + #Note: PFTauProducer and Prediscriminants have to be set in the final cfg + toMultiplex = 'patTauDiscriminationAgainstElectronMVA6Phase2Raw', + mapping = mapping_phase2, + rawValues = ["discriminator", "category"], + workingPoints = workingPoints_phase2 +) + +patTauDiscriminationAgainstElectronMVA6Phase2Task = cms.Task( + mergedSlimmedElectronsForTauId, + patTauDiscriminationAgainstElectronMVA6Phase2Raw, + patTauDiscriminationAgainstElectronMVA6Phase2 +) + +patTauDiscriminationAgainstElectronMVA6Phase2Seq = cms.Sequence( + patTauDiscriminationAgainstElectronMVA6Phase2Task +) diff --git a/RecoTauTag/RecoTau/python/PFRecoTauDiscriminationAgainstElectronMVA6Phase2_cff.py b/RecoTauTag/RecoTau/python/PFRecoTauDiscriminationAgainstElectronMVA6Phase2_cff.py new file mode 100644 index 0000000000000..2f3db755b3eb7 --- /dev/null +++ b/RecoTauTag/RecoTau/python/PFRecoTauDiscriminationAgainstElectronMVA6Phase2_cff.py @@ -0,0 +1,57 @@ +import FWCore.ParameterSet.Config as cms + +# HGCal electron stuff +from RecoEgamma.EgammaTools.cleanedEcalDrivenGsfElectronsFromMultiCl_cfi import cleanedEcalDrivenGsfElectronsFromMultiCl +from RecoEgamma.EgammaTools.hgcalElectronIDValueMap_cff import hgcalElectronIDValueMap +# HGCal electrons cleaned against duplicates and electrons in barrel (pt>10GeV) +# TauValElectronSelector defined Validation/RecoTau/plugins/Selectors.cc; +# is there a more intuitive place where such a selector is defined? +cleanedEcalDrivenGsfElectronsFromMultiClNoEB = cms.EDFilter('TauValElectronSelector', + cut = cms.string('!isEB && pt >= 10.'), + src = cms.InputTag('cleanedEcalDrivenGsfElectronsFromMultiCl') +) +# Electron collection merger +mergedGsfElectronsForTauId = cms.EDProducer('GsfElectronCollectionMerger', + src = cms.VInputTag('gedGsfElectrons', 'cleanedEcalDrivenGsfElectronsFromMultiClNoEB') +) +# HGCal EleID with merged electron collection +hgcElectronIdForTauId = hgcalElectronIDValueMap.clone( + electrons = "mergedGsfElectronsForTauId" +) +# anti-e phase-2 tauID (raw) +from RecoTauTag.RecoTau.tauDiscriminationAgainstElectronMVA6Phase2_mvaDefs_cff import mvaNames_phase2, mapping_phase2, workingPoints_phase2 +from RecoTauTag.RecoTau.pfRecoTauDiscriminationAgainstElectronMVA6_cfi import * +pfRecoTauDiscriminationAgainstElectronMVA6Phase2Raw = pfRecoTauDiscriminationAgainstElectronMVA6.clone( + #Note: PFTauProducer and Prediscriminants have to be set in the final cfg + srcElectrons = "mergedGsfElectronsForTauId", + isPhase2 = True, + vetoEcalCracks = False, + hgcalElectronIDs = [cms.InputTag("hgcElectronIdForTauId", key) for key in hgcElectronIdForTauId.variables], + **mvaNames_phase2 +) +# anti-e phase-2 tauID (WPs) +from RecoTauTag.RecoTau.recoTauDiscriminantCutMultiplexerDefault_cfi import recoTauDiscriminantCutMultiplexerDefault +pfRecoTauDiscriminationAgainstElectronMVA6Phase2 = recoTauDiscriminantCutMultiplexerDefault.clone( + #Note: PFTauProducer and Prediscriminants have to be set in the final cfg + toMultiplex = "pfRecoTauDiscriminationAgainstElectronMVA6Phase2Raw", + mapping = mapping_phase2, + rawValues = ["discriminator", "category"], + workingPoints = workingPoints_phase2 +) + +electronsForTauDiscriminationAgainstElectronMVA6Phase2Task = cms.Task( + cleanedEcalDrivenGsfElectronsFromMultiCl, + cleanedEcalDrivenGsfElectronsFromMultiClNoEB, + mergedGsfElectronsForTauId, + hgcElectronIdForTauId +) + +pfRecoTauDiscriminationAgainstElectronMVA6Phase2Task = cms.Task( + electronsForTauDiscriminationAgainstElectronMVA6Phase2Task, + pfRecoTauDiscriminationAgainstElectronMVA6Phase2Raw, + pfRecoTauDiscriminationAgainstElectronMVA6Phase2 +) + +pfRecoTauDiscriminationAgainstElectronMVA6Phase2Seq = cms.Sequence( + pfRecoTauDiscriminationAgainstElectronMVA6Phase2Task +) diff --git a/RecoTauTag/RecoTau/python/tauDiscriminationAgainstElectronMVA6Phase2_mvaDefs_cff.py b/RecoTauTag/RecoTau/python/tauDiscriminationAgainstElectronMVA6Phase2_mvaDefs_cff.py new file mode 100644 index 0000000000000..09927d3866bcf --- /dev/null +++ b/RecoTauTag/RecoTau/python/tauDiscriminationAgainstElectronMVA6Phase2_mvaDefs_cff.py @@ -0,0 +1,88 @@ +import FWCore.ParameterSet.Config as cms + +# anti-e phase-2 tauID mva names +mvaNames_phase2 = dict( + mvaName_NoEleMatch_woGwoGSF_BL = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_woGwoGSF_BL"), + mvaName_NoEleMatch_wGwoGSF_BL = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_wGwoGSF_BL"), + mvaName_woGwGSF_BL = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_woGwGSF_BL"), + mvaName_wGwGSF_BL = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_wGwGSF_BL"), + mvaName_NoEleMatch_woGwoGSF_EC = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_woGwoGSF_FWEC"), + mvaName_NoEleMatch_wGwoGSF_EC = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_wGwoGSF_FWEC"), + mvaName_woGwGSF_EC = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_woGwGSF_FWEC"), + mvaName_wGwGSF_EC = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_wGwGSF_FWEC"), + mvaName_NoEleMatch_woGwoGSF_VFEC = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_woGwoGSF_VFWEC"), + mvaName_NoEleMatch_wGwoGSF_VFEC = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_wGwoGSF_VFWEC"), + mvaName_woGwGSF_VFEC = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_woGwGSF_VFWEC"), + mvaName_wGwGSF_VFEC = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_wGwGSF_VFWEC") +) +# anti-e phase-2 tauID (WPs) +mapping_phase2 = cms.VPSet( + cms.PSet( + category = cms.uint32(0), # minMVANoEleMatchWOgWOgsfBL + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_woGwoGSF_BL"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(2), # minMVANoEleMatchWgWOgsfBL + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_wGwoGSF_BL"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(5), # minMVAWOgWgsfBL + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_woGwGSF_BL"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(7), # minMVAWgWgsfBL + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_wGwGSF_BL"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(8), # minMVANoEleMatchWOgWOgsfEC + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_woGwoGSF_FWEC"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(9), # minMVANoEleMatchWOgWOgsfVFEC + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_woGwoGSF_VFWEC"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(10), # minMVANoEleMatchWgWOgsfEC + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_wGwoGSF_FWEC"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(11), # minMVANoEleMatchWgWOgsfVFEC + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_NoEleMatch_wGwoGSF_VFWEC"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(13), # minMVAWOgWgsfEC + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_woGwGSF_FWEC"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(14), # minMVAWOgWgsfVFEC + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_woGwGSF_VFWEC"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(15), # minMVAWgWgsfEC + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_wGwGSF_FWEC"), + variable = cms.string("pt") + ), + cms.PSet( + category = cms.uint32(16), # minMVAWgWgsfVFEC + cut = cms.string("RecoTauTag_antiElectronPhase2MVA6v1_gbr_wGwGSF_VFWEC"), + variable = cms.string("pt") + ) +) + +workingPoints_phase2 = cms.vstring( + "_WPEff98", + "_WPEff90", + "_WPEff80", + "_WPEff70", + "_WPEff60" +) diff --git a/RecoTauTag/RecoTau/python/tools/runTauIdMVA.py b/RecoTauTag/RecoTau/python/tools/runTauIdMVA.py index 8cea4ad6b132f..7167a9eab12e4 100644 --- a/RecoTauTag/RecoTau/python/tools/runTauIdMVA.py +++ b/RecoTauTag/RecoTau/python/tools/runTauIdMVA.py @@ -13,7 +13,8 @@ class TauIDEmbedder(object): "deepTau2017v1", "deepTau2017v2", "deepTau2017v2p1", "DPFTau_2016_v0", "DPFTau_2016_v1", "againstEle2018", - "newDMPhase2v1" + "newDMPhase2v1", + "againstElePhase2v1" ] def __init__(self, process, debug = False, @@ -917,6 +918,47 @@ def tauIDMVAinputs(module, wp): tauIDSources.byTightIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs("rerunDiscriminationByIsolationMVADBnewDMwLTPhase2", "_WPEff60") tauIDSources.byVTightIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs("rerunDiscriminationByIsolationMVADBnewDMwLTPhase2", "_WPEff50") tauIDSources.byVVTightIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs("rerunDiscriminationByIsolationMVADBnewDMwLTPhase2", "_WPEff40") + + if "againstElePhase2v1" in self.toKeep: + if self.debug: print ("Adding anti-e Phase2v1 ID") + ### Define new anti-e discriminants for Phase2 + ## Raw + from RecoTauTag.RecoTau.PATTauDiscriminationAgainstElectronMVA6Phase2_cff import patTauDiscriminationAgainstElectronMVA6Phase2Raw, patTauDiscriminationAgainstElectronMVA6Phase2, mergedSlimmedElectronsForTauId + self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Raw = patTauDiscriminationAgainstElectronMVA6Phase2Raw.clone( + PATTauProducer = 'slimmedTaus', + Prediscriminants = noPrediscriminants #already selected for MiniAOD + ) + ## WPs + self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1 = patTauDiscriminationAgainstElectronMVA6Phase2.clone( + PATTauProducer = self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Raw.PATTauProducer, + Prediscriminants = self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Raw.Prediscriminants, + toMultiplex = 'patTauDiscriminationByElectronRejectionMVA6Phase2v1Raw' + ) + ### Put all new phase2 anti-e discrminats to a sequence + self.process.mergedSlimmedElectronsForTauId = mergedSlimmedElectronsForTauId + self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Task = cms.Task( + self.process.mergedSlimmedElectronsForTauId, + self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Raw, + self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1 + ) + self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Seq = cms.Sequence(self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Task) + self.process.rerunMvaIsolationTask.add(self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Task) + self.process.rerunMvaIsolationSequence += self.process.patTauDiscriminationByElectronRejectionMVA6Phase2v1Seq + + _againstElectronTauIDPhase2v1Sources = cms.PSet( + againstElectronMVA6RawPhase2v1 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA6Phase2v1", "raw"), + againstElectronMVA6categoryPhase2v1 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA6Phase2v1", "category"), + againstElectronVLooseMVA6Phase2v1 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA6Phase2v1", "_WPEff98"), + againstElectronLooseMVA6Phase2v1 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA6Phase2v1", "_WPEff90"), + againstElectronMediumMVA6Phase2v1 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA6Phase2v1", "_WPEff80"), + againstElectronTightMVA6Phase2v1 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA6Phase2v1", "_WPEff70"), + againstElectronVTightMVA6Phase2v1 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA6Phase2v1", "_WPEff60") + ) + _tauIDSourcesWithAgainistElePhase2v1 = cms.PSet( + tauIDSources.clone(), + _againstElectronTauIDPhase2v1Sources + ) + tauIDSources =_tauIDSourcesWithAgainistElePhase2v1.clone() ## if self.debug: print('Embedding new TauIDs into \"'+self.updatedTauName+'\"') if not hasattr(self.process, self.updatedTauName): diff --git a/RecoTauTag/RecoTau/src/AntiElectronDeadECAL.cc b/RecoTauTag/RecoTau/src/AntiElectronDeadECAL.cc index 080c333fcf01b..782e4e2b87c34 100644 --- a/RecoTauTag/RecoTau/src/AntiElectronDeadECAL.cc +++ b/RecoTauTag/RecoTau/src/AntiElectronDeadECAL.cc @@ -15,11 +15,12 @@ #include "DataFormats/Math/interface/deltaR.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" -AntiElectronDeadECAL::AntiElectronDeadECAL(const edm::ParameterSet& cfg) +AntiElectronDeadECAL::AntiElectronDeadECAL(const edm::ParameterSet& cfg, edm::ConsumesCollector&& cc) : minStatus_(cfg.getParameter("minStatus")), dR2_(std::pow(cfg.getParameter("dR"), 2)), extrapolateToECalEntrance_(cfg.getParameter("extrapolateToECalEntrance")), verbosity_(cfg.getParameter("verbosity")), + positionAtECalEntrance_(PositionAtECalEntranceComputer(cc)), isFirstEvent_(true) {} AntiElectronDeadECAL::~AntiElectronDeadECAL() {} diff --git a/RecoTauTag/RecoTau/src/AntiElectronIDMVA6.cc b/RecoTauTag/RecoTau/src/AntiElectronIDMVA6.cc index 6aeeaadea68d9..6275bc6296eaf 100644 --- a/RecoTauTag/RecoTau/src/AntiElectronIDMVA6.cc +++ b/RecoTauTag/RecoTau/src/AntiElectronIDMVA6.cc @@ -16,8 +16,25 @@ using namespace antiElecIDMVA6_blocks; +namespace { + const reco::Track* getTrackFromPFCand(const reco::PFCandidate* pfCandidate) { + const reco::Track* track = nullptr; + if (pfCandidate->trackRef().isNonnull()) + track = pfCandidate->trackRef().get(); + else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->innerTrack().isNonnull()) + track = pfCandidate->muonRef()->innerTrack().get(); + else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->globalTrack().isNonnull()) + track = pfCandidate->muonRef()->globalTrack().get(); + else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->outerTrack().isNonnull()) + track = pfCandidate->muonRef()->outerTrack().get(); + else if (pfCandidate->gsfTrackRef().isNonnull()) + track = pfCandidate->gsfTrackRef().get(); + return track; + } +} // namespace + template -AntiElectronIDMVA6::AntiElectronIDMVA6(const edm::ParameterSet& cfg) +AntiElectronIDMVA6::AntiElectronIDMVA6(const edm::ParameterSet& cfg, edm::ConsumesCollector&& cc) : isInitialized_(false), mva_NoEleMatch_woGwoGSF_BL_(nullptr), mva_NoEleMatch_wGwoGSF_BL_(nullptr), @@ -26,7 +43,14 @@ AntiElectronIDMVA6::AntiElectronIDMVA6(const edm::Paramet mva_NoEleMatch_woGwoGSF_EC_(nullptr), mva_NoEleMatch_wGwoGSF_EC_(nullptr), mva_woGwGSF_EC_(nullptr), - mva_wGwGSF_EC_(nullptr) { + mva_wGwGSF_EC_(nullptr), + mva_NoEleMatch_woGwoGSF_VFEC_(nullptr), + mva_NoEleMatch_wGwoGSF_VFEC_(nullptr), + mva_woGwGSF_VFEC_(nullptr), + mva_wGwGSF_VFEC_(nullptr), + isPhase2_(cfg.getParameter("isPhase2")), + positionAtECalEntrance_(PositionAtECalEntranceComputer(cc, isPhase2_)), + verbosity_(cfg.getParameter("verbosity")) { loadMVAfromDB_ = cfg.exists("loadMVAfromDB") ? cfg.getParameter("loadMVAfromDB") : false; if (!loadMVAfromDB_) { if (cfg.exists("inputFileName")) { @@ -44,32 +68,51 @@ AntiElectronIDMVA6::AntiElectronIDMVA6(const edm::Paramet mvaName_NoEleMatch_wGwoGSF_EC_ = cfg.getParameter("mvaName_NoEleMatch_wGwoGSF_EC"); mvaName_woGwGSF_EC_ = cfg.getParameter("mvaName_woGwGSF_EC"); mvaName_wGwGSF_EC_ = cfg.getParameter("mvaName_wGwGSF_EC"); - + if (isPhase2_) { + mvaName_NoEleMatch_woGwoGSF_VFEC_ = cfg.getParameter("mvaName_NoEleMatch_woGwoGSF_VFEC"); + mvaName_NoEleMatch_wGwoGSF_VFEC_ = cfg.getParameter("mvaName_NoEleMatch_wGwoGSF_VFEC"); + mvaName_woGwGSF_VFEC_ = cfg.getParameter("mvaName_woGwGSF_VFEC"); + mvaName_wGwGSF_VFEC_ = cfg.getParameter("mvaName_wGwGSF_VFEC"); + } usePhiAtEcalEntranceExtrapolation_ = cfg.getParameter("usePhiAtEcalEntranceExtrapolation"); - Var_NoEleMatch_woGwoGSF_Barrel_ = new float[10]; - Var_NoEleMatch_wGwoGSF_Barrel_ = new float[18]; - Var_woGwGSF_Barrel_ = new float[24]; - Var_wGwGSF_Barrel_ = new float[32]; - Var_NoEleMatch_woGwoGSF_Endcap_ = new float[9]; - Var_NoEleMatch_wGwoGSF_Endcap_ = new float[17]; - Var_woGwGSF_Endcap_ = new float[23]; - Var_wGwGSF_Endcap_ = new float[31]; - - verbosity_ = 0; + if (!isPhase2_) { + var_NoEleMatch_woGwoGSF_Barrel_ = std::vector(10); + var_NoEleMatch_wGwoGSF_Barrel_ = std::vector(18); + var_woGwGSF_Barrel_ = std::vector(24); + var_wGwGSF_Barrel_ = std::vector(32); + var_NoEleMatch_woGwoGSF_Endcap_ = std::vector(9); + var_NoEleMatch_wGwoGSF_Endcap_ = std::vector(17); + var_woGwGSF_Endcap_ = std::vector(23); + var_wGwGSF_Endcap_ = std::vector(31); + } else { + var_NoEleMatch_woGwoGSF_Barrel_ = std::vector(9); + var_NoEleMatch_wGwoGSF_Barrel_ = std::vector(17); + var_woGwGSF_Barrel_ = std::vector(27); + var_wGwGSF_Barrel_ = std::vector(36); + var_NoEleMatch_woGwoGSF_Endcap_ = std::vector(6); + var_NoEleMatch_wGwoGSF_Endcap_ = std::vector(14); + var_woGwGSF_Endcap_ = std::vector(31); + var_wGwGSF_Endcap_ = std::vector(38); + var_NoEleMatch_woGwoGSF_VFEndcap_ = std::vector(6); + var_NoEleMatch_wGwoGSF_VFEndcap_ = std::vector(14); + var_woGwGSF_VFEndcap_ = std::vector(32); + var_wGwGSF_VFEndcap_ = std::vector(40); + + //MB: Tokens for additional inputs (HGCal EleID variables) only for Phase2 and reco::GsfElectrons + if (std::is_same::value) { + for (const auto& inputTag : cfg.getParameter>("hgcalElectronIDs")) { + std::string elecIdLabel = "hgcElectronID:" + inputTag.instance(); + electronIds_tokens_[elecIdLabel] = cc.consumes>( + inputTag); //MB: It assumes that instances are not empty and meaningful (as for userData in patElectrons) + electronIds_[elecIdLabel] = edm::Handle>(); + } + } + } } template AntiElectronIDMVA6::~AntiElectronIDMVA6() { - delete[] Var_NoEleMatch_woGwoGSF_Barrel_; - delete[] Var_NoEleMatch_wGwoGSF_Barrel_; - delete[] Var_woGwGSF_Barrel_; - delete[] Var_wGwGSF_Barrel_; - delete[] Var_NoEleMatch_woGwoGSF_Endcap_; - delete[] Var_NoEleMatch_wGwoGSF_Endcap_; - delete[] Var_woGwGSF_Endcap_; - delete[] Var_wGwGSF_Endcap_; - if (!loadMVAfromDB_) { delete mva_NoEleMatch_woGwoGSF_BL_; delete mva_NoEleMatch_wGwoGSF_BL_; @@ -79,6 +122,12 @@ AntiElectronIDMVA6::~AntiElectronIDMVA6() { delete mva_NoEleMatch_wGwoGSF_EC_; delete mva_woGwGSF_EC_; delete mva_wGwGSF_EC_; + if (isPhase2_) { + delete mva_NoEleMatch_woGwoGSF_VFEC_; + delete mva_NoEleMatch_wGwoGSF_VFEC_; + delete mva_woGwGSF_VFEC_; + delete mva_wGwGSF_VFEC_; + } } for (std::vector::iterator it = inputFilesToDelete_.begin(); it != inputFilesToDelete_.end(); ++it) { @@ -89,7 +138,7 @@ AntiElectronIDMVA6::~AntiElectronIDMVA6() { namespace { const GBRForest* loadMVAfromFile(TFile* inputFile, const std::string& mvaName) { const GBRForest* mva = (GBRForest*)inputFile->Get(mvaName.data()); - if (!mva) + if (mva == nullptr) throw cms::Exception("PFRecoTauDiscriminationAgainstElectronMVA6::loadMVA") << " Failed to load MVA = " << mvaName.data() << " from file " << " !!\n"; @@ -116,6 +165,12 @@ void AntiElectronIDMVA6::beginEvent(const edm::Event& evt mva_NoEleMatch_wGwoGSF_EC_ = loadMVAfromDB(es, mvaName_NoEleMatch_wGwoGSF_EC_); mva_woGwGSF_EC_ = loadMVAfromDB(es, mvaName_woGwGSF_EC_); mva_wGwGSF_EC_ = loadMVAfromDB(es, mvaName_wGwGSF_EC_); + if (isPhase2_) { + mva_NoEleMatch_woGwoGSF_VFEC_ = loadMVAfromDB(es, mvaName_NoEleMatch_woGwoGSF_VFEC_); + mva_NoEleMatch_wGwoGSF_VFEC_ = loadMVAfromDB(es, mvaName_NoEleMatch_wGwoGSF_VFEC_); + mva_woGwGSF_VFEC_ = loadMVAfromDB(es, mvaName_woGwGSF_VFEC_); + mva_wGwGSF_VFEC_ = loadMVAfromDB(es, mvaName_wGwGSF_VFEC_); + } } else { if (inputFileName_.location() == edm::FileInPath::Unknown) throw cms::Exception("PFRecoTauDiscriminationAgainstElectronMVA6::loadMVA") @@ -130,15 +185,27 @@ void AntiElectronIDMVA6::beginEvent(const edm::Event& evt mva_NoEleMatch_wGwoGSF_EC_ = loadMVAfromFile(inputFile, mvaName_NoEleMatch_wGwoGSF_EC_); mva_woGwGSF_EC_ = loadMVAfromFile(inputFile, mvaName_woGwGSF_EC_); mva_wGwGSF_EC_ = loadMVAfromFile(inputFile, mvaName_wGwGSF_EC_); + if (isPhase2_) { + mva_NoEleMatch_woGwoGSF_VFEC_ = loadMVAfromFile(inputFile, mvaName_NoEleMatch_woGwoGSF_VFEC_); + mva_NoEleMatch_wGwoGSF_VFEC_ = loadMVAfromFile(inputFile, mvaName_NoEleMatch_wGwoGSF_VFEC_); + mva_woGwGSF_VFEC_ = loadMVAfromFile(inputFile, mvaName_woGwGSF_VFEC_); + mva_wGwGSF_VFEC_ = loadMVAfromFile(inputFile, mvaName_wGwGSF_VFEC_); + } inputFilesToDelete_.push_back(inputFile); } isInitialized_ = true; } positionAtECalEntrance_.beginEvent(es); + //MB: Handle additional inputs (HGCal EleID variables) only for Phase2 and reco::GsfElectrons + if (isPhase2_ && std::is_same::value) { + for (const auto& eId_token : electronIds_tokens_) { + electronIds_[eId_token.first] = evt.getHandle(eId_token.second); + } + } } template -double AntiElectronIDMVA6::MVAValue(const TauVars& tauVars, +double AntiElectronIDMVA6::mvaValue(const TauVars& tauVars, const TauGammaVecs& tauGammaVecs, const ElecVars& elecVars) { TauGammaMoms tauGammaMoms; @@ -198,11 +265,15 @@ double AntiElectronIDMVA6::MVAValue(const TauVars& tauVar tauGammaMoms.gammaEtaMomOut = std::sqrt(dEta2 * tauGammaMoms.gammaEnFracOut) * tauVars.pt; tauGammaMoms.gammaPhiMomOut = std::sqrt(dPhi2 * tauGammaMoms.gammaEnFracOut) * tauVars.pt; - return MVAValue(tauVars, tauGammaMoms, elecVars); + if (!isPhase2_) { + return mvaValue(tauVars, tauGammaMoms, elecVars); + } else { + return mvaValuePhase2(tauVars, tauGammaMoms, elecVars); + } } template -double AntiElectronIDMVA6::MVAValue(const TauVars& tauVars, +double AntiElectronIDMVA6::mvaValue(const TauVars& tauVars, const TauGammaMoms& tauGammaMoms, const ElecVars& elecVars) { if (!isInitialized_) { @@ -211,7 +282,6 @@ double AntiElectronIDMVA6::MVAValue(const TauVars& tauVar double mvaValue = -99.; - const float ECALBarrelEndcapEtaBorder = 1.479; float elecDeltaPinPoutOverPin = (elecVars.pIn > 0.0) ? (std::abs(elecVars.pIn - elecVars.pOut) / elecVars.pIn) : 1.0; float elecEecalOverPout = (elecVars.pOut > 0.0) ? (elecVars.eEcal / elecVars.pOut) : 20.0; float elecNumHitsDiffOverSum = @@ -221,200 +291,528 @@ double AntiElectronIDMVA6::MVAValue(const TauVars& tauVar if (deltaR(tauVars.etaAtEcalEntrance, tauVars.phi, elecVars.eta, elecVars.phi) > 0.3 && tauGammaMoms.signalPFGammaCandsIn == 0 && tauVars.hasGsf < 0.5) { - if (std::abs(tauVars.etaAtEcalEntrance) < ECALBarrelEndcapEtaBorder) { - Var_NoEleMatch_woGwoGSF_Barrel_[0] = tauVars.etaAtEcalEntrance; - Var_NoEleMatch_woGwoGSF_Barrel_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance; - Var_NoEleMatch_woGwoGSF_Barrel_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); - Var_NoEleMatch_woGwoGSF_Barrel_[3] = std::log(std::max(1.f, tauVars.pt)); - Var_NoEleMatch_woGwoGSF_Barrel_[4] = tauVars.emFraction; - Var_NoEleMatch_woGwoGSF_Barrel_[5] = tauVars.leadPFChargedHadrHoP; - Var_NoEleMatch_woGwoGSF_Barrel_[6] = tauVars.leadPFChargedHadrEoP; - Var_NoEleMatch_woGwoGSF_Barrel_[7] = tauVars.visMassIn; - Var_NoEleMatch_woGwoGSF_Barrel_[8] = tauVars.dCrackEta; - Var_NoEleMatch_woGwoGSF_Barrel_[9] = tauVars.dCrackPhi; - mvaValue = mva_NoEleMatch_woGwoGSF_BL_->GetClassifier(Var_NoEleMatch_woGwoGSF_Barrel_); + if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) { + var_NoEleMatch_woGwoGSF_Barrel_[0] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_woGwoGSF_Barrel_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_NoEleMatch_woGwoGSF_Barrel_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_Barrel_[3] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_Barrel_[4] = tauVars.emFraction; + var_NoEleMatch_woGwoGSF_Barrel_[5] = tauVars.leadPFChargedHadrHoP; + var_NoEleMatch_woGwoGSF_Barrel_[6] = tauVars.leadPFChargedHadrEoP; + var_NoEleMatch_woGwoGSF_Barrel_[7] = tauVars.visMassIn; + var_NoEleMatch_woGwoGSF_Barrel_[8] = tauVars.dCrackEta; + var_NoEleMatch_woGwoGSF_Barrel_[9] = tauVars.dCrackPhi; + mvaValue = mva_NoEleMatch_woGwoGSF_BL_->GetClassifier(var_NoEleMatch_woGwoGSF_Barrel_.data()); } else { - Var_NoEleMatch_woGwoGSF_Endcap_[0] = tauVars.etaAtEcalEntrance; - Var_NoEleMatch_woGwoGSF_Endcap_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance; - Var_NoEleMatch_woGwoGSF_Endcap_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); - Var_NoEleMatch_woGwoGSF_Endcap_[3] = std::log(std::max(1.f, tauVars.pt)); - Var_NoEleMatch_woGwoGSF_Endcap_[4] = tauVars.emFraction; - Var_NoEleMatch_woGwoGSF_Endcap_[5] = tauVars.leadPFChargedHadrHoP; - Var_NoEleMatch_woGwoGSF_Endcap_[6] = tauVars.leadPFChargedHadrEoP; - Var_NoEleMatch_woGwoGSF_Endcap_[7] = tauVars.visMassIn; - Var_NoEleMatch_woGwoGSF_Endcap_[8] = tauVars.dCrackEta; - mvaValue = mva_NoEleMatch_woGwoGSF_EC_->GetClassifier(Var_NoEleMatch_woGwoGSF_Endcap_); + var_NoEleMatch_woGwoGSF_Endcap_[0] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_woGwoGSF_Endcap_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_NoEleMatch_woGwoGSF_Endcap_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_Endcap_[3] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_Endcap_[4] = tauVars.emFraction; + var_NoEleMatch_woGwoGSF_Endcap_[5] = tauVars.leadPFChargedHadrHoP; + var_NoEleMatch_woGwoGSF_Endcap_[6] = tauVars.leadPFChargedHadrEoP; + var_NoEleMatch_woGwoGSF_Endcap_[7] = tauVars.visMassIn; + var_NoEleMatch_woGwoGSF_Endcap_[8] = tauVars.dCrackEta; + mvaValue = mva_NoEleMatch_woGwoGSF_EC_->GetClassifier(var_NoEleMatch_woGwoGSF_Endcap_.data()); } } else if (deltaR(tauVars.etaAtEcalEntrance, tauVars.phi, elecVars.eta, elecVars.phi) > 0.3 && tauGammaMoms.signalPFGammaCandsIn > 0 && tauVars.hasGsf < 0.5) { - if (std::abs(tauVars.etaAtEcalEntrance) < ECALBarrelEndcapEtaBorder) { - Var_NoEleMatch_wGwoGSF_Barrel_[0] = tauVars.etaAtEcalEntrance; - Var_NoEleMatch_wGwoGSF_Barrel_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance; - Var_NoEleMatch_wGwoGSF_Barrel_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); - Var_NoEleMatch_wGwoGSF_Barrel_[3] = std::log(std::max(1.f, tauVars.pt)); - Var_NoEleMatch_wGwoGSF_Barrel_[4] = tauVars.emFraction; - Var_NoEleMatch_wGwoGSF_Barrel_[5] = tauGammaMoms.signalPFGammaCandsIn; - Var_NoEleMatch_wGwoGSF_Barrel_[6] = tauGammaMoms.signalPFGammaCandsOut; - Var_NoEleMatch_wGwoGSF_Barrel_[7] = tauVars.leadPFChargedHadrHoP; - Var_NoEleMatch_wGwoGSF_Barrel_[8] = tauVars.leadPFChargedHadrEoP; - Var_NoEleMatch_wGwoGSF_Barrel_[9] = tauVars.visMassIn; - Var_NoEleMatch_wGwoGSF_Barrel_[10] = tauGammaMoms.gammaEtaMomIn; - Var_NoEleMatch_wGwoGSF_Barrel_[11] = tauGammaMoms.gammaEtaMomOut; - Var_NoEleMatch_wGwoGSF_Barrel_[12] = tauGammaMoms.gammaPhiMomIn; - Var_NoEleMatch_wGwoGSF_Barrel_[13] = tauGammaMoms.gammaPhiMomOut; - Var_NoEleMatch_wGwoGSF_Barrel_[14] = tauGammaMoms.gammaEnFracIn; - Var_NoEleMatch_wGwoGSF_Barrel_[15] = tauGammaMoms.gammaEnFracOut; - Var_NoEleMatch_wGwoGSF_Barrel_[16] = tauVars.dCrackEta; - Var_NoEleMatch_wGwoGSF_Barrel_[17] = tauVars.dCrackPhi; - mvaValue = mva_NoEleMatch_wGwoGSF_BL_->GetClassifier(Var_NoEleMatch_wGwoGSF_Barrel_); + if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) { + var_NoEleMatch_wGwoGSF_Barrel_[0] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_wGwoGSF_Barrel_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_NoEleMatch_wGwoGSF_Barrel_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_Barrel_[3] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_Barrel_[4] = tauVars.emFraction; + var_NoEleMatch_wGwoGSF_Barrel_[5] = tauGammaMoms.signalPFGammaCandsIn; + var_NoEleMatch_wGwoGSF_Barrel_[6] = tauGammaMoms.signalPFGammaCandsOut; + var_NoEleMatch_wGwoGSF_Barrel_[7] = tauVars.leadPFChargedHadrHoP; + var_NoEleMatch_wGwoGSF_Barrel_[8] = tauVars.leadPFChargedHadrEoP; + var_NoEleMatch_wGwoGSF_Barrel_[9] = tauVars.visMassIn; + var_NoEleMatch_wGwoGSF_Barrel_[10] = tauGammaMoms.gammaEtaMomIn; + var_NoEleMatch_wGwoGSF_Barrel_[11] = tauGammaMoms.gammaEtaMomOut; + var_NoEleMatch_wGwoGSF_Barrel_[12] = tauGammaMoms.gammaPhiMomIn; + var_NoEleMatch_wGwoGSF_Barrel_[13] = tauGammaMoms.gammaPhiMomOut; + var_NoEleMatch_wGwoGSF_Barrel_[14] = tauGammaMoms.gammaEnFracIn; + var_NoEleMatch_wGwoGSF_Barrel_[15] = tauGammaMoms.gammaEnFracOut; + var_NoEleMatch_wGwoGSF_Barrel_[16] = tauVars.dCrackEta; + var_NoEleMatch_wGwoGSF_Barrel_[17] = tauVars.dCrackPhi; + mvaValue = mva_NoEleMatch_wGwoGSF_BL_->GetClassifier(var_NoEleMatch_wGwoGSF_Barrel_.data()); } else { - Var_NoEleMatch_wGwoGSF_Endcap_[0] = tauVars.etaAtEcalEntrance; - Var_NoEleMatch_wGwoGSF_Endcap_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance; - Var_NoEleMatch_wGwoGSF_Endcap_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); - Var_NoEleMatch_wGwoGSF_Endcap_[3] = std::log(std::max(1.f, tauVars.pt)); - Var_NoEleMatch_wGwoGSF_Endcap_[4] = tauVars.emFraction; - Var_NoEleMatch_wGwoGSF_Endcap_[5] = tauGammaMoms.signalPFGammaCandsIn; - Var_NoEleMatch_wGwoGSF_Endcap_[6] = tauGammaMoms.signalPFGammaCandsOut; - Var_NoEleMatch_wGwoGSF_Endcap_[7] = tauVars.leadPFChargedHadrHoP; - Var_NoEleMatch_wGwoGSF_Endcap_[8] = tauVars.leadPFChargedHadrEoP; - Var_NoEleMatch_wGwoGSF_Endcap_[9] = tauVars.visMassIn; - Var_NoEleMatch_wGwoGSF_Endcap_[10] = tauGammaMoms.gammaEtaMomIn; - Var_NoEleMatch_wGwoGSF_Endcap_[11] = tauGammaMoms.gammaEtaMomOut; - Var_NoEleMatch_wGwoGSF_Endcap_[12] = tauGammaMoms.gammaPhiMomIn; - Var_NoEleMatch_wGwoGSF_Endcap_[13] = tauGammaMoms.gammaPhiMomOut; - Var_NoEleMatch_wGwoGSF_Endcap_[14] = tauGammaMoms.gammaEnFracIn; - Var_NoEleMatch_wGwoGSF_Endcap_[15] = tauGammaMoms.gammaEnFracOut; - Var_NoEleMatch_wGwoGSF_Endcap_[16] = tauVars.dCrackEta; - mvaValue = mva_NoEleMatch_wGwoGSF_EC_->GetClassifier(Var_NoEleMatch_wGwoGSF_Endcap_); + var_NoEleMatch_wGwoGSF_Endcap_[0] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_wGwoGSF_Endcap_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_NoEleMatch_wGwoGSF_Endcap_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_Endcap_[3] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_Endcap_[4] = tauVars.emFraction; + var_NoEleMatch_wGwoGSF_Endcap_[5] = tauGammaMoms.signalPFGammaCandsIn; + var_NoEleMatch_wGwoGSF_Endcap_[6] = tauGammaMoms.signalPFGammaCandsOut; + var_NoEleMatch_wGwoGSF_Endcap_[7] = tauVars.leadPFChargedHadrHoP; + var_NoEleMatch_wGwoGSF_Endcap_[8] = tauVars.leadPFChargedHadrEoP; + var_NoEleMatch_wGwoGSF_Endcap_[9] = tauVars.visMassIn; + var_NoEleMatch_wGwoGSF_Endcap_[10] = tauGammaMoms.gammaEtaMomIn; + var_NoEleMatch_wGwoGSF_Endcap_[11] = tauGammaMoms.gammaEtaMomOut; + var_NoEleMatch_wGwoGSF_Endcap_[12] = tauGammaMoms.gammaPhiMomIn; + var_NoEleMatch_wGwoGSF_Endcap_[13] = tauGammaMoms.gammaPhiMomOut; + var_NoEleMatch_wGwoGSF_Endcap_[14] = tauGammaMoms.gammaEnFracIn; + var_NoEleMatch_wGwoGSF_Endcap_[15] = tauGammaMoms.gammaEnFracOut; + var_NoEleMatch_wGwoGSF_Endcap_[16] = tauVars.dCrackEta; + mvaValue = mva_NoEleMatch_wGwoGSF_EC_->GetClassifier(var_NoEleMatch_wGwoGSF_Endcap_.data()); } } else if (tauGammaMoms.signalPFGammaCandsIn == 0 && tauVars.hasGsf > 0.5) { - if (std::abs(tauVars.etaAtEcalEntrance) < ECALBarrelEndcapEtaBorder) { - Var_woGwGSF_Barrel_[0] = std::max(-0.1f, elecVars.eTotOverPin); - Var_woGwGSF_Barrel_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF)); - Var_woGwGSF_Barrel_[2] = elecVars.gsfNumHits; - Var_woGwGSF_Barrel_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol)); - Var_woGwGSF_Barrel_[4] = elecVars.gsfTracklnPt; - Var_woGwGSF_Barrel_[5] = elecNumHitsDiffOverSum; - Var_woGwGSF_Barrel_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF)); - Var_woGwGSF_Barrel_[7] = std::min(elecDeltaPinPoutOverPin, 1.f); - Var_woGwGSF_Barrel_[8] = std::min(elecEecalOverPout, 20.f); - Var_woGwGSF_Barrel_[9] = elecVars.deltaEta; - Var_woGwGSF_Barrel_[10] = elecVars.deltaPhi; - Var_woGwGSF_Barrel_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); - Var_woGwGSF_Barrel_[12] = std::min(elecVars.mvaInHadEnergy, 20.f); - Var_woGwGSF_Barrel_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f); - Var_woGwGSF_Barrel_[14] = tauVars.etaAtEcalEntrance; - Var_woGwGSF_Barrel_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance; - Var_woGwGSF_Barrel_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); - Var_woGwGSF_Barrel_[17] = std::log(std::max(1.f, tauVars.pt)); - Var_woGwGSF_Barrel_[18] = tauVars.emFraction; - Var_woGwGSF_Barrel_[19] = tauVars.leadPFChargedHadrHoP; - Var_woGwGSF_Barrel_[20] = tauVars.leadPFChargedHadrEoP; - Var_woGwGSF_Barrel_[21] = tauVars.visMassIn; - Var_woGwGSF_Barrel_[22] = tauVars.dCrackEta; - Var_woGwGSF_Barrel_[23] = tauVars.dCrackPhi; - mvaValue = mva_woGwGSF_BL_->GetClassifier(Var_woGwGSF_Barrel_); + if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) { + var_woGwGSF_Barrel_[0] = std::max(-0.1f, elecVars.eTotOverPin); + var_woGwGSF_Barrel_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF)); + var_woGwGSF_Barrel_[2] = elecVars.gsfNumHits; + var_woGwGSF_Barrel_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol)); + var_woGwGSF_Barrel_[4] = elecVars.gsfTracklnPt; + var_woGwGSF_Barrel_[5] = elecNumHitsDiffOverSum; + var_woGwGSF_Barrel_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF)); + var_woGwGSF_Barrel_[7] = std::min(elecDeltaPinPoutOverPin, 1.f); + var_woGwGSF_Barrel_[8] = std::min(elecEecalOverPout, 20.f); + var_woGwGSF_Barrel_[9] = elecVars.deltaEta; + var_woGwGSF_Barrel_[10] = elecVars.deltaPhi; + var_woGwGSF_Barrel_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); + var_woGwGSF_Barrel_[12] = std::min(elecVars.mvaInHadEnergy, 20.f); + var_woGwGSF_Barrel_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f); + var_woGwGSF_Barrel_[14] = tauVars.etaAtEcalEntrance; + var_woGwGSF_Barrel_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_woGwGSF_Barrel_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_woGwGSF_Barrel_[17] = std::log(std::max(1.f, tauVars.pt)); + var_woGwGSF_Barrel_[18] = tauVars.emFraction; + var_woGwGSF_Barrel_[19] = tauVars.leadPFChargedHadrHoP; + var_woGwGSF_Barrel_[20] = tauVars.leadPFChargedHadrEoP; + var_woGwGSF_Barrel_[21] = tauVars.visMassIn; + var_woGwGSF_Barrel_[22] = tauVars.dCrackEta; + var_woGwGSF_Barrel_[23] = tauVars.dCrackPhi; + mvaValue = mva_woGwGSF_BL_->GetClassifier(var_woGwGSF_Barrel_.data()); } else { - Var_woGwGSF_Endcap_[0] = std::max(-0.1f, elecVars.eTotOverPin); - Var_woGwGSF_Endcap_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF)); - Var_woGwGSF_Endcap_[2] = elecVars.gsfNumHits; - Var_woGwGSF_Endcap_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol)); - Var_woGwGSF_Endcap_[4] = elecVars.gsfTracklnPt; - Var_woGwGSF_Endcap_[5] = elecNumHitsDiffOverSum; - Var_woGwGSF_Endcap_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF)); - Var_woGwGSF_Endcap_[7] = std::min(elecDeltaPinPoutOverPin, 1.f); - Var_woGwGSF_Endcap_[8] = std::min(elecEecalOverPout, 20.f); - Var_woGwGSF_Endcap_[9] = elecVars.deltaEta; - Var_woGwGSF_Endcap_[10] = elecVars.deltaPhi; - Var_woGwGSF_Endcap_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); - Var_woGwGSF_Endcap_[12] = std::min(elecVars.mvaInHadEnergy, 20.f); - Var_woGwGSF_Endcap_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f); - Var_woGwGSF_Endcap_[14] = tauVars.etaAtEcalEntrance; - Var_woGwGSF_Endcap_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance; - Var_woGwGSF_Endcap_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); - Var_woGwGSF_Endcap_[17] = std::log(std::max(1.f, tauVars.pt)); - Var_woGwGSF_Endcap_[18] = tauVars.emFraction; - Var_woGwGSF_Endcap_[19] = tauVars.leadPFChargedHadrHoP; - Var_woGwGSF_Endcap_[20] = tauVars.leadPFChargedHadrEoP; - Var_woGwGSF_Endcap_[21] = tauVars.visMassIn; - Var_woGwGSF_Endcap_[22] = tauVars.dCrackEta; - mvaValue = mva_woGwGSF_EC_->GetClassifier(Var_woGwGSF_Endcap_); + var_woGwGSF_Endcap_[0] = std::max(-0.1f, elecVars.eTotOverPin); + var_woGwGSF_Endcap_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF)); + var_woGwGSF_Endcap_[2] = elecVars.gsfNumHits; + var_woGwGSF_Endcap_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol)); + var_woGwGSF_Endcap_[4] = elecVars.gsfTracklnPt; + var_woGwGSF_Endcap_[5] = elecNumHitsDiffOverSum; + var_woGwGSF_Endcap_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF)); + var_woGwGSF_Endcap_[7] = std::min(elecDeltaPinPoutOverPin, 1.f); + var_woGwGSF_Endcap_[8] = std::min(elecEecalOverPout, 20.f); + var_woGwGSF_Endcap_[9] = elecVars.deltaEta; + var_woGwGSF_Endcap_[10] = elecVars.deltaPhi; + var_woGwGSF_Endcap_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); + var_woGwGSF_Endcap_[12] = std::min(elecVars.mvaInHadEnergy, 20.f); + var_woGwGSF_Endcap_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f); + var_woGwGSF_Endcap_[14] = tauVars.etaAtEcalEntrance; + var_woGwGSF_Endcap_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_woGwGSF_Endcap_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_woGwGSF_Endcap_[17] = std::log(std::max(1.f, tauVars.pt)); + var_woGwGSF_Endcap_[18] = tauVars.emFraction; + var_woGwGSF_Endcap_[19] = tauVars.leadPFChargedHadrHoP; + var_woGwGSF_Endcap_[20] = tauVars.leadPFChargedHadrEoP; + var_woGwGSF_Endcap_[21] = tauVars.visMassIn; + var_woGwGSF_Endcap_[22] = tauVars.dCrackEta; + mvaValue = mva_woGwGSF_EC_->GetClassifier(var_woGwGSF_Endcap_.data()); } } else if (tauGammaMoms.signalPFGammaCandsIn > 0 && tauVars.hasGsf > 0.5) { - if (std::abs(tauVars.etaAtEcalEntrance) < ECALBarrelEndcapEtaBorder) { - Var_wGwGSF_Barrel_[0] = std::max(-0.1f, elecVars.eTotOverPin); - Var_wGwGSF_Barrel_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF)); - Var_wGwGSF_Barrel_[2] = elecVars.gsfNumHits; - Var_wGwGSF_Barrel_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol)); - Var_wGwGSF_Barrel_[4] = elecVars.gsfTracklnPt; - Var_wGwGSF_Barrel_[5] = elecNumHitsDiffOverSum; - Var_wGwGSF_Barrel_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF)); - Var_wGwGSF_Barrel_[7] = std::min(elecDeltaPinPoutOverPin, 1.f); - Var_wGwGSF_Barrel_[8] = std::min(elecEecalOverPout, 20.f); - Var_wGwGSF_Barrel_[9] = elecVars.deltaEta; - Var_wGwGSF_Barrel_[10] = elecVars.deltaPhi; - Var_wGwGSF_Barrel_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); - Var_wGwGSF_Barrel_[12] = std::min(elecVars.mvaInHadEnergy, 20.f); - Var_wGwGSF_Barrel_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f); - Var_wGwGSF_Barrel_[14] = tauVars.etaAtEcalEntrance; - Var_wGwGSF_Barrel_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance; - Var_wGwGSF_Barrel_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); - Var_wGwGSF_Barrel_[17] = std::log(std::max(1.f, tauVars.pt)); - Var_wGwGSF_Barrel_[18] = tauVars.emFraction; - Var_wGwGSF_Barrel_[19] = tauGammaMoms.signalPFGammaCandsIn; - Var_wGwGSF_Barrel_[20] = tauGammaMoms.signalPFGammaCandsOut; - Var_wGwGSF_Barrel_[21] = tauVars.leadPFChargedHadrHoP; - Var_wGwGSF_Barrel_[22] = tauVars.leadPFChargedHadrEoP; - Var_wGwGSF_Barrel_[23] = tauVars.visMassIn; - Var_wGwGSF_Barrel_[24] = tauGammaMoms.gammaEtaMomIn; - Var_wGwGSF_Barrel_[25] = tauGammaMoms.gammaEtaMomOut; - Var_wGwGSF_Barrel_[26] = tauGammaMoms.gammaPhiMomIn; - Var_wGwGSF_Barrel_[27] = tauGammaMoms.gammaPhiMomOut; - Var_wGwGSF_Barrel_[28] = tauGammaMoms.gammaEnFracIn; - Var_wGwGSF_Barrel_[29] = tauGammaMoms.gammaEnFracOut; - Var_wGwGSF_Barrel_[30] = tauVars.dCrackEta; - Var_wGwGSF_Barrel_[31] = tauVars.dCrackPhi; - mvaValue = mva_wGwGSF_BL_->GetClassifier(Var_wGwGSF_Barrel_); + if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) { + var_wGwGSF_Barrel_[0] = std::max(-0.1f, elecVars.eTotOverPin); + var_wGwGSF_Barrel_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF)); + var_wGwGSF_Barrel_[2] = elecVars.gsfNumHits; + var_wGwGSF_Barrel_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol)); + var_wGwGSF_Barrel_[4] = elecVars.gsfTracklnPt; + var_wGwGSF_Barrel_[5] = elecNumHitsDiffOverSum; + var_wGwGSF_Barrel_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF)); + var_wGwGSF_Barrel_[7] = std::min(elecDeltaPinPoutOverPin, 1.f); + var_wGwGSF_Barrel_[8] = std::min(elecEecalOverPout, 20.f); + var_wGwGSF_Barrel_[9] = elecVars.deltaEta; + var_wGwGSF_Barrel_[10] = elecVars.deltaPhi; + var_wGwGSF_Barrel_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); + var_wGwGSF_Barrel_[12] = std::min(elecVars.mvaInHadEnergy, 20.f); + var_wGwGSF_Barrel_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f); + var_wGwGSF_Barrel_[14] = tauVars.etaAtEcalEntrance; + var_wGwGSF_Barrel_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_wGwGSF_Barrel_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_wGwGSF_Barrel_[17] = std::log(std::max(1.f, tauVars.pt)); + var_wGwGSF_Barrel_[18] = tauVars.emFraction; + var_wGwGSF_Barrel_[19] = tauGammaMoms.signalPFGammaCandsIn; + var_wGwGSF_Barrel_[20] = tauGammaMoms.signalPFGammaCandsOut; + var_wGwGSF_Barrel_[21] = tauVars.leadPFChargedHadrHoP; + var_wGwGSF_Barrel_[22] = tauVars.leadPFChargedHadrEoP; + var_wGwGSF_Barrel_[23] = tauVars.visMassIn; + var_wGwGSF_Barrel_[24] = tauGammaMoms.gammaEtaMomIn; + var_wGwGSF_Barrel_[25] = tauGammaMoms.gammaEtaMomOut; + var_wGwGSF_Barrel_[26] = tauGammaMoms.gammaPhiMomIn; + var_wGwGSF_Barrel_[27] = tauGammaMoms.gammaPhiMomOut; + var_wGwGSF_Barrel_[28] = tauGammaMoms.gammaEnFracIn; + var_wGwGSF_Barrel_[29] = tauGammaMoms.gammaEnFracOut; + var_wGwGSF_Barrel_[30] = tauVars.dCrackEta; + var_wGwGSF_Barrel_[31] = tauVars.dCrackPhi; + mvaValue = mva_wGwGSF_BL_->GetClassifier(var_wGwGSF_Barrel_.data()); } else { - Var_wGwGSF_Endcap_[0] = std::max(-0.1f, elecVars.eTotOverPin); - Var_wGwGSF_Endcap_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF)); - Var_wGwGSF_Endcap_[2] = elecVars.gsfNumHits; - Var_wGwGSF_Endcap_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol)); - Var_wGwGSF_Endcap_[4] = elecVars.gsfTracklnPt; - Var_wGwGSF_Endcap_[5] = elecNumHitsDiffOverSum; - Var_wGwGSF_Endcap_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF)); - Var_wGwGSF_Endcap_[7] = std::min(elecDeltaPinPoutOverPin, 1.f); - Var_wGwGSF_Endcap_[8] = std::min(elecEecalOverPout, 20.f); - Var_wGwGSF_Endcap_[9] = elecVars.deltaEta; - Var_wGwGSF_Endcap_[10] = elecVars.deltaPhi; - Var_wGwGSF_Endcap_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); - Var_wGwGSF_Endcap_[12] = std::min(elecVars.mvaInHadEnergy, 20.f); - Var_wGwGSF_Endcap_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f); - Var_wGwGSF_Endcap_[14] = tauVars.etaAtEcalEntrance; - Var_wGwGSF_Endcap_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance; - Var_wGwGSF_Endcap_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); - Var_wGwGSF_Endcap_[17] = std::log(std::max(1.f, tauVars.pt)); - Var_wGwGSF_Endcap_[18] = tauVars.emFraction; - Var_wGwGSF_Endcap_[19] = tauGammaMoms.signalPFGammaCandsIn; - Var_wGwGSF_Endcap_[20] = tauGammaMoms.signalPFGammaCandsOut; - Var_wGwGSF_Endcap_[21] = tauVars.leadPFChargedHadrHoP; - Var_wGwGSF_Endcap_[22] = tauVars.leadPFChargedHadrEoP; - Var_wGwGSF_Endcap_[23] = tauVars.visMassIn; - Var_wGwGSF_Endcap_[24] = tauGammaMoms.gammaEtaMomIn; - Var_wGwGSF_Endcap_[25] = tauGammaMoms.gammaEtaMomOut; - Var_wGwGSF_Endcap_[26] = tauGammaMoms.gammaPhiMomIn; - Var_wGwGSF_Endcap_[27] = tauGammaMoms.gammaPhiMomOut; - Var_wGwGSF_Endcap_[28] = tauGammaMoms.gammaEnFracIn; - Var_wGwGSF_Endcap_[29] = tauGammaMoms.gammaEnFracOut; - Var_wGwGSF_Endcap_[30] = tauVars.dCrackEta; - mvaValue = mva_wGwGSF_EC_->GetClassifier(Var_wGwGSF_Endcap_); + var_wGwGSF_Endcap_[0] = std::max(-0.1f, elecVars.eTotOverPin); + var_wGwGSF_Endcap_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF)); + var_wGwGSF_Endcap_[2] = elecVars.gsfNumHits; + var_wGwGSF_Endcap_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol)); + var_wGwGSF_Endcap_[4] = elecVars.gsfTracklnPt; + var_wGwGSF_Endcap_[5] = elecNumHitsDiffOverSum; + var_wGwGSF_Endcap_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF)); + var_wGwGSF_Endcap_[7] = std::min(elecDeltaPinPoutOverPin, 1.f); + var_wGwGSF_Endcap_[8] = std::min(elecEecalOverPout, 20.f); + var_wGwGSF_Endcap_[9] = elecVars.deltaEta; + var_wGwGSF_Endcap_[10] = elecVars.deltaPhi; + var_wGwGSF_Endcap_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); + var_wGwGSF_Endcap_[12] = std::min(elecVars.mvaInHadEnergy, 20.f); + var_wGwGSF_Endcap_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f); + var_wGwGSF_Endcap_[14] = tauVars.etaAtEcalEntrance; + var_wGwGSF_Endcap_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_wGwGSF_Endcap_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_wGwGSF_Endcap_[17] = std::log(std::max(1.f, tauVars.pt)); + var_wGwGSF_Endcap_[18] = tauVars.emFraction; + var_wGwGSF_Endcap_[19] = tauGammaMoms.signalPFGammaCandsIn; + var_wGwGSF_Endcap_[20] = tauGammaMoms.signalPFGammaCandsOut; + var_wGwGSF_Endcap_[21] = tauVars.leadPFChargedHadrHoP; + var_wGwGSF_Endcap_[22] = tauVars.leadPFChargedHadrEoP; + var_wGwGSF_Endcap_[23] = tauVars.visMassIn; + var_wGwGSF_Endcap_[24] = tauGammaMoms.gammaEtaMomIn; + var_wGwGSF_Endcap_[25] = tauGammaMoms.gammaEtaMomOut; + var_wGwGSF_Endcap_[26] = tauGammaMoms.gammaPhiMomIn; + var_wGwGSF_Endcap_[27] = tauGammaMoms.gammaPhiMomOut; + var_wGwGSF_Endcap_[28] = tauGammaMoms.gammaEnFracIn; + var_wGwGSF_Endcap_[29] = tauGammaMoms.gammaEnFracOut; + var_wGwGSF_Endcap_[30] = tauVars.dCrackEta; + mvaValue = mva_wGwGSF_EC_->GetClassifier(var_wGwGSF_Endcap_.data()); } } return mvaValue; } +//// +template +double AntiElectronIDMVA6::mvaValuePhase2(const TauVars& tauVars, + const TauGammaMoms& tauGammaMoms, + const ElecVars& elecVars) { + if (!isInitialized_) { + throw cms::Exception("ClassNotInitialized") << " AntiElectronMVA6 not properly initialized !!\n"; + } + + double mvaValue = -99.; + + //do not consider tau candidates outside the HGCal border at |eta|=3 + if (std::abs(tauVars.etaAtEcalEntrance) > 3.0) { + return mvaValue; + } + float elecDeltaPinPoutOverPin = (elecVars.pIn > 0.0) ? (std::abs(elecVars.pIn - elecVars.pOut) / elecVars.pIn) : 1.0; + float elecEecalOverPout = (elecVars.pOut > 0.0) ? (elecVars.eEcal / elecVars.pOut) : 20.0; + float elecNumHitsDiffOverSum = + ((elecVars.gsfNumHits + elecVars.kfNumHits) > 0.0) + ? ((elecVars.gsfNumHits - elecVars.kfNumHits) / (elecVars.gsfNumHits + elecVars.kfNumHits)) + : 1.0; + + if (tauGammaMoms.signalPFGammaCandsIn == 0 && tauVars.hasGsf < 0.5) { + if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) { + var_NoEleMatch_woGwoGSF_Barrel_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_Barrel_[1] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_Barrel_[2] = tauVars.emFraction; + var_NoEleMatch_woGwoGSF_Barrel_[3] = tauVars.leadPFChargedHadrHoP; + var_NoEleMatch_woGwoGSF_Barrel_[4] = tauVars.leadPFChargedHadrEoP; + var_NoEleMatch_woGwoGSF_Barrel_[5] = tauVars.visMassIn; + var_NoEleMatch_woGwoGSF_Barrel_[6] = tauVars.dCrackEta; + var_NoEleMatch_woGwoGSF_Barrel_[7] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_woGwoGSF_Barrel_[8] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + mvaValue = mva_NoEleMatch_woGwoGSF_BL_->GetClassifier(var_NoEleMatch_woGwoGSF_Barrel_.data()); + } else if (std::abs(tauVars.etaAtEcalEntrance) < ecalEndcapVFEndcapEtaBorder_) { + var_NoEleMatch_woGwoGSF_Endcap_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_Endcap_[1] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_Endcap_[2] = tauVars.visMassIn; + var_NoEleMatch_woGwoGSF_Endcap_[3] = tauVars.dCrackEta; + var_NoEleMatch_woGwoGSF_Endcap_[4] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_woGwoGSF_Endcap_[5] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + mvaValue = mva_NoEleMatch_woGwoGSF_EC_->GetClassifier(var_NoEleMatch_woGwoGSF_Endcap_.data()); + } else { + var_NoEleMatch_woGwoGSF_VFEndcap_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_VFEndcap_[1] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_woGwoGSF_VFEndcap_[2] = tauVars.visMassIn; + var_NoEleMatch_woGwoGSF_VFEndcap_[3] = tauVars.dCrackEta; + var_NoEleMatch_woGwoGSF_VFEndcap_[4] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_woGwoGSF_VFEndcap_[5] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + mvaValue = mva_NoEleMatch_woGwoGSF_VFEC_->GetClassifier(var_NoEleMatch_woGwoGSF_VFEndcap_.data()); + } + } else if (tauGammaMoms.signalPFGammaCandsIn > 0 && tauVars.hasGsf < 0.5) { + if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) { + var_NoEleMatch_wGwoGSF_Barrel_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_Barrel_[1] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_Barrel_[2] = tauVars.emFraction; + var_NoEleMatch_wGwoGSF_Barrel_[3] = tauGammaMoms.signalPFGammaCandsIn; + var_NoEleMatch_wGwoGSF_Barrel_[4] = tauGammaMoms.signalPFGammaCandsOut; + var_NoEleMatch_wGwoGSF_Barrel_[5] = tauVars.leadPFChargedHadrHoP; + var_NoEleMatch_wGwoGSF_Barrel_[6] = tauVars.leadPFChargedHadrEoP; + var_NoEleMatch_wGwoGSF_Barrel_[7] = tauVars.visMassIn; + var_NoEleMatch_wGwoGSF_Barrel_[7] = tauGammaMoms.gammaEtaMomIn; + var_NoEleMatch_wGwoGSF_Barrel_[9] = tauGammaMoms.gammaEtaMomOut; + var_NoEleMatch_wGwoGSF_Barrel_[10] = tauGammaMoms.gammaPhiMomIn; + var_NoEleMatch_wGwoGSF_Barrel_[11] = tauGammaMoms.gammaPhiMomOut; + var_NoEleMatch_wGwoGSF_Barrel_[12] = tauGammaMoms.gammaEnFracIn; + var_NoEleMatch_wGwoGSF_Barrel_[13] = tauGammaMoms.gammaEnFracOut; + var_NoEleMatch_wGwoGSF_Barrel_[14] = tauVars.dCrackEta; + var_NoEleMatch_wGwoGSF_Barrel_[15] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_wGwoGSF_Barrel_[16] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + mvaValue = mva_NoEleMatch_wGwoGSF_BL_->GetClassifier(var_NoEleMatch_wGwoGSF_Barrel_.data()); + } else if (std::abs(tauVars.etaAtEcalEntrance) < ecalEndcapVFEndcapEtaBorder_) { + var_NoEleMatch_wGwoGSF_Endcap_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_Endcap_[1] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_Endcap_[2] = tauGammaMoms.signalPFGammaCandsIn; + var_NoEleMatch_wGwoGSF_Endcap_[3] = tauGammaMoms.signalPFGammaCandsOut; + var_NoEleMatch_wGwoGSF_Endcap_[4] = tauVars.visMassIn; + var_NoEleMatch_wGwoGSF_Endcap_[5] = tauGammaMoms.gammaEtaMomIn; + var_NoEleMatch_wGwoGSF_Endcap_[6] = tauGammaMoms.gammaEtaMomOut; + var_NoEleMatch_wGwoGSF_Endcap_[7] = tauGammaMoms.gammaPhiMomIn; + var_NoEleMatch_wGwoGSF_Endcap_[8] = tauGammaMoms.gammaPhiMomOut; + var_NoEleMatch_wGwoGSF_Endcap_[9] = tauGammaMoms.gammaEnFracIn; + var_NoEleMatch_wGwoGSF_Endcap_[10] = tauGammaMoms.gammaEnFracOut; + var_NoEleMatch_wGwoGSF_Endcap_[11] = tauVars.dCrackEta; + var_NoEleMatch_wGwoGSF_Endcap_[12] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_wGwoGSF_Endcap_[13] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + mvaValue = mva_NoEleMatch_wGwoGSF_EC_->GetClassifier(var_NoEleMatch_wGwoGSF_Endcap_.data()); + } else { + var_NoEleMatch_wGwoGSF_VFEndcap_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_VFEndcap_[1] = std::log(std::max(1.f, tauVars.pt)); + var_NoEleMatch_wGwoGSF_VFEndcap_[2] = tauGammaMoms.signalPFGammaCandsIn; + var_NoEleMatch_wGwoGSF_VFEndcap_[3] = tauGammaMoms.signalPFGammaCandsOut; + var_NoEleMatch_wGwoGSF_VFEndcap_[4] = tauVars.visMassIn; + var_NoEleMatch_wGwoGSF_VFEndcap_[5] = tauGammaMoms.gammaEtaMomIn; + var_NoEleMatch_wGwoGSF_VFEndcap_[6] = tauGammaMoms.gammaEtaMomOut; + var_NoEleMatch_wGwoGSF_VFEndcap_[7] = tauGammaMoms.gammaPhiMomIn; + var_NoEleMatch_wGwoGSF_VFEndcap_[8] = tauGammaMoms.gammaPhiMomOut; + var_NoEleMatch_wGwoGSF_VFEndcap_[9] = tauGammaMoms.gammaEnFracIn; + var_NoEleMatch_wGwoGSF_VFEndcap_[10] = tauGammaMoms.gammaEnFracOut; + var_NoEleMatch_wGwoGSF_VFEndcap_[11] = tauVars.dCrackEta; + var_NoEleMatch_wGwoGSF_VFEndcap_[12] = tauVars.etaAtEcalEntrance; + var_NoEleMatch_wGwoGSF_VFEndcap_[13] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + mvaValue = mva_NoEleMatch_wGwoGSF_VFEC_->GetClassifier(var_NoEleMatch_wGwoGSF_VFEndcap_.data()); + } + } else if (tauGammaMoms.signalPFGammaCandsIn == 0 && tauVars.hasGsf > 0.5) { + if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) { + var_woGwGSF_Barrel_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF)); + var_woGwGSF_Barrel_[1] = elecVars.gsfNumHits; + var_woGwGSF_Barrel_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol)); + var_woGwGSF_Barrel_[3] = elecVars.gsfTracklnPt; + var_woGwGSF_Barrel_[4] = elecNumHitsDiffOverSum; + var_woGwGSF_Barrel_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF)); + var_woGwGSF_Barrel_[6] = std::min(elecDeltaPinPoutOverPin, 1.f); + var_woGwGSF_Barrel_[7] = std::min(elecEecalOverPout, 20.f); + var_woGwGSF_Barrel_[8] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); + var_woGwGSF_Barrel_[9] = std::min(elecVars.mvaInHadEnergy, 20.f); + var_woGwGSF_Barrel_[10] = std::min(elecVars.mvaInDeltaEta, 0.1f); + var_woGwGSF_Barrel_[11] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_woGwGSF_Barrel_[12] = std::log(std::max(1.f, tauVars.pt)); + var_woGwGSF_Barrel_[13] = tauVars.emFraction; + var_woGwGSF_Barrel_[14] = tauVars.leadPFChargedHadrHoP; + var_woGwGSF_Barrel_[15] = tauVars.leadPFChargedHadrEoP; + var_woGwGSF_Barrel_[16] = tauVars.visMassIn; + var_woGwGSF_Barrel_[17] = tauVars.dCrackEta; + var_woGwGSF_Barrel_[18] = tauVars.etaAtEcalEntrance; + var_woGwGSF_Barrel_[19] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_woGwGSF_Barrel_[20] = elecVars.deltaEta; + var_woGwGSF_Barrel_[21] = elecVars.deltaPhi; + var_woGwGSF_Barrel_[22] = elecVars.sigmaIEtaIEta5x5; + var_woGwGSF_Barrel_[23] = elecVars.showerCircularity; + var_woGwGSF_Barrel_[24] = elecVars.r9; + var_woGwGSF_Barrel_[25] = elecVars.superClusterEtaWidth; + var_woGwGSF_Barrel_[26] = elecVars.superClusterPhiWidth; + mvaValue = mva_woGwGSF_BL_->GetClassifier(var_woGwGSF_Barrel_.data()); + } else if (std::abs(tauVars.etaAtEcalEntrance) < ecalEndcapVFEndcapEtaBorder_) { + var_woGwGSF_Endcap_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF)); + var_woGwGSF_Endcap_[1] = elecVars.gsfNumHits; + var_woGwGSF_Endcap_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol)); + var_woGwGSF_Endcap_[3] = elecVars.gsfTracklnPt; + var_woGwGSF_Endcap_[4] = elecNumHitsDiffOverSum; + var_woGwGSF_Endcap_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF)); + var_woGwGSF_Endcap_[6] = elecVars.eEcal; + var_woGwGSF_Endcap_[7] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_woGwGSF_Endcap_[8] = std::log(std::max(1.f, tauVars.pt)); + var_woGwGSF_Endcap_[9] = tauVars.visMassIn; + var_woGwGSF_Endcap_[10] = tauVars.dCrackEta; + var_woGwGSF_Endcap_[11] = tauVars.etaAtEcalEntrance; + var_woGwGSF_Endcap_[12] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_woGwGSF_Endcap_[13] = elecVars.hgcalSigmaUU; + var_woGwGSF_Endcap_[14] = elecVars.hgcalSigmaVV; + var_woGwGSF_Endcap_[15] = elecVars.hgcalSigmaEE; + var_woGwGSF_Endcap_[16] = elecVars.hgcalSigmaPP; + var_woGwGSF_Endcap_[17] = elecVars.hgcalNLayers; + var_woGwGSF_Endcap_[18] = elecVars.hgcalLastLayer; + var_woGwGSF_Endcap_[19] = elecVars.hgcalLayerEfrac10; + var_woGwGSF_Endcap_[20] = elecVars.hgcalLayerEfrac90; + var_woGwGSF_Endcap_[21] = elecVars.hgcalEcEnergyEE; + var_woGwGSF_Endcap_[22] = elecVars.hgcalEcEnergyFH; + var_woGwGSF_Endcap_[23] = elecVars.hgcalMeasuredDepth; + var_woGwGSF_Endcap_[24] = elecVars.hgcalExpectedDepth; + var_woGwGSF_Endcap_[25] = elecVars.hgcalDepthCompatibility; + var_woGwGSF_Endcap_[26] = elecVars.deltaEta; + var_woGwGSF_Endcap_[27] = elecVars.deltaPhi; + var_woGwGSF_Endcap_[28] = elecVars.eSeedClusterOverPout; + var_woGwGSF_Endcap_[29] = elecVars.superClusterEtaWidth; + var_woGwGSF_Endcap_[30] = elecVars.superClusterPhiWidth; + mvaValue = mva_woGwGSF_EC_->GetClassifier(var_woGwGSF_Endcap_.data()); + } else { + var_woGwGSF_VFEndcap_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF)); + var_woGwGSF_VFEndcap_[1] = elecVars.gsfNumHits; + var_woGwGSF_VFEndcap_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol)); + var_woGwGSF_VFEndcap_[3] = elecVars.gsfTracklnPt; + var_woGwGSF_VFEndcap_[4] = elecNumHitsDiffOverSum; + var_woGwGSF_VFEndcap_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF)); + var_woGwGSF_VFEndcap_[6] = elecVars.eEcal; + var_woGwGSF_VFEndcap_[7] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_woGwGSF_VFEndcap_[8] = std::log(std::max(1.f, tauVars.pt)); + var_woGwGSF_VFEndcap_[9] = tauVars.visMassIn; + var_woGwGSF_VFEndcap_[10] = tauVars.dCrackEta; + var_woGwGSF_VFEndcap_[11] = tauVars.etaAtEcalEntrance; + var_woGwGSF_VFEndcap_[12] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_woGwGSF_VFEndcap_[13] = elecVars.hgcalSigmaUU; + var_woGwGSF_VFEndcap_[14] = elecVars.hgcalSigmaVV; + var_woGwGSF_VFEndcap_[15] = elecVars.hgcalSigmaEE; + var_woGwGSF_VFEndcap_[16] = elecVars.hgcalSigmaPP; + var_woGwGSF_VFEndcap_[17] = elecVars.hgcalNLayers; + var_woGwGSF_VFEndcap_[18] = elecVars.hgcalLastLayer; + var_woGwGSF_VFEndcap_[19] = elecVars.hgcalLayerEfrac10; + var_woGwGSF_VFEndcap_[20] = elecVars.hgcalLayerEfrac90; + var_woGwGSF_VFEndcap_[21] = elecVars.hgcalEcEnergyEE; + var_woGwGSF_VFEndcap_[22] = elecVars.hgcalEcEnergyFH; + var_woGwGSF_VFEndcap_[23] = elecVars.hgcalMeasuredDepth; + var_woGwGSF_VFEndcap_[24] = elecVars.hgcalExpectedDepth; + var_woGwGSF_VFEndcap_[25] = elecVars.hgcalExpectedSigma; + var_woGwGSF_VFEndcap_[26] = elecVars.hgcalDepthCompatibility; + var_woGwGSF_VFEndcap_[27] = elecVars.deltaEta; + var_woGwGSF_VFEndcap_[28] = elecVars.deltaPhi; + var_woGwGSF_VFEndcap_[29] = elecVars.eSeedClusterOverPout; + var_woGwGSF_VFEndcap_[30] = elecVars.superClusterEtaWidth; + var_woGwGSF_VFEndcap_[31] = elecVars.superClusterPhiWidth; + mvaValue = mva_woGwGSF_VFEC_->GetClassifier(var_woGwGSF_VFEndcap_.data()); + } + } else if (tauGammaMoms.signalPFGammaCandsIn > 0 && tauVars.hasGsf > 0.5) { + if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) { + var_wGwGSF_Barrel_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF)); + var_wGwGSF_Barrel_[1] = elecVars.gsfNumHits; + var_wGwGSF_Barrel_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol)); + var_wGwGSF_Barrel_[3] = elecVars.gsfTracklnPt; + var_wGwGSF_Barrel_[4] = elecNumHitsDiffOverSum; + var_wGwGSF_Barrel_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF)); + var_wGwGSF_Barrel_[6] = std::min(elecDeltaPinPoutOverPin, 1.f); + var_wGwGSF_Barrel_[7] = std::min(elecEecalOverPout, 20.f); + var_wGwGSF_Barrel_[8] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f); + var_wGwGSF_Barrel_[9] = std::min(elecVars.mvaInHadEnergy, 20.f); + var_wGwGSF_Barrel_[10] = std::min(elecVars.mvaInDeltaEta, 0.1f); + var_wGwGSF_Barrel_[11] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_wGwGSF_Barrel_[12] = std::log(std::max(1.f, tauVars.pt)); + var_wGwGSF_Barrel_[13] = tauVars.emFraction; + var_wGwGSF_Barrel_[14] = tauGammaMoms.signalPFGammaCandsIn; + var_wGwGSF_Barrel_[15] = tauGammaMoms.signalPFGammaCandsOut; + var_wGwGSF_Barrel_[16] = tauVars.leadPFChargedHadrHoP; + var_wGwGSF_Barrel_[17] = tauVars.leadPFChargedHadrEoP; + var_wGwGSF_Barrel_[18] = tauVars.visMassIn; + var_wGwGSF_Barrel_[19] = tauGammaMoms.gammaEtaMomIn; + var_wGwGSF_Barrel_[20] = tauGammaMoms.gammaEtaMomOut; + var_wGwGSF_Barrel_[21] = tauGammaMoms.gammaPhiMomIn; + var_wGwGSF_Barrel_[22] = tauGammaMoms.gammaPhiMomOut; + var_wGwGSF_Barrel_[23] = tauGammaMoms.gammaEnFracIn; + var_wGwGSF_Barrel_[24] = tauGammaMoms.gammaEnFracOut; + var_wGwGSF_Barrel_[25] = tauVars.dCrackEta; + var_wGwGSF_Barrel_[26] = tauVars.etaAtEcalEntrance; + var_wGwGSF_Barrel_[27] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_wGwGSF_Barrel_[28] = elecVars.deltaEta; + var_wGwGSF_Barrel_[29] = elecVars.deltaPhi; + var_wGwGSF_Barrel_[30] = elecVars.sigmaIPhiIPhi5x5; + var_wGwGSF_Barrel_[31] = elecVars.sigmaIEtaIEta5x5; + var_wGwGSF_Barrel_[32] = elecVars.showerCircularity; + var_wGwGSF_Barrel_[33] = elecVars.eSeedClusterOverPout; + var_wGwGSF_Barrel_[34] = elecVars.superClusterEtaWidth; + var_wGwGSF_Barrel_[35] = elecVars.superClusterPhiWidth; + mvaValue = mva_wGwGSF_BL_->GetClassifier(var_wGwGSF_Barrel_.data()); + } else if (std::abs(tauVars.etaAtEcalEntrance) < ecalEndcapVFEndcapEtaBorder_) { + var_wGwGSF_Endcap_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF)); + var_wGwGSF_Endcap_[1] = elecVars.gsfNumHits; + var_wGwGSF_Endcap_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol)); + var_wGwGSF_Endcap_[3] = elecVars.gsfTracklnPt; + var_wGwGSF_Endcap_[4] = elecNumHitsDiffOverSum; + var_wGwGSF_Endcap_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF)); + var_wGwGSF_Endcap_[6] = elecVars.eEcal; + var_wGwGSF_Endcap_[7] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_wGwGSF_Endcap_[8] = std::log(std::max(1.f, tauVars.pt)); + var_wGwGSF_Endcap_[9] = tauGammaMoms.signalPFGammaCandsIn; + var_wGwGSF_Endcap_[10] = tauGammaMoms.signalPFGammaCandsOut; + var_wGwGSF_Endcap_[11] = tauVars.visMassIn; + var_wGwGSF_Endcap_[12] = tauGammaMoms.gammaEtaMomIn; + var_wGwGSF_Endcap_[13] = tauGammaMoms.gammaEtaMomOut; + var_wGwGSF_Endcap_[14] = tauGammaMoms.gammaPhiMomIn; + var_wGwGSF_Endcap_[15] = tauGammaMoms.gammaPhiMomOut; + var_wGwGSF_Endcap_[16] = tauGammaMoms.gammaEnFracIn; + var_wGwGSF_Endcap_[17] = tauGammaMoms.gammaEnFracOut; + var_wGwGSF_Endcap_[18] = tauVars.dCrackEta; + var_wGwGSF_Endcap_[19] = tauVars.etaAtEcalEntrance; + var_wGwGSF_Endcap_[20] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_wGwGSF_Endcap_[21] = elecVars.hgcalSigmaVV; + var_wGwGSF_Endcap_[22] = elecVars.hgcalSigmaEE; + var_wGwGSF_Endcap_[23] = elecVars.hgcalSigmaPP; + var_wGwGSF_Endcap_[24] = elecVars.hgcalNLayers; + var_wGwGSF_Endcap_[25] = elecVars.hgcalFirstLayer; + var_wGwGSF_Endcap_[26] = elecVars.hgcalLastLayer; + var_wGwGSF_Endcap_[27] = elecVars.hgcalLayerEfrac10; + var_wGwGSF_Endcap_[28] = elecVars.hgcalLayerEfrac90; + var_wGwGSF_Endcap_[29] = elecVars.hgcalEcEnergyEE; + var_wGwGSF_Endcap_[30] = elecVars.hgcalEcEnergyFH; + var_wGwGSF_Endcap_[31] = elecVars.hgcalMeasuredDepth; + var_wGwGSF_Endcap_[32] = elecVars.hgcalExpectedDepth; + var_wGwGSF_Endcap_[33] = elecVars.deltaEta; + var_wGwGSF_Endcap_[34] = elecVars.deltaPhi; + var_wGwGSF_Endcap_[35] = elecVars.eSeedClusterOverPout; + var_wGwGSF_Endcap_[36] = elecVars.superClusterEtaWidth; + var_wGwGSF_Endcap_[37] = elecVars.superClusterPhiWidth; + mvaValue = mva_wGwGSF_EC_->GetClassifier(var_wGwGSF_Endcap_.data()); + } else { + var_wGwGSF_VFEndcap_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF)); + var_wGwGSF_VFEndcap_[1] = elecVars.gsfNumHits; + var_wGwGSF_VFEndcap_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol)); + var_wGwGSF_VFEndcap_[3] = elecVars.gsfTracklnPt; + var_wGwGSF_VFEndcap_[4] = elecNumHitsDiffOverSum; + var_wGwGSF_VFEndcap_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF)); + var_wGwGSF_VFEndcap_[6] = elecVars.eEcal; + var_wGwGSF_VFEndcap_[7] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt)); + var_wGwGSF_VFEndcap_[8] = std::log(std::max(1.f, tauVars.pt)); + var_wGwGSF_VFEndcap_[9] = tauGammaMoms.signalPFGammaCandsIn; + var_wGwGSF_VFEndcap_[10] = tauGammaMoms.signalPFGammaCandsOut; + var_wGwGSF_VFEndcap_[11] = tauVars.visMassIn; + var_wGwGSF_VFEndcap_[12] = tauGammaMoms.gammaEtaMomIn; + var_wGwGSF_VFEndcap_[13] = tauGammaMoms.gammaEtaMomOut; + var_wGwGSF_VFEndcap_[14] = tauGammaMoms.gammaPhiMomIn; + var_wGwGSF_VFEndcap_[15] = tauGammaMoms.gammaPhiMomOut; + var_wGwGSF_VFEndcap_[16] = tauGammaMoms.gammaEnFracIn; + var_wGwGSF_VFEndcap_[17] = tauGammaMoms.gammaEnFracOut; + var_wGwGSF_VFEndcap_[18] = tauVars.dCrackEta; + var_wGwGSF_VFEndcap_[19] = tauVars.etaAtEcalEntrance; + var_wGwGSF_VFEndcap_[20] = tauVars.leadChargedPFCandEtaAtEcalEntrance; + var_wGwGSF_VFEndcap_[21] = elecVars.hgcalSigmaUU; + var_wGwGSF_VFEndcap_[22] = elecVars.hgcalSigmaVV; + var_wGwGSF_VFEndcap_[23] = elecVars.hgcalSigmaEE; + var_wGwGSF_VFEndcap_[24] = elecVars.hgcalSigmaPP; + var_wGwGSF_VFEndcap_[25] = elecVars.hgcalNLayers; + var_wGwGSF_VFEndcap_[26] = elecVars.hgcalLastLayer; + var_wGwGSF_VFEndcap_[27] = elecVars.hgcalLayerEfrac10; + var_wGwGSF_VFEndcap_[28] = elecVars.hgcalLayerEfrac90; + var_wGwGSF_VFEndcap_[29] = elecVars.hgcalEcEnergyEE; + var_wGwGSF_VFEndcap_[30] = elecVars.hgcalEcEnergyFH; + var_wGwGSF_VFEndcap_[31] = elecVars.hgcalMeasuredDepth; + var_wGwGSF_VFEndcap_[32] = elecVars.hgcalExpectedDepth; + var_wGwGSF_VFEndcap_[33] = elecVars.hgcalExpectedSigma; + var_wGwGSF_VFEndcap_[34] = elecVars.hgcalDepthCompatibility; + var_wGwGSF_VFEndcap_[35] = elecVars.deltaEta; + var_wGwGSF_VFEndcap_[36] = elecVars.deltaPhi; + var_wGwGSF_VFEndcap_[37] = elecVars.eSeedClusterOverPout; + var_wGwGSF_VFEndcap_[38] = elecVars.superClusterEtaWidth; + var_wGwGSF_VFEndcap_[39] = elecVars.superClusterPhiWidth; + mvaValue = mva_wGwGSF_VFEC_->GetClassifier(var_wGwGSF_VFEndcap_.data()); + } + } + return mvaValue; +} +//// template -double AntiElectronIDMVA6::MVAValue(const TauType& theTau, const ElectronType& theEle) +double AntiElectronIDMVA6::mvaValue(const TauType& theTau, const ElectronRef& theEleRef) { // === tau variables === @@ -422,13 +820,13 @@ double AntiElectronIDMVA6::MVAValue(const TauType& theTau TauGammaVecs tauGammaVecs = AntiElectronIDMVA6::getTauGammaVecs(theTau); // === electron variables === - ElecVars elecVars = AntiElectronIDMVA6::getElecVars(theEle); + ElecVars elecVars = AntiElectronIDMVA6::getElecVars(theEleRef); - return MVAValue(tauVars, tauGammaVecs, elecVars); + return mvaValue(tauVars, tauGammaVecs, elecVars); } template -double AntiElectronIDMVA6::MVAValue(const TauType& theTau) { +double AntiElectronIDMVA6::mvaValue(const TauType& theTau) { // === tau variables === TauVars tauVars = AntiElectronIDMVA6::getTauVars(theTau); TauGammaVecs tauGammaVecs = AntiElectronIDMVA6::getTauGammaVecs(theTau); @@ -437,7 +835,7 @@ double AntiElectronIDMVA6::MVAValue(const TauType& theTau ElecVars elecVars; elecVars.eta = 9.9; // Dummy value used in MVA training - return MVAValue(tauVars, tauGammaVecs, elecVars); + return mvaValue(tauVars, tauGammaVecs, elecVars); } template @@ -514,58 +912,81 @@ TauGammaVecs AntiElectronIDMVA6::getTauGammaVecs(const Ta } template -ElecVars AntiElectronIDMVA6::getElecVars(const ElectronType& theEle) { +ElecVars AntiElectronIDMVA6::getElecVars(const ElectronRef& theEleRef) { ElecVars elecVars; - elecVars.eta = theEle.eta(); - elecVars.phi = theEle.phi(); + elecVars.eta = theEleRef->eta(); + elecVars.phi = theEleRef->phi(); // Variables related to the electron Cluster float elecEe = 0.; float elecEgamma = 0.; - reco::SuperClusterRef pfSuperCluster = theEle.superCluster(); + reco::SuperClusterRef pfSuperCluster = theEleRef->superCluster(); if (pfSuperCluster.isNonnull() && pfSuperCluster.isAvailable()) { - for (reco::CaloCluster_iterator pfCluster = pfSuperCluster->clustersBegin(); - pfCluster != pfSuperCluster->clustersEnd(); - ++pfCluster) { - double pfClusterEn = (*pfCluster)->energy(); - if (pfCluster == pfSuperCluster->clustersBegin()) - elecEe += pfClusterEn; - else - elecEgamma += pfClusterEn; + if (!isPhase2_) { + for (reco::CaloCluster_iterator pfCluster = pfSuperCluster->clustersBegin(); + pfCluster != pfSuperCluster->clustersEnd(); + ++pfCluster) { + double pfClusterEn = (*pfCluster)->energy(); + if (pfCluster == pfSuperCluster->clustersBegin()) + elecEe += pfClusterEn; + else + elecEgamma += pfClusterEn; + } } + elecVars.superClusterEtaWidth = pfSuperCluster->etaWidth(); + elecVars.superClusterPhiWidth = pfSuperCluster->phiWidth(); } - - elecVars.pIn = std::sqrt(theEle.trackMomentumAtVtx().Mag2()); - elecVars.pOut = std::sqrt(theEle.trackMomentumOut().Mag2()); + elecVars.eSeedClusterOverPout = theEleRef->eSeedClusterOverPout(); + elecVars.showerCircularity = 1. - theEleRef->e1x5() / theEleRef->e5x5(); + elecVars.r9 = theEleRef->r9(); + elecVars.sigmaIEtaIEta5x5 = theEleRef->full5x5_sigmaIetaIeta(); + elecVars.sigmaIPhiIPhi5x5 = theEleRef->full5x5_sigmaIphiIphi(); + + elecVars.pIn = std::sqrt(theEleRef->trackMomentumAtVtx().Mag2()); + elecVars.pOut = std::sqrt(theEleRef->trackMomentumOut().Mag2()); elecVars.eTotOverPin = (elecVars.pIn > 0.0) ? ((elecEe + elecEgamma) / elecVars.pIn) : -0.1; - elecVars.eEcal = theEle.ecalEnergy(); - elecVars.deltaEta = theEle.deltaEtaSeedClusterTrackAtCalo(); - elecVars.deltaPhi = theEle.deltaPhiSeedClusterTrackAtCalo(); - elecVars.mvaInSigmaEtaEta = theEle.mvaInput().sigmaEtaEta; - elecVars.mvaInHadEnergy = theEle.mvaInput().hadEnergy; - elecVars.mvaInDeltaEta = theEle.mvaInput().deltaEta; + elecVars.eEcal = theEleRef->ecalEnergy(); + if (!isPhase2_) { + elecVars.deltaEta = theEleRef->deltaEtaSeedClusterTrackAtCalo(); + elecVars.deltaPhi = theEleRef->deltaPhiSeedClusterTrackAtCalo(); + } else { + elecVars.deltaEta = theEleRef->deltaEtaEleClusterTrackAtCalo(); + elecVars.deltaPhi = theEleRef->deltaPhiEleClusterTrackAtCalo(); + } + elecVars.mvaInSigmaEtaEta = theEleRef->mvaInput().sigmaEtaEta; + elecVars.mvaInHadEnergy = theEleRef->mvaInput().hadEnergy; + elecVars.mvaInDeltaEta = theEleRef->mvaInput().deltaEta; // Variables related to the GsfTrack elecVars.chi2NormGSF = -99.; elecVars.gsfNumHits = -99.; elecVars.gsfTrackResol = -99.; elecVars.gsfTracklnPt = -99.; - if (theEle.gsfTrack().isNonnull()) { - elecVars.chi2NormGSF = theEle.gsfTrack()->normalizedChi2(); - elecVars.gsfNumHits = theEle.gsfTrack()->numberOfValidHits(); - if (theEle.gsfTrack()->pt() > 0.) { - elecVars.gsfTrackResol = theEle.gsfTrack()->ptError() / theEle.gsfTrack()->pt(); - elecVars.gsfTracklnPt = log(theEle.gsfTrack()->pt()) * M_LN10; + if (theEleRef->gsfTrack().isNonnull()) { + elecVars.chi2NormGSF = theEleRef->gsfTrack()->normalizedChi2(); + elecVars.gsfNumHits = theEleRef->gsfTrack()->numberOfValidHits(); + if (theEleRef->gsfTrack()->pt() > 0.) { + elecVars.gsfTrackResol = theEleRef->gsfTrack()->ptError() / theEleRef->gsfTrack()->pt(); + elecVars.gsfTracklnPt = log(theEleRef->gsfTrack()->pt()) * M_LN10; } } // Variables related to the CtfTrack elecVars.chi2NormKF = -99.; elecVars.kfNumHits = -99.; - if (theEle.closestCtfTrackRef().isNonnull()) { - elecVars.chi2NormKF = theEle.closestCtfTrackRef()->normalizedChi2(); - elecVars.kfNumHits = theEle.closestCtfTrackRef()->numberOfValidHits(); + if (theEleRef->closestCtfTrackRef().isNonnull()) { + elecVars.chi2NormKF = theEleRef->closestCtfTrackRef()->normalizedChi2(); + elecVars.kfNumHits = theEleRef->closestCtfTrackRef()->numberOfValidHits(); + } + + // Variables related to HGCal + if (isPhase2_ && !theEleRef->isEB()) { + if (std::is_same::value || std::is_same::value) + getElecVarsHGCalTypeSpecific(theEleRef, elecVars); + else + throw cms::Exception("AntiElectronIDMVA6") + << "Unsupported ElectronType used. You must use either reco::GsfElectron or pat::Electron."; } return elecVars; @@ -675,26 +1096,38 @@ TauVars AntiElectronIDMVA6::getTauVarsTypeSpecific(const tauVars.leadChargedPFCandEtaAtEcalEntrance = theTau.etaAtEcalEntranceLeadChargedCand(); tauVars.leadChargedPFCandPt = theTau.ptLeadChargedCand(); tauVars.phi = theTau.phi(); - if (!usePhiAtEcalEntranceExtrapolation_) { - tauVars.phi = theTau.phiAtEcalEntrance(); + if (!isPhase2_) { + if (!usePhiAtEcalEntranceExtrapolation_) { + tauVars.phi = theTau.phiAtEcalEntrance(); + } else { + float etaAtECal = 0.; + float phiAtECal = 0.; + bool success = energyWeightedEtaAndPhiAtECal(theTau, etaAtECal, phiAtECal); + if (success) { + tauVars.phi = phiAtECal; + } + } + tauVars.emFraction = std::max(theTau.emFraction_MVA(), 0.f); } else { - float sumPhiTimesEnergy = 0.; - float sumEnergy = 0.; - for (const auto& candidate : theTau.signalCands()) { - float phiAtECalEntrance = candidate->phi(); + if (std::abs(theTau.eta()) >= ecalBarrelEndcapEtaBorder_) { //HGCal + tauVars.etaAtEcalEntrance = -99.; + tauVars.leadChargedPFCandEtaAtEcalEntrance = -99.; bool success = false; - reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success); + reco::Candidate::Point posAtECal = positionAtECalEntrance_(theTau.leadChargedHadrCand().get(), success); if (success) { - phiAtECalEntrance = posAtECal.phi(); + tauVars.leadChargedPFCandEtaAtEcalEntrance = posAtECal.eta(); + } + float phiAtECal = 0.; + float etaAtECal = 0.; + success = energyWeightedEtaAndPhiAtECal(theTau, etaAtECal, phiAtECal); + if (success) { + tauVars.etaAtEcalEntrance = etaAtECal; } - sumPhiTimesEnergy += phiAtECalEntrance * candidate->energy(); - sumEnergy += candidate->energy(); - } - if (sumEnergy > 0.) { - tauVars.phi = sumPhiTimesEnergy / sumEnergy; } + tauVars.emFraction = std::max(theTau.ecalEnergyLeadChargedHadrCand() / + (theTau.ecalEnergyLeadChargedHadrCand() + theTau.hcalEnergyLeadChargedHadrCand()), + 0.f); } - tauVars.emFraction = std::max(theTau.emFraction_MVA(), (float)0.); tauVars.leadPFChargedHadrHoP = 0.; tauVars.leadPFChargedHadrEoP = 0.; if (theTau.leadChargedHadrCand()->p() > 0.) { @@ -719,57 +1152,96 @@ TauVars AntiElectronIDMVA6::getTauVarsTypeSpecific(const // Check type of candidates building tau to avoid dynamic casts further bool isFromPFCands = (theTau.leadCand().isNonnull() && dynamic_cast(theTau.leadCand().get()) != nullptr); - for (const auto& candidate : theTau.signalCands()) { - float etaAtECalEntrance = candidate->eta(); - float phiAtECalEntrance = candidate->phi(); - const reco::Track* track = nullptr; - if (isFromPFCands) { - const reco::PFCandidate* pfCandidate = static_cast(candidate.get()); - etaAtECalEntrance = pfCandidate->positionAtECALEntrance().eta(); - if (!usePhiAtEcalEntranceExtrapolation_) { - phiAtECalEntrance = pfCandidate->positionAtECALEntrance().phi(); + if (!isPhase2_) { + for (const auto& candidate : theTau.signalCands()) { + float etaAtECalEntrance = candidate->eta(); + float phiAtECalEntrance = candidate->phi(); + const reco::Track* track = nullptr; + if (isFromPFCands) { + const reco::PFCandidate* pfCandidate = static_cast(candidate.get()); + etaAtECalEntrance = pfCandidate->positionAtECALEntrance().eta(); + if (!usePhiAtEcalEntranceExtrapolation_) { + phiAtECalEntrance = pfCandidate->positionAtECALEntrance().phi(); + } else { + bool success = false; + reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success); + if (success) { + phiAtECalEntrance = posAtECal.phi(); + } + } + track = getTrackFromPFCand(pfCandidate); } else { bool success = false; reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success); if (success) { + etaAtECalEntrance = posAtECal.eta(); phiAtECalEntrance = posAtECal.phi(); } + track = candidate->bestTrack(); } - if (pfCandidate->trackRef().isNonnull()) - track = pfCandidate->trackRef().get(); - else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->innerTrack().isNonnull()) - track = pfCandidate->muonRef()->innerTrack().get(); - else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->globalTrack().isNonnull()) - track = pfCandidate->muonRef()->globalTrack().get(); - else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->outerTrack().isNonnull()) - track = pfCandidate->muonRef()->outerTrack().get(); - else if (pfCandidate->gsfTrackRef().isNonnull()) - track = pfCandidate->gsfTrackRef().get(); - } else { - bool success = false; - reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success); - if (success) { - etaAtECalEntrance = posAtECal.eta(); - phiAtECalEntrance = posAtECal.phi(); + if (track != nullptr) { + if (track->pt() > tauVars.leadChargedPFCandPt) { + tauVars.leadChargedPFCandEtaAtEcalEntrance = etaAtECalEntrance; + tauVars.leadChargedPFCandPt = track->pt(); + } } - track = candidate->bestTrack(); + sumEtaTimesEnergy += etaAtECalEntrance * candidate->energy(); + sumPhiTimesEnergy += phiAtECalEntrance * candidate->energy(); + sumEnergy += candidate->energy(); + } + if (sumEnergy > 0.) { + tauVars.etaAtEcalEntrance = sumEtaTimesEnergy / sumEnergy; + tauVars.phi = sumPhiTimesEnergy / sumEnergy; } - if (track != nullptr) { - if (track->pt() > tauVars.leadChargedPFCandPt) { - tauVars.leadChargedPFCandEtaAtEcalEntrance = etaAtECalEntrance; - tauVars.leadChargedPFCandPt = track->pt(); + tauVars.emFraction = std::max(theTau.emFraction(), 0.f); + } else { // Phase2 + for (const auto& candidate : theTau.signalCands()) { + float etaAtECalEntrance = candidate->eta(); + const reco::Track* track = nullptr; + if (isFromPFCands) { + const reco::PFCandidate* pfCandidate = static_cast(candidate.get()); + etaAtECalEntrance = pfCandidate->positionAtECALEntrance().eta(); + if (std::abs(theTau.eta()) >= ecalBarrelEndcapEtaBorder_) { //HGCal + bool success = false; + reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success); + if (success) { + etaAtECalEntrance = posAtECal.eta(); + } + } + track = getTrackFromPFCand(pfCandidate); + } else { + bool success = false; + reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success); + if (success) { + etaAtECalEntrance = posAtECal.eta(); + } + track = candidate->bestTrack(); + } + if (track != nullptr) { + if (track->pt() > tauVars.leadChargedPFCandPt) { + tauVars.leadChargedPFCandEtaAtEcalEntrance = etaAtECalEntrance; + tauVars.leadChargedPFCandPt = track->pt(); + } + } + sumEtaTimesEnergy += etaAtECalEntrance * candidate->energy(); + sumEnergy += candidate->energy(); + } + if (sumEnergy > 0.) { + tauVars.etaAtEcalEntrance = sumEtaTimesEnergy / sumEnergy; + } + if (isFromPFCands) { + const reco::PFCandidate* pfLeadCandidte = + static_cast(theTau.leadChargedHadrCand().get()); + tauVars.emFraction = + std::max(pfLeadCandidte->ecalEnergy() / (pfLeadCandidte->ecalEnergy() + pfLeadCandidte->hcalEnergy()), 0.); + } else { + const pat::PackedCandidate* patLeadCandiate = + dynamic_cast(theTau.leadChargedHadrCand().get()); + if (patLeadCandiate != nullptr) { + tauVars.emFraction = std::max(1. - patLeadCandiate->hcalFraction(), 0.); } } - sumEtaTimesEnergy += etaAtECalEntrance * candidate->energy(); - sumPhiTimesEnergy += phiAtECalEntrance * candidate->energy(); - sumEnergy += candidate->energy(); - } - if (sumEnergy > 0.) { - tauVars.etaAtEcalEntrance = sumEtaTimesEnergy / sumEnergy; - tauVars.phi = sumPhiTimesEnergy / sumEnergy; } - - tauVars.emFraction = std::max(theTau.emFraction(), (float)0.); tauVars.leadPFChargedHadrHoP = 0.; tauVars.leadPFChargedHadrEoP = 0.; if (theTau.leadChargedHadrCand()->p() > 0.) { @@ -793,6 +1265,87 @@ TauVars AntiElectronIDMVA6::getTauVarsTypeSpecific(const return tauVars; } +// reco::GsfElectron +template +void AntiElectronIDMVA6::getElecVarsHGCalTypeSpecific( + const reco::GsfElectronRef& theEleRef, antiElecIDMVA6_blocks::ElecVars& elecVars) { + //MB: Assumed that presence of one of the HGCal EleID variables guarantee presence of all + if (!(electronIds_.find("hgcElectronID:sigmaUU") != electronIds_.end() && + electronIds_.at("hgcElectronID:sigmaUU").isValid())) + return; + + elecVars.hgcalSigmaUU = (*electronIds_.at("hgcElectronID:sigmaUU"))[theEleRef]; + elecVars.hgcalSigmaVV = (*electronIds_.at("hgcElectronID:sigmaVV"))[theEleRef]; + elecVars.hgcalSigmaEE = (*electronIds_.at("hgcElectronID:sigmaEE"))[theEleRef]; + elecVars.hgcalSigmaPP = (*electronIds_.at("hgcElectronID:sigmaPP"))[theEleRef]; + elecVars.hgcalNLayers = (*electronIds_.at("hgcElectronID:nLayers"))[theEleRef]; + elecVars.hgcalFirstLayer = (*electronIds_.at("hgcElectronID:firstLayer"))[theEleRef]; + elecVars.hgcalLastLayer = (*electronIds_.at("hgcElectronID:lastLayer"))[theEleRef]; + elecVars.hgcalLayerEfrac10 = (*electronIds_.at("hgcElectronID:layerEfrac10"))[theEleRef]; + elecVars.hgcalLayerEfrac90 = (*electronIds_.at("hgcElectronID:layerEfrac90"))[theEleRef]; + elecVars.hgcalEcEnergyEE = (*electronIds_.at("hgcElectronID:ecEnergyEE"))[theEleRef]; + elecVars.hgcalEcEnergyFH = (*electronIds_.at("hgcElectronID:ecEnergyFH"))[theEleRef]; + elecVars.hgcalMeasuredDepth = (*electronIds_.at("hgcElectronID:measuredDepth"))[theEleRef]; + elecVars.hgcalExpectedDepth = (*electronIds_.at("hgcElectronID:expectedDepth"))[theEleRef]; + elecVars.hgcalExpectedSigma = (*electronIds_.at("hgcElectronID:expectedSigma"))[theEleRef]; + elecVars.hgcalDepthCompatibility = (*electronIds_.at("hgcElectronID:depthCompatibility"))[theEleRef]; +} + +// pat::Electron +template +void AntiElectronIDMVA6::getElecVarsHGCalTypeSpecific( + const pat::ElectronRef& theEleRef, antiElecIDMVA6_blocks::ElecVars& elecVars) { + //MB: Assumed that presence of one of the HGCal EleID variables guarantee presence of all + if (!theEleRef->hasUserFloat("hgcElectronID:sigmaUU")) + return; + + elecVars.hgcalSigmaUU = theEleRef->userFloat("hgcElectronID:sigmaUU"); + elecVars.hgcalSigmaVV = theEleRef->userFloat("hgcElectronID:sigmaVV"); + elecVars.hgcalSigmaEE = theEleRef->userFloat("hgcElectronID:sigmaEE"); + elecVars.hgcalSigmaPP = theEleRef->userFloat("hgcElectronID:sigmaPP"); + elecVars.hgcalNLayers = theEleRef->userFloat("hgcElectronID:nLayers"); + elecVars.hgcalFirstLayer = theEleRef->userFloat("hgcElectronID:firstLayer"); + elecVars.hgcalLastLayer = theEleRef->userFloat("hgcElectronID:lastLayer"); + elecVars.hgcalLayerEfrac10 = theEleRef->userFloat("hgcElectronID:layerEfrac10"); + elecVars.hgcalLayerEfrac90 = theEleRef->userFloat("hgcElectronID:layerEfrac90"); + elecVars.hgcalEcEnergyEE = theEleRef->userFloat("hgcElectronID:ecEnergyEE"); + elecVars.hgcalEcEnergyFH = theEleRef->userFloat("hgcElectronID:ecEnergyFH"); + elecVars.hgcalMeasuredDepth = theEleRef->userFloat("hgcElectronID:measuredDepth"); + elecVars.hgcalExpectedDepth = theEleRef->userFloat("hgcElectronID:expectedDepth"); + elecVars.hgcalExpectedSigma = theEleRef->userFloat("hgcElectronID:expectedSigma"); + elecVars.hgcalDepthCompatibility = theEleRef->userFloat("hgcElectronID:depthCompatibility"); +} + +template +bool AntiElectronIDMVA6::energyWeightedEtaAndPhiAtECal(const pat::Tau& theTau, + float& eta, + float& phi) { + eta = 0.; + phi = 0.; + float sumEnergy = 0.; + for (const auto& candidate : theTau.signalCands()) { + float etaAtECalEntrance = candidate->eta(); + float phiAtECalEntrance = candidate->phi(); + bool success = false; + reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success); + if (success) { + etaAtECalEntrance = posAtECal.eta(); + phiAtECalEntrance = posAtECal.phi(); + } + eta += etaAtECalEntrance * candidate->energy(); + phi += phiAtECalEntrance * candidate->energy(); + sumEnergy += candidate->energy(); + } + if (sumEnergy > 0.) { + eta = eta / sumEnergy; + phi = phi / sumEnergy; + } else { + eta = -99.; + phi = -99.; + } + return (sumEnergy > 0.); +} + // compile desired types and make available to linker template class AntiElectronIDMVA6; template class AntiElectronIDMVA6; diff --git a/RecoTauTag/RecoTau/src/PositionAtECalEntranceComputer.cc b/RecoTauTag/RecoTau/src/PositionAtECalEntranceComputer.cc index 391ac598bb414..7b15c10d57427 100644 --- a/RecoTauTag/RecoTau/src/PositionAtECalEntranceComputer.cc +++ b/RecoTauTag/RecoTau/src/PositionAtECalEntranceComputer.cc @@ -2,23 +2,38 @@ #include "MagneticField/Engine/interface/MagneticField.h" #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" +#include "Geometry/CaloGeometry/interface/CaloGeometry.h" +#include "Geometry/Records/interface/CaloGeometryRecord.h" #include "CommonTools/BaseParticlePropagator/interface/BaseParticlePropagator.h" #include -PositionAtECalEntranceComputer::PositionAtECalEntranceComputer() : bField_z_(-1.) {} +PositionAtECalEntranceComputer::PositionAtECalEntranceComputer(edm::ConsumesCollector&& cc, bool isPhase2) + : bField_esToken_(cc.esConsumes()), + caloGeo_esToken_(cc.esConsumes()), + bField_z_(-1.), + isPhase2_(isPhase2) {} + +PositionAtECalEntranceComputer::PositionAtECalEntranceComputer(edm::ConsumesCollector& cc, bool isPhase2) + : bField_esToken_(cc.esConsumes()), + caloGeo_esToken_(cc.esConsumes()), + bField_z_(-1.), + isPhase2_(isPhase2) {} PositionAtECalEntranceComputer::~PositionAtECalEntranceComputer() {} void PositionAtECalEntranceComputer::beginEvent(const edm::EventSetup& es) { - edm::ESHandle bField; - es.get().get(bField); - bField_z_ = bField->inTesla(GlobalPoint(0., 0., 0.)).z(); + bField_z_ = es.getData(bField_esToken_).inTesla(GlobalPoint(0., 0., 0.)).z(); + if (isPhase2_) { + recHitTools_.setGeometry(es.getData(caloGeo_esToken_)); + hgcalFace_z_ = recHitTools_.getPositionLayer(1).z(); // HGCal 1st layer + } } reco::Candidate::Point PositionAtECalEntranceComputer::operator()(const reco::Candidate* particle, bool& success) const { assert(bField_z_ != -1.); + reco::Candidate::Point position; BaseParticlePropagator propagator = BaseParticlePropagator( RawParticle(particle->p4(), math::XYZTLorentzVector(particle->vertex().x(), particle->vertex().y(), particle->vertex().z(), 0.), @@ -26,11 +41,19 @@ reco::Candidate::Point PositionAtECalEntranceComputer::operator()(const reco::Ca 0., 0., bField_z_); - propagator.propagateToEcalEntrance(false); - reco::Candidate::Point position; + if (!isPhase2_ || std::abs(particle->eta()) < ecalBarrelEndcapEtaBorder_) { // ECal + propagator.propagateToEcalEntrance(false); + } else { // HGCal + if (std::abs(particle->vertex().z()) >= hgcalFace_z_) { + success = false; + return position; + } + propagator.setPropagationConditions(152.6, hgcalFace_z_, false); + propagator.propagate(); + } if (propagator.getSuccess() != 0) { position = propagator.particle().vertex().Vect(); - success = true; + success = (std::abs(position.eta()) <= hgcalHfEtaBorder_); } else { success = false; }