CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | Static Private Member Functions | Private Attributes
DeepTauId Class Reference
Inheritance diagram for DeepTauId:
deep_tau::DeepTauBase edm::stream::EDProducer< edm::GlobalCache< DeepTauCache > >

Public Member Functions

 DeepTauId (const edm::ParameterSet &cfg, const deep_tau::DeepTauCache *cache)
 
- Public Member Functions inherited from deep_tau::DeepTauBase
 DeepTauBase (const edm::ParameterSet &cfg, const OutputCollection &outputs, const DeepTauCache *cache)
 
void produce (edm::Event &event, const edm::EventSetup &es) override
 
 ~DeepTauBase () override
 
- Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DeepTauCache > >
 EDProducer ()=default
 
bool hasAbilityToProduceInLumis () const final
 
bool hasAbilityToProduceInRuns () const final
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 
static const OutputCollection & GetOutputs ()
 
static void globalEndJob (const deep_tau::DeepTauCache *cache_)
 
static std::unique_ptr< deep_tau::DeepTauCache > initializeGlobalCache (const edm::ParameterSet &cfg)
 
- Static Public Member Functions inherited from deep_tau::DeepTauBase
static void globalEndJob (const DeepTauCache *cache)
 
static std::unique_ptr< DeepTauCache > initializeGlobalCache (const edm::ParameterSet &cfg)
 

Static Public Attributes

static float default_value = -999.
 

Private Member Functions

template<typename dnn >
tensorflow::Tensor createInputs (const TauType &tau, const ElectronCollection &electrons, const MuonCollection &muons) const
 
tensorflow::Tensor getPredictions (edm::Event &event, const edm::EventSetup &es, edm::Handle< TauCollection > taus) override
 

Static Private Member Functions

static void calculateElectronClusterVars (const pat::Electron *ele, float &elecEe, float &elecEgamma)
 
static float calculateGottfriedJacksonAngleDifference (const pat::Tau &tau)
 
static const pat::Electron * findMatchedElectron (const pat::Tau &tau, const pat::ElectronCollection &electrons, double deltaR)
 
static double getInnerSignalConeRadius (double pt)
 
static bool isInEcalCrack (double eta)
 
template<typename CandidateCollection >
static void processIsolationPFComponents (const pat::Tau &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4, float &pt, float &d_eta, float &d_phi, float &m, float &n)
 
template<typename CandidateCollection >
static void processSignalPFComponents (const pat::Tau &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4_inner, LorentzVectorXYZ &p4_outer, float &pt_inner, float &dEta_inner, float &dPhi_inner, float &m_inner, float &pt_outer, float &dEta_outer, float &dPhi_outer, float &m_outer, float &n_inner, float &n_outer)
 

Private Attributes

edm::EDGetTokenT< ElectronCollection > electrons_token
 
std::string input_layer
 
edm::EDGetTokenT< MuonCollection > muons_token
 
std::string output_layer
 

Additional Inherited Members

- Public Types inherited from deep_tau::DeepTauBase
using Cutter = TauWPThreshold
 
using CutterPtr = std::unique_ptr< Cutter >
 
using ElectronCollection = pat::ElectronCollection
 
using LorentzVectorXYZ = ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double >>
 
using MuonCollection = pat::MuonCollection
 
using OutputCollection = std::map< std::string, Output >
 
using TauCollection = std::vector< TauType >
 
using TauDiscriminator = pat::PATTauDiscriminator
 
using TauRef = edm::Ref< TauCollection >
 
using TauRefProd = edm::RefProd< TauCollection >
 
using TauType = pat::Tau
 
using WPMap = std::map< std::string, CutterPtr >
 
- Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DeepTauCache > >
typedef CacheContexts< T... > CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T... > HasAbility
 
typedef CacheTypes::LuminosityBlockCache LuminosityBlockCache
 
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache > LuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCache > RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 
- Protected Attributes inherited from deep_tau::DeepTauBase
const DeepTauCache * cache_
 
OutputCollection outputs_
 
edm::EDGetTokenT< TauCollection > tausToken_
 
std::map< std::string, WPMap > workingPoints_
 

Detailed Description

Definition at line 230 of file DeepTauId.cc.

Constructor & Destructor Documentation

DeepTauId::DeepTauId ( const edm::ParameterSet &  cfg,
const deep_tau::DeepTauCache *  cache 
)
inlineexplicit

Definition at line 272 of file DeepTauId.cc.

272  :
273  DeepTauBase(cfg, GetOutputs(), cache),
274  electrons_token(consumes<ElectronCollection>(cfg.getParameter<edm::InputTag>("electrons"))),
275  muons_token(consumes<MuonCollection>(cfg.getParameter<edm::InputTag>("muons"))),
276  input_layer(cache_->getGraph().node(0).name()),
277  output_layer(cache_->getGraph().node(cache_->getGraph().node_size() - 1).name())
278  {
279  const auto& shape = cache_->getGraph().node(0).attr().at("shape").shape();
280  if(shape.dim(1).size() != dnn_inputs_2017v1::NumberOfInputs)
281  throw cms::Exception("DeepTauId") << "number of inputs does not match the expected inputs for the given version";
282 
283  }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
deep_tau::DeepTauCache::getGraph
const tensorflow::GraphDef & getGraph() const
Definition: DeepTauBase.h:50
deep_tau::DeepTauBase::cache_
const DeepTauCache * cache_
Definition: DeepTauBase.h:101
DeepTauId::electrons_token
edm::EDGetTokenT< ElectronCollection > electrons_token
Definition: DeepTauId.cc:632
DeepTauId::GetOutputs
static const OutputCollection & GetOutputs()
Definition: DeepTauId.cc:235
deep_tau::DeepTauBase::DeepTauBase
DeepTauBase(const edm::ParameterSet &cfg, const OutputCollection &outputs, const DeepTauCache *cache)
Definition: DeepTauBase.cc:79
DeepTauId::input_layer
std::string input_layer
Definition: DeepTauId.cc:634
DeepTauId::muons_token
edm::EDGetTokenT< MuonCollection > muons_token
Definition: DeepTauId.cc:633
DeepTauId::output_layer
std::string output_layer
Definition: DeepTauId.cc:634

Member Function Documentation

static void DeepTauId::calculateElectronClusterVars ( const pat::Electron *  ele,
float &  elecEe,
float &  elecEgamma 
)
inlinestaticprivate

Definition at line 513 of file DeepTauId.cc.

References pat::Electron::superCluster().

514  {
515  if(ele) {
516  elecEe = elecEgamma = 0;
517  auto superCluster = ele->superCluster();
518  if(superCluster.isNonnull() && superCluster.isAvailable() && superCluster->clusters().isNonnull()
519  && superCluster->clusters().isAvailable()) {
520  for(auto iter = superCluster->clustersBegin(); iter != superCluster->clustersEnd(); ++iter) {
521  const double energy = (*iter)->energy();
522  if(iter == superCluster->clustersBegin()) elecEe += energy;
523  else elecEgamma += energy;
524  }
525  }
526  } else {
527  elecEe = elecEgamma = default_value;
528  }
529  }
DeepTauId::default_value
static float default_value
Definition: DeepTauId.cc:233
pat::Electron::superCluster
reco::SuperClusterRef superCluster() const override
override the reco::GsfElectron::superCluster method, to access the internal storage of the superclust...
static float DeepTauId::calculateGottfriedJacksonAngleDifference ( const pat::Tau &  tau)
inlinestaticprivate

Definition at line 594 of file DeepTauId.cc.

References funct::abs(), constexpr, pat::Tau::decayMode(), pat::Tau::flightLength(), reco::LeafCandidate::p(), reco::LeafCandidate::p4(), and funct::pow().

595  {
596  if(tau.decayMode() == 10) {
597  static constexpr double mTau = 1.77682;
598  const double mAOne = tau.p4().M();
599  const double pAOneMag = tau.p();
600  const double argumentThetaGJmax = (std::pow(mTau,2) - std::pow(mAOne,2) ) / ( 2 * mTau * pAOneMag );
601  const double argumentThetaGJmeasured = tau.p4().Vect().Dot(tau.flightLength())
602  / ( pAOneMag * tau.flightLength().R() );
603  if ( std::abs(argumentThetaGJmax) <= 1. && std::abs(argumentThetaGJmeasured) <= 1. ) {
604  double thetaGJmax = std::asin( argumentThetaGJmax );
605  double thetaGJmeasured = std::acos( argumentThetaGJmeasured );
606  return thetaGJmeasured - thetaGJmax;
607  }
608  }
609  return default_value;
610  }
constexpr
#define constexpr
pat::Tau::flightLength
const pat::tau::TauPFEssential::Vector & flightLength() const
Definition: Tau.h:321
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
reco::LeafCandidate::p4
const LorentzVector & p4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:99
reco::LeafCandidate::p
double p() const final
magnitude of momentum vector
Definition: LeafCandidate.h:108
pat::Tau::decayMode
int decayMode() const
reconstructed tau decay mode (specific to PFTau)
Definition: Tau.h:365
DeepTauId::default_value
static float default_value
Definition: DeepTauId.cc:233
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
template<typename dnn >
tensorflow::Tensor DeepTauId::createInputs ( const TauType &  tau,
const ElectronCollection &  electrons,
const MuonCollection &  muons 
) const
inlineprivate

Definition at line 318 of file DeepTauId.cc.

References funct::abs(), tauProducer_cfi::chargedIsoPtSum, constexpr, taus_cff::decayMode, pat::Tau::decayMode(), particleFlow_cfi::dEta, particleFlow_cfi::dPhi, PVValHelper::dxy, pat::Tau::dxy(), pat::Tau::dxy_Sig(), PVValHelper::dz, pat::Tau::ecalEnergyLeadChargedHadrCand(), pat::Tau::emFraction_MVA(), PVValHelper::eta, pat::Tau::etaAtEcalEntranceLeadChargedCand(), Exception, pat::Tau::flightLength(), pat::Tau::flightLengthSig(), edm::Ptr< T >::get(), pat::Tau::hasSecondaryVertex(), pat::Tau::hcalEnergyLeadChargedHadrCand(), PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, electrons_cff::ip3d, pat::Tau::ip3d(), pat::Tau::ip3d_Sig(), edm::Ptr< T >::isNonnull(), pat::Tau::leadChargedHadrCand(), pat::Tau::leadingTrackNormChi2(), pat::Tau::leadPFChargedHadrCand(), ResonanceBuilder::mass, tauProducer_cfi::neutralIsoPtSum, tauProducer_cfi::neutralIsoPtSumWeight, reco::LeafCandidate::p4(), tauProducer_cfi::photonPtSumOutsideSignalCone, EnergyCorrector::pt, pat::Tau::ptLeadChargedCand(), tauProducer_cfi::puCorrPtSum, metsig::tau, TauIdMVAAuxiliaries::tau_Eratio(), TauIdMVAAuxiliaries::tau_n_photons_total(), TauIdMVAAuxiliaries::tau_pt_weighted_deta_strip(), TauIdMVAAuxiliaries::tau_pt_weighted_dphi_strip(), TauIdMVAAuxiliaries::tau_pt_weighted_dr_iso(), TauIdMVAAuxiliaries::tau_pt_weighted_dr_signal(), and pat::Tau::tauID().

320  {
321  static constexpr bool check_all_set = false;
322  static constexpr float default_value_for_set_check = -42;
323  static const TauIdMVAAuxiliaries clusterVariables;
324 
325  tensorflow::Tensor inputs(tensorflow::DT_FLOAT, { 1, dnn_inputs_2017v1::NumberOfInputs});
326  const auto& get = [&](int var_index) -> float& { return inputs.matrix<float>()(0, var_index); };
327  auto leadChargedHadrCand = dynamic_cast<const pat::PackedCandidate*>(tau.leadChargedHadrCand().get());
328 
329  if(check_all_set) {
330  for(int var_index = 0; var_index < dnn::NumberOfInputs; ++var_index) {
331  get(var_index) = default_value_for_set_check;
332  }
333  }
334 
335  get(dnn::pt) = tau.p4().pt();
336  get(dnn::eta) = tau.p4().eta();
337  get(dnn::mass) = tau.p4().mass();
338  get(dnn::decayMode) = tau.decayMode();
339  get(dnn::chargedIsoPtSum) = tau.tauID("chargedIsoPtSum");
340  get(dnn::neutralIsoPtSum) = tau.tauID("neutralIsoPtSum");
341  get(dnn::neutralIsoPtSumWeight) = tau.tauID("neutralIsoPtSumWeight");
342  get(dnn::photonPtSumOutsideSignalCone) = tau.tauID("photonPtSumOutsideSignalCone");
343  get(dnn::puCorrPtSum) = tau.tauID("puCorrPtSum");
344  get(dnn::dxy) = tau.dxy();
345  get(dnn::dxy_sig) = tau.dxy_Sig();
346  get(dnn::dz) = leadChargedHadrCand ? leadChargedHadrCand->dz() : default_value;
347  get(dnn::ip3d) = tau.ip3d();
348  get(dnn::ip3d_sig) = tau.ip3d_Sig();
349  get(dnn::hasSecondaryVertex) = tau.hasSecondaryVertex();
350  get(dnn::flightLength_r) = tau.flightLength().R();
351  get(dnn::flightLength_dEta) = dEta(tau.flightLength(), tau.p4());
352  get(dnn::flightLength_dPhi) = dPhi(tau.flightLength(), tau.p4());
353  get(dnn::flightLength_sig) = tau.flightLengthSig();
354  get(dnn::leadChargedHadrCand_pt) = leadChargedHadrCand ? leadChargedHadrCand->p4().Pt() : default_value;
355  get(dnn::leadChargedHadrCand_dEta) = leadChargedHadrCand
356  ? dEta(leadChargedHadrCand->p4(), tau.p4()) : default_value;
357  get(dnn::leadChargedHadrCand_dPhi) = leadChargedHadrCand
358  ? dPhi(leadChargedHadrCand->p4(), tau.p4()) : default_value;
359  get(dnn::leadChargedHadrCand_mass) = leadChargedHadrCand
360  ? leadChargedHadrCand->p4().mass() : default_value;
361  get(dnn::pt_weighted_deta_strip) = clusterVariables.tau_pt_weighted_deta_strip(tau, tau.decayMode());
362  get(dnn::pt_weighted_dphi_strip) = clusterVariables.tau_pt_weighted_dphi_strip(tau, tau.decayMode());
363  get(dnn::pt_weighted_dr_signal) = clusterVariables.tau_pt_weighted_dr_signal(tau, tau.decayMode());
364  get(dnn::pt_weighted_dr_iso) = clusterVariables.tau_pt_weighted_dr_iso(tau, tau.decayMode());
365  get(dnn::leadingTrackNormChi2) = tau.leadingTrackNormChi2();
366  get(dnn::e_ratio) = clusterVariables.tau_Eratio(tau);
367  get(dnn::gj_angle_diff) = calculateGottfriedJacksonAngleDifference(tau);
368  get(dnn::n_photons) = clusterVariables.tau_n_photons_total(tau);
369  get(dnn::emFraction) = tau.emFraction_MVA();
370  get(dnn::has_gsf_track) = leadChargedHadrCand && std::abs(leadChargedHadrCand->pdgId()) == 11;
371  get(dnn::inside_ecal_crack) = isInEcalCrack(tau.p4().Eta());
372  auto gsf_ele = findMatchedElectron(tau, electrons, 0.3);
373  get(dnn::gsf_ele_matched) = gsf_ele != nullptr;
374  get(dnn::gsf_ele_pt) = gsf_ele != nullptr ? gsf_ele->p4().Pt() : default_value;
375  get(dnn::gsf_ele_dEta) = gsf_ele != nullptr ? dEta(gsf_ele->p4(), tau.p4()) : default_value;
376  get(dnn::gsf_ele_dPhi) = gsf_ele != nullptr ? dPhi(gsf_ele->p4(), tau.p4()) : default_value;
377  get(dnn::gsf_ele_mass) = gsf_ele != nullptr ? gsf_ele->p4().mass() : default_value;
378  calculateElectronClusterVars(gsf_ele, get(dnn::gsf_ele_Ee), get(dnn::gsf_ele_Egamma));
379  get(dnn::gsf_ele_Pin) = gsf_ele != nullptr ? gsf_ele->trackMomentumAtVtx().R() : default_value;
380  get(dnn::gsf_ele_Pout) = gsf_ele != nullptr ? gsf_ele->trackMomentumOut().R() : default_value;
381  get(dnn::gsf_ele_EtotOverPin) = get(dnn::gsf_ele_Pin) > 0
382  ? (get(dnn::gsf_ele_Ee) + get(dnn::gsf_ele_Egamma)) / get(dnn::gsf_ele_Pin)
383  : default_value;
384  get(dnn::gsf_ele_Eecal) = gsf_ele != nullptr ? gsf_ele->ecalEnergy() : default_value;
385  get(dnn::gsf_ele_dEta_SeedClusterTrackAtCalo) = gsf_ele != nullptr
386  ? gsf_ele->deltaEtaSeedClusterTrackAtCalo() : default_value;
387  get(dnn::gsf_ele_dPhi_SeedClusterTrackAtCalo) = gsf_ele != nullptr
388  ? gsf_ele->deltaPhiSeedClusterTrackAtCalo() : default_value;
389  get(dnn::gsf_ele_mvaIn_sigmaEtaEta) = gsf_ele != nullptr
390  ? gsf_ele->mvaInput().sigmaEtaEta : default_value;
391  get(dnn::gsf_ele_mvaIn_hadEnergy) = gsf_ele != nullptr ? gsf_ele->mvaInput().hadEnergy : default_value;
392  get(dnn::gsf_ele_mvaIn_deltaEta) = gsf_ele != nullptr ? gsf_ele->mvaInput().deltaEta : default_value;
393 
394  get(dnn::gsf_ele_Chi2NormGSF) = default_value;
395  get(dnn::gsf_ele_GSFNumHits) = default_value;
396  get(dnn::gsf_ele_GSFTrackResol) = default_value;
397  get(dnn::gsf_ele_GSFTracklnPt) = default_value;
398  if(gsf_ele != nullptr && gsf_ele->gsfTrack().isNonnull()) {
399  get(dnn::gsf_ele_Chi2NormGSF) = gsf_ele->gsfTrack()->normalizedChi2();
400  get(dnn::gsf_ele_GSFNumHits) = gsf_ele->gsfTrack()->numberOfValidHits();
401  if(gsf_ele->gsfTrack()->pt() > 0) {
402  get(dnn::gsf_ele_GSFTrackResol) = gsf_ele->gsfTrack()->ptError() / gsf_ele->gsfTrack()->pt();
403  get(dnn::gsf_ele_GSFTracklnPt) = std::log10(gsf_ele->gsfTrack()->pt());
404  }
405  }
406 
407  get(dnn::gsf_ele_Chi2NormKF) = default_value;
408  get(dnn::gsf_ele_KFNumHits) = default_value;
409  if(gsf_ele != nullptr && gsf_ele->closestCtfTrackRef().isNonnull()) {
410  get(dnn::gsf_ele_Chi2NormKF) = gsf_ele->closestCtfTrackRef()->normalizedChi2();
411  get(dnn::gsf_ele_KFNumHits) = gsf_ele->closestCtfTrackRef()->numberOfValidHits();
412  }
413  get(dnn::leadChargedCand_etaAtEcalEntrance) = tau.etaAtEcalEntranceLeadChargedCand();
414  get(dnn::leadChargedCand_pt) = tau.ptLeadChargedCand();
415 
416  get(dnn::leadChargedHadrCand_HoP) = default_value;
417  get(dnn::leadChargedHadrCand_EoP) = default_value;
418  if(tau.leadChargedHadrCand()->pt() > 0) {
419  get(dnn::leadChargedHadrCand_HoP) = tau.hcalEnergyLeadChargedHadrCand()
420  / tau.leadChargedHadrCand()->pt();
421  get(dnn::leadChargedHadrCand_EoP) = tau.ecalEnergyLeadChargedHadrCand()
422  / tau.leadChargedHadrCand()->pt();
423  }
424 
425  MuonHitMatch muon_hit_match;
426  if(tau.leadPFChargedHadrCand().isNonnull() && tau.leadPFChargedHadrCand()->muonRef().isNonnull())
427  muon_hit_match.addMatchedMuon(*tau.leadPFChargedHadrCand()->muonRef(), tau);
428 
429  auto matched_muons = muon_hit_match.findMatchedMuons(tau, muons, 0.3, 5);
430  for(auto muon : matched_muons)
431  muon_hit_match.addMatchedMuon(*muon, tau);
432  muon_hit_match.fillTensor<dnn>(get, tau, default_value);
433 
434  LorentzVectorXYZ signalChargedHadrCands_sumIn, signalChargedHadrCands_sumOut;
435  processSignalPFComponents(tau, tau.signalChargedHadrCands(),
436  signalChargedHadrCands_sumIn, signalChargedHadrCands_sumOut,
437  get(dnn::signalChargedHadrCands_sum_innerSigCone_pt),
438  get(dnn::signalChargedHadrCands_sum_innerSigCone_dEta),
439  get(dnn::signalChargedHadrCands_sum_innerSigCone_dPhi),
440  get(dnn::signalChargedHadrCands_sum_innerSigCone_mass),
441  get(dnn::signalChargedHadrCands_sum_outerSigCone_pt),
442  get(dnn::signalChargedHadrCands_sum_outerSigCone_dEta),
443  get(dnn::signalChargedHadrCands_sum_outerSigCone_dPhi),
444  get(dnn::signalChargedHadrCands_sum_outerSigCone_mass),
445  get(dnn::signalChargedHadrCands_nTotal_innerSigCone),
446  get(dnn::signalChargedHadrCands_nTotal_outerSigCone));
447 
448  LorentzVectorXYZ signalNeutrHadrCands_sumIn, signalNeutrHadrCands_sumOut;
449  processSignalPFComponents(tau, tau.signalNeutrHadrCands(),
450  signalNeutrHadrCands_sumIn, signalNeutrHadrCands_sumOut,
451  get(dnn::signalNeutrHadrCands_sum_innerSigCone_pt),
452  get(dnn::signalNeutrHadrCands_sum_innerSigCone_dEta),
453  get(dnn::signalNeutrHadrCands_sum_innerSigCone_dPhi),
454  get(dnn::signalNeutrHadrCands_sum_innerSigCone_mass),
455  get(dnn::signalNeutrHadrCands_sum_outerSigCone_pt),
456  get(dnn::signalNeutrHadrCands_sum_outerSigCone_dEta),
457  get(dnn::signalNeutrHadrCands_sum_outerSigCone_dPhi),
458  get(dnn::signalNeutrHadrCands_sum_outerSigCone_mass),
459  get(dnn::signalNeutrHadrCands_nTotal_innerSigCone),
460  get(dnn::signalNeutrHadrCands_nTotal_outerSigCone));
461 
462 
463  LorentzVectorXYZ signalGammaCands_sumIn, signalGammaCands_sumOut;
464  processSignalPFComponents(tau, tau.signalGammaCands(),
465  signalGammaCands_sumIn, signalGammaCands_sumOut,
466  get(dnn::signalGammaCands_sum_innerSigCone_pt),
467  get(dnn::signalGammaCands_sum_innerSigCone_dEta),
468  get(dnn::signalGammaCands_sum_innerSigCone_dPhi),
469  get(dnn::signalGammaCands_sum_innerSigCone_mass),
470  get(dnn::signalGammaCands_sum_outerSigCone_pt),
471  get(dnn::signalGammaCands_sum_outerSigCone_dEta),
472  get(dnn::signalGammaCands_sum_outerSigCone_dPhi),
473  get(dnn::signalGammaCands_sum_outerSigCone_mass),
474  get(dnn::signalGammaCands_nTotal_innerSigCone),
475  get(dnn::signalGammaCands_nTotal_outerSigCone));
476 
477  LorentzVectorXYZ isolationChargedHadrCands_sum;
478  processIsolationPFComponents(tau, tau.isolationChargedHadrCands(), isolationChargedHadrCands_sum,
479  get(dnn::isolationChargedHadrCands_sum_pt),
480  get(dnn::isolationChargedHadrCands_sum_dEta),
481  get(dnn::isolationChargedHadrCands_sum_dPhi),
482  get(dnn::isolationChargedHadrCands_sum_mass),
483  get(dnn::isolationChargedHadrCands_nTotal));
484 
485  LorentzVectorXYZ isolationNeutrHadrCands_sum;
486  processIsolationPFComponents(tau, tau.isolationNeutrHadrCands(), isolationNeutrHadrCands_sum,
487  get(dnn::isolationNeutrHadrCands_sum_pt),
488  get(dnn::isolationNeutrHadrCands_sum_dEta),
489  get(dnn::isolationNeutrHadrCands_sum_dPhi),
490  get(dnn::isolationNeutrHadrCands_sum_mass),
491  get(dnn::isolationNeutrHadrCands_nTotal));
492 
493  LorentzVectorXYZ isolationGammaCands_sum;
494  processIsolationPFComponents(tau, tau.isolationGammaCands(), isolationGammaCands_sum,
495  get(dnn::isolationGammaCands_sum_pt),
496  get(dnn::isolationGammaCands_sum_dEta),
497  get(dnn::isolationGammaCands_sum_dPhi),
498  get(dnn::isolationGammaCands_sum_mass),
499  get(dnn::isolationGammaCands_nTotal));
500 
501  get(dnn::tau_visMass_innerSigCone) = (signalGammaCands_sumIn + signalChargedHadrCands_sumIn).mass();
502 
503  if(check_all_set) {
504  for(int var_index = 0; var_index < dnn::NumberOfInputs; ++var_index) {
505  if(get(var_index) == default_value_for_set_check)
506  throw cms::Exception("DeepTauId: variable with index = ") << var_index << " is not set.";
507  }
508  }
509 
510  return inputs;
511  }
tauProducer_cfi.puCorrPtSum
puCorrPtSum
Definition: tauProducer_cfi.py:70
nano_cff.electrons
electrons
Definition: nano_cff.py:36
TauIdMVAAuxiliaries::tau_Eratio
float tau_Eratio(const reco::PFTau &tau) const
return ratio of energy in ECAL over sum of energy in ECAL and HCAL
Definition: PFRecoTauClusterVariables.h:35
taus_cff.decayMode
decayMode
Definition: taus_cff.py:54
DeepTauId::isInEcalCrack
static bool isInEcalCrack(double eta)
Definition: DeepTauId.cc:612
DeepTauId::processIsolationPFComponents
static void processIsolationPFComponents(const pat::Tau &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4, float &pt, float &d_eta, float &d_phi, float &m, float &n)
Definition: DeepTauId.cc:568
PatBasicFWLiteJetAnalyzer_Selector_cfg.inputs
inputs
Definition: PatBasicFWLiteJetAnalyzer_Selector_cfg.py:40
electrons_cff.ip3d
ip3d
Definition: electrons_cff.py:309
constexpr
#define constexpr
DeepTauId::calculateGottfriedJacksonAngleDifference
static float calculateGottfriedJacksonAngleDifference(const pat::Tau &tau)
Definition: DeepTauId.cc:594
TauIdMVAAuxiliaries::tau_pt_weighted_dphi_strip
float tau_pt_weighted_dphi_strip(const reco::PFTau &tau, int dm) const
Definition: PFRecoTauClusterVariables.h:168
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
extraflags_cff.muons
muons
Definition: extraflags_cff.py:17
TauIdMVAAuxiliaries::tau_pt_weighted_dr_signal
float tau_pt_weighted_dr_signal(const reco::PFTau &tau, int dm) const
Definition: PFRecoTauClusterVariables.h:152
TauIdMVAAuxiliaries::tau_pt_weighted_dr_iso
float tau_pt_weighted_dr_iso(const reco::PFTau &tau, int dm) const
Definition: PFRecoTauClusterVariables.h:176
tauProducer_cfi.photonPtSumOutsideSignalCone
photonPtSumOutsideSignalCone
Definition: tauProducer_cfi.py:73
tauProducer_cfi.chargedIsoPtSum
chargedIsoPtSum
Definition: tauProducer_cfi.py:68
tauProducer_cfi.neutralIsoPtSum
neutralIsoPtSum
Definition: tauProducer_cfi.py:69
TauIdMVAAuxiliaries::tau_pt_weighted_deta_strip
float tau_pt_weighted_deta_strip(const reco::PFTau &tau, int dm) const
Definition: PFRecoTauClusterVariables.h:160
DeepTauId::processSignalPFComponents
static void processSignalPFComponents(const pat::Tau &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4_inner, LorentzVectorXYZ &p4_outer, float &pt_inner, float &dEta_inner, float &dPhi_inner, float &m_inner, float &pt_outer, float &dEta_outer, float &dPhi_outer, float &m_outer, float &n_inner, float &n_outer)
Definition: DeepTauId.cc:532
particleFlow_cfi.dPhi
dPhi
Definition: particleFlow_cfi.py:78
DeepTauId::findMatchedElectron
static const pat::Electron * findMatchedElectron(const pat::Tau &tau, const pat::ElectronCollection &electrons, double deltaR)
Definition: DeepTauId.cc:618
DeepTauId::default_value
static float default_value
Definition: DeepTauId.cc:233
particleFlow_cfi.dEta
dEta
Definition: particleFlow_cfi.py:77
DeepTauId::calculateElectronClusterVars
static void calculateElectronClusterVars(const pat::Electron *ele, float &elecEe, float &elecEgamma)
Definition: DeepTauId.cc:513
deep_tau::DeepTauBase::LorentzVectorXYZ
ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double >> LorentzVectorXYZ
Definition: DeepTauBase.h:67
tauProducer_cfi.neutralIsoPtSumWeight
neutralIsoPtSumWeight
Definition: tauProducer_cfi.py:71
TauIdMVAAuxiliaries::tau_n_photons_total
unsigned int tau_n_photons_total(const reco::PFTau &tau) const
return total number of pf photon candidates with pT>500 MeV, which are associated to signal ...
Definition: PFRecoTauClusterVariables.h:183
static void DeepTauId::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions)
inlinestatic

Definition at line 246 of file DeepTauId.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and AlCaHLTBitMon_QueryRunRegistry::string.

247  {
248  edm::ParameterSetDescription desc;
249  desc.add<edm::InputTag>("electrons", edm::InputTag("slimmedElectrons"));
250  desc.add<edm::InputTag>("muons", edm::InputTag("slimmedMuons"));
251  desc.add<edm::InputTag>("taus", edm::InputTag("slimmedTaus"));
252  desc.add<std::string>("graph_file", "RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v1_20L1024N_quantized.pb");
253  desc.add<bool>("mem_mapped", false);
254 
255  edm::ParameterSetDescription descWP;
256  descWP.add<std::string>("VVVLoose", "0");
257  descWP.add<std::string>("VVLoose", "0");
258  descWP.add<std::string>("VLoose", "0");
259  descWP.add<std::string>("Loose", "0");
260  descWP.add<std::string>("Medium", "0");
261  descWP.add<std::string>("Tight", "0");
262  descWP.add<std::string>("VTight", "0");
263  descWP.add<std::string>("VVTight", "0");
264  descWP.add<std::string>("VVVTight", "0");
265  desc.add<edm::ParameterSetDescription>("VSeWP", descWP);
266  desc.add<edm::ParameterSetDescription>("VSmuWP", descWP);
267  desc.add<edm::ParameterSetDescription>("VSjetWP", descWP);
268  descriptions.add("DeepTau2017v1", desc);
269  }
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:89
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:67
static const pat::Electron* DeepTauId::findMatchedElectron ( const pat::Tau &  tau,
const pat::ElectronCollection &  electrons,
double  deltaR 
)
inlinestaticprivate

Definition at line 618 of file DeepTauId.cc.

References deltaR(), reco::deltaR2(), reco::LeafCandidate::p4(), and reco::LeafCandidate::pt().

620  {
621  const double dR2 = deltaR*deltaR;
622  const pat::Electron* matched_ele = nullptr;
623  for(const auto& ele : electrons) {
624  if(reco::deltaR2(tau.p4(), ele.p4()) < dR2 && (!matched_ele || matched_ele->pt() < ele.pt())) {
625  matched_ele = &ele;
626  }
627  }
628  return matched_ele;
629  }
nano_cff.electrons
electrons
Definition: nano_cff.py:36
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
reco::LeafCandidate::p4
const LorentzVector & p4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:99
deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
reco::deltaR2
constexpr auto deltaR2(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:16
pat::Electron
Analysis-level electron class.
Definition: Electron.h:52
static double DeepTauId::getInnerSignalConeRadius ( double  pt)
inlinestaticprivate

Definition at line 586 of file DeepTauId.cc.

References constexpr, SiStripPI::max, and cosmictrackSelector_cfi::min_pt.

587  {
588  static constexpr double min_pt = 30., min_radius = 0.05, cone_opening_coef = 3.;
589  // This is equivalent of the original formula (std::max(std::min(0.1, 3.0/pt), 0.05)
590  return std::max(cone_opening_coef / std::max(pt, min_pt), min_radius);
591  }
cosmictrackSelector_cfi.min_pt
min_pt
Definition: cosmictrackSelector_cfi.py:18
constexpr
#define constexpr
static const OutputCollection& DeepTauId::GetOutputs ( )
inlinestatic

Definition at line 235 of file DeepTauId.cc.

References constexpr, and Output.

236  {
237  static constexpr size_t e_index = 0, mu_index = 1, tau_index = 2, jet_index = 3;
238  static const OutputCollection outputs_ = {
239  { "VSe", Output({tau_index}, {e_index, tau_index}) },
240  { "VSmu", Output({tau_index}, {mu_index, tau_index}) },
241  { "VSjet", Output({tau_index}, {jet_index, tau_index}) },
242  };
243  return outputs_;
244  }
deep_tau::DeepTauBase::OutputCollection
std::map< std::string, Output > OutputCollection
Definition: DeepTauBase.h:82
constexpr
#define constexpr
deep_tau::DeepTauBase::outputs_
OutputCollection outputs_
Definition: DeepTauBase.h:100
Output
#define Output(cl)
Definition: vmac.h:194
tensorflow::Tensor DeepTauId::getPredictions ( edm::Event &  event,
const edm::EventSetup &  es,
edm::Handle< TauCollection >  taus 
)
inlineoverrideprivatevirtual

Implements deep_tau::DeepTauBase.

Definition at line 296 of file DeepTauId.cc.

References nano_cff::electrons, PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, gen::k, extraflags_cff::muons, and tensorflow::run().

298  {
299  edm::Handle<pat::ElectronCollection> electrons;
300  event.getByToken(electrons_token, electrons);
301 
302  edm::Handle<pat::MuonCollection> muons;
303  event.getByToken(muons_token, muons);
304 
305  tensorflow::Tensor predictions(tensorflow::DT_FLOAT, { static_cast<int>(taus->size()),
306  dnn_inputs_2017v1::NumberOfOutputs});
307  for(size_t tau_index = 0; tau_index < taus->size(); ++tau_index) {
308  const tensorflow::Tensor& inputs = createInputs<dnn_inputs_2017v1>(taus->at(tau_index), *electrons, *muons);
309  std::vector<tensorflow::Tensor> pred_vector;
310  tensorflow::run(&(cache_->getSession()), { { input_layer, inputs } }, { output_layer }, &pred_vector);
311  for(int k = 0; k < dnn_inputs_2017v1::NumberOfOutputs; ++k)
312  predictions.matrix<float>()(tau_index, k) = pred_vector[0].flat<float>()(k);
313  }
314  return predictions;
315  }
nano_cff.electrons
electrons
Definition: nano_cff.py:36
deep_tau::DeepTauCache::getSession
tensorflow::Session & getSession() const
Definition: DeepTauBase.h:49
deep_tau::DeepTauBase::cache_
const DeepTauCache * cache_
Definition: DeepTauBase.h:101
DeepTauId::electrons_token
edm::EDGetTokenT< ElectronCollection > electrons_token
Definition: DeepTauId.cc:632
PatBasicFWLiteJetAnalyzer_Selector_cfg.inputs
inputs
Definition: PatBasicFWLiteJetAnalyzer_Selector_cfg.py:40
extraflags_cff.muons
muons
Definition: extraflags_cff.py:17
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:79
DeepTauId::input_layer
std::string input_layer
Definition: DeepTauId.cc:634
tensorflow::run
void run(Session *session, const NamedTensorList &inputs, const std::vector< std::string > &outputNames, const std::vector< std::string > &targetNodes, std::vector< Tensor > *outputs)
Definition: TensorFlow.cc:210
DeepTauId::muons_token
edm::EDGetTokenT< MuonCollection > muons_token
Definition: DeepTauId.cc:633
DeepTauId::output_layer
std::string output_layer
Definition: DeepTauId.cc:634
static void DeepTauId::globalEndJob ( const deep_tau::DeepTauCache *  cache_)
inlinestatic

Definition at line 290 of file DeepTauId.cc.

291  {
292  return DeepTauBase::globalEndJob(cache_);
293  }
static std::unique_ptr<deep_tau::DeepTauCache> DeepTauId::initializeGlobalCache ( const edm::ParameterSet &  cfg)
inlinestatic

Definition at line 285 of file DeepTauId.cc.

286  {
287  return DeepTauBase::initializeGlobalCache(cfg);
288  }
static bool DeepTauId::isInEcalCrack ( double  eta)
inlinestaticprivate

Definition at line 612 of file DeepTauId.cc.

References funct::abs().

613  {
614  const double abs_eta = std::abs(eta);
615  return abs_eta > 1.46 && abs_eta < 1.558;
616  }
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
template<typename CandidateCollection >
static void DeepTauId::processIsolationPFComponents ( const pat::Tau &  tau,
const CandidateCollection &  candidates,
LorentzVectorXYZ &  p4,
float &  pt,
float &  d_eta,
float &  d_phi,
float &  m,
float &  n 
)
inlinestaticprivate

Definition at line 568 of file DeepTauId.cc.

References particleFlow_cfi::dEta, particleFlow_cfi::dPhi, gen::n, and reco::LeafCandidate::p4().

571  {
572  p4 = LorentzVectorXYZ(0, 0, 0, 0);
573  n = 0;
574 
575  for(const auto& cand : candidates) {
576  p4 += cand->p4();
577  ++n;
578  }
579 
580  pt = n != 0 ? p4.Pt() : default_value;
581  d_eta = n != 0 ? dEta(p4, tau.p4()) : default_value;
582  d_phi = n != 0 ? dPhi(p4, tau.p4()) : default_value;
583  m = n != 0 ? p4.mass() : default_value;
584  }
p4
double p4[4]
Definition: TauolaWrapper.h:92
reco::LeafCandidate::p4
const LorentzVector & p4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:99
particleFlow_cfi.dPhi
dPhi
Definition: particleFlow_cfi.py:78
DeepTauId::default_value
static float default_value
Definition: DeepTauId.cc:233
particleFlow_cfi.dEta
dEta
Definition: particleFlow_cfi.py:77
deep_tau::DeepTauBase::LorentzVectorXYZ
ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double >> LorentzVectorXYZ
Definition: DeepTauBase.h:67
template<typename CandidateCollection >
static void DeepTauId::processSignalPFComponents ( const pat::Tau &  tau,
const CandidateCollection &  candidates,
LorentzVectorXYZ &  p4_inner,
LorentzVectorXYZ &  p4_outer,
float &  pt_inner,
float &  dEta_inner,
float &  dPhi_inner,
float &  m_inner,
float &  pt_outer,
float &  dEta_outer,
float &  dPhi_outer,
float &  m_outer,
float &  n_inner,
float &  n_outer 
)
inlinestaticprivate

Definition at line 532 of file DeepTauId.cc.

References reco::deltaR(), particleFlow_cfi::dEta, particleFlow_cfi::dPhi, PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, pat::Tau::leadChargedHadrCand(), reco::LeafCandidate::p4(), and reco::LeafCandidate::pt().

537  {
538  p4_inner = LorentzVectorXYZ(0, 0, 0, 0);
539  p4_outer = LorentzVectorXYZ(0, 0, 0, 0);
540  n_inner = 0;
541  n_outer = 0;
542 
543  const double innerSigCone_radius = getInnerSignalConeRadius(tau.pt());
544  for(const auto& cand : candidates) {
545  const double dR = reco::deltaR(cand->p4(), tau.leadChargedHadrCand()->p4());
546  const bool isInside_innerSigCone = dR < innerSigCone_radius;
547  if(isInside_innerSigCone) {
548  p4_inner += cand->p4();
549  ++n_inner;
550  } else {
551  p4_outer += cand->p4();
552  ++n_outer;
553  }
554  }
555 
556  pt_inner = n_inner != 0 ? p4_inner.Pt() : default_value;
557  dEta_inner = n_inner != 0 ? dEta(p4_inner, tau.p4()) : default_value;
558  dPhi_inner = n_inner != 0 ? dPhi(p4_inner, tau.p4()) : default_value;
559  m_inner = n_inner != 0 ? p4_inner.mass() : default_value;
560 
561  pt_outer = n_outer != 0 ? p4_outer.Pt() : default_value;
562  dEta_outer = n_outer != 0 ? dEta(p4_outer, tau.p4()) : default_value;
563  dPhi_outer = n_outer != 0 ? dPhi(p4_outer, tau.p4()) : default_value;
564  m_outer = n_outer != 0 ? p4_outer.mass() : default_value;
565  }
DeepTauId::getInnerSignalConeRadius
static double getInnerSignalConeRadius(double pt)
Definition: DeepTauId.cc:586
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
reco::LeafCandidate::p4
const LorentzVector & p4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:99
pat::Tau::leadChargedHadrCand
const reco::CandidatePtr leadChargedHadrCand() const
reco::deltaR
constexpr auto deltaR(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:28
PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.dR
dR
Definition: PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.py:19
particleFlow_cfi.dPhi
dPhi
Definition: particleFlow_cfi.py:78
DeepTauId::default_value
static float default_value
Definition: DeepTauId.cc:233
particleFlow_cfi.dEta
dEta
Definition: particleFlow_cfi.py:77
deep_tau::DeepTauBase::LorentzVectorXYZ
ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double >> LorentzVectorXYZ
Definition: DeepTauBase.h:67

Member Data Documentation

float DeepTauId::default_value = -999.
static

Definition at line 233 of file DeepTauId.cc.

edm::EDGetTokenT<ElectronCollection> DeepTauId::electrons_token
private

Definition at line 632 of file DeepTauId.cc.

std::string DeepTauId::input_layer
private

Definition at line 634 of file DeepTauId.cc.

edm::EDGetTokenT<MuonCollection> DeepTauId::muons_token
private

Definition at line 633 of file DeepTauId.cc.

std::string DeepTauId::output_layer
private

Definition at line 634 of file DeepTauId.cc.

Generated for CMSSW Reference Manual by doxygen 1.8.11