CMS 3D CMS Logo
List of all members | Public Member Functions | Private Member Functions | Private Attributes
PFRecoTauDiscriminationAgainstElectronMVA6 Class Reference
Inheritance diagram for PFRecoTauDiscriminationAgainstElectronMVA6:
TauDiscriminationProducerBase< TauType, TauDiscriminator > edm::stream::EDProducer<>

Public Member Functions

void beginEvent (const edm::Event &, const edm::EventSetup &) override
 
double discriminate (const PFTauRef &) const override
 
void endEvent (edm::Event &) override
 
 PFRecoTauDiscriminationAgainstElectronMVA6 (const edm::ParameterSet &cfg)
 
 ~PFRecoTauDiscriminationAgainstElectronMVA6 () override
 
- Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
virtual double discriminate (const TauRef &tau) const =0
 
void produce (edm::Event &, const edm::EventSetup &) override
 
 TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)
 
 TauDiscriminationProducerBase ()
 
 ~TauDiscriminationProducerBase () override
 
- Public Member Functions inherited from edm::stream::EDProducer<>
 EDProducer ()=default
 
bool hasAbilityToProduceInLumis () const final
 
bool hasAbilityToProduceInRuns () const final
 

Private Member Functions

bool isInEcalCrack (double) const
 

Private Attributes

std::unique_ptr< PFTauDiscriminator > category_output_
 
edm::Handle< reco::GsfElectronCollection > gsfElectrons_
 
edm::EDGetTokenT< reco::GsfElectronCollection > GsfElectrons_token
 
std::string moduleLabel_
 
std::unique_ptr< AntiElectronIDMVA6 > mva_
 
edm::InputTag srcGsfElectrons_
 
edm::Handle< TauCollection > taus_
 
int verbosity_
 
bool vetoEcalCracks_
 

Additional Inherited Members

- Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
typedef std::vector< TauType > TauCollection
 
typedef edm::Ref< TauCollection > TauRef
 
typedef edm::RefProd< TauCollection > TauRefProd
 
- Public Types inherited from edm::stream::EDProducer<>
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 TauDiscriminationProducerBase< TauType, TauDiscriminator >
std::string moduleLabel_
 
double prediscriminantFailValue_
 
edm::EDGetTokenT< TauCollection > Tau_token
 
size_t tauIndex_
 
edm::InputTag TauProducer_
 

Detailed Description

Definition at line 27 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

Constructor & Destructor Documentation

PFRecoTauDiscriminationAgainstElectronMVA6::PFRecoTauDiscriminationAgainstElectronMVA6 ( const edm::ParameterSet &  cfg)
inlineexplicit

Definition at line 30 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

References looper::cfg, edm::ParameterSet::exists(), and edm::ParameterSet::getParameter().

31  : PFTauDiscriminationProducerBase(cfg),
32  mva_(),
33  category_output_()
34  {
35  mva_ = std::make_unique<AntiElectronIDMVA6>(cfg);
36 
37  srcGsfElectrons_ = cfg.getParameter<edm::InputTag>("srcGsfElectrons");
38  GsfElectrons_token = consumes<reco::GsfElectronCollection>(srcGsfElectrons_);
39  vetoEcalCracks_ = cfg.getParameter<bool>("vetoEcalCracks");
40  verbosity_ = ( cfg.exists("verbosity") ) ?
41  cfg.getParameter<int>("verbosity") : 0;
42 
43  // add category index
44  produces<PFTauDiscriminator>("category");
45  }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:760
PFRecoTauDiscriminationAgainstElectronMVA6::GsfElectrons_token
edm::EDGetTokenT< reco::GsfElectronCollection > GsfElectrons_token
Definition: PFRecoTauDiscriminationAgainstElectronMVA6.cc:62
PFTauDiscriminationProducerBase
TauDiscriminationProducerBase< reco::PFTau, reco::PFTauDiscriminator > PFTauDiscriminationProducerBase
Definition: TauDiscriminationProducerBase.h:111
PFRecoTauDiscriminationAgainstElectronMVA6::~PFRecoTauDiscriminationAgainstElectronMVA6 ( )
inlineoverride

Definition at line 53 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

53 {}

Member Function Documentation

void PFRecoTauDiscriminationAgainstElectronMVA6::beginEvent ( const edm::Event &  evt,
const edm::EventSetup &  es 
)
overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 73 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

References edm::Event::getByToken().

74 {
75  mva_->beginEvent(evt, es);
76 
77  evt.getByToken(Tau_token, taus_);
78  category_output_.reset(new PFTauDiscriminator(TauRefProd(taus_)));
79 
80  evt.getByToken(GsfElectrons_token, gsfElectrons_);
81 }
TauDiscriminationProducerBase::TauRefProd
edm::RefProd< TauCollection > TauRefProd
Definition: TauDiscriminationProducerBase.h:56
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:579
PFRecoTauDiscriminationAgainstElectronMVA6::GsfElectrons_token
edm::EDGetTokenT< reco::GsfElectronCollection > GsfElectrons_token
Definition: PFRecoTauDiscriminationAgainstElectronMVA6.cc:62
TauDiscriminationProducerBase::Tau_token
edm::EDGetTokenT< TauCollection > Tau_token
Definition: TauDiscriminationProducerBase.h:98
double PFRecoTauDiscriminationAgainstElectronMVA6::discriminate ( const PFTauRef &  thePFTauRef) const
override

Definition at line 83 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

References funct::abs(), taus_updatedMVAIds_cff::category, reco::deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, reco::TrackBase::eta(), edm::Ref< C, T, F >::isNonnull(), SiStripPI::max, min(), boostedElectronIsolation_cff::pfGamma, reco::TrackBase::pt(), and HiIsolationCommonParameters_cff::track.

84 {
85  double mvaValue = 1.;
86  double category = -1.;
87  bool isGsfElectronMatched = false;
88 
89  float deltaRDummy = 9.9;
90 
91  const float ECALBarrelEndcapEtaBorder = 1.479;
92  float tauEtaAtEcalEntrance = -99.;
93  float sumEtaTimesEnergy = 0.;
94  float sumEnergy = 0.;
95  const std::vector<reco::PFCandidatePtr>& signalPFCands = thePFTauRef->signalPFCands();
96  for ( const auto & pfCandidate : signalPFCands ) {
97  sumEtaTimesEnergy += (pfCandidate->positionAtECALEntrance().eta()*pfCandidate->energy());
98  sumEnergy += pfCandidate->energy();
99  }
100  if ( sumEnergy > 0. ) {
101  tauEtaAtEcalEntrance = sumEtaTimesEnergy/sumEnergy;
102  }
103 
104  float leadChargedPFCandEtaAtEcalEntrance = -99.;
105  float leadChargedPFCandPt = -99.;
106  for ( const auto & pfCandidate : signalPFCands ) {
107  const reco::Track* track = nullptr;
108  if ( pfCandidate->trackRef().isNonnull() ) track = pfCandidate->trackRef().get();
109  else if ( pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->innerTrack().isNonnull() ) track = pfCandidate->muonRef()->innerTrack().get();
110  else if ( pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->globalTrack().isNonnull() ) track = pfCandidate->muonRef()->globalTrack().get();
111  else if ( pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->outerTrack().isNonnull() ) track = pfCandidate->muonRef()->outerTrack().get();
112  else if ( pfCandidate->gsfTrackRef().isNonnull() ) track = pfCandidate->gsfTrackRef().get();
113  if ( track ) {
114  if ( track->pt() > leadChargedPFCandPt ) {
115  leadChargedPFCandEtaAtEcalEntrance = pfCandidate->positionAtECALEntrance().eta();
116  leadChargedPFCandPt = track->pt();
117  }
118  }
119  }
120 
121  if( (*thePFTauRef).leadPFChargedHadrCand().isNonnull()) {
122 
123  int numSignalPFGammaCandsInSigCone = 0;
124  const std::vector<reco::PFCandidatePtr>& signalPFGammaCands = thePFTauRef->signalPFGammaCands();
125 
126  for ( const auto & pfGamma : signalPFGammaCands ) {
127 
128  double dR = deltaR(pfGamma->p4(), thePFTauRef->leadPFChargedHadrCand()->p4());
129  double signalrad = std::max(0.05, std::min(0.10, 3.0/std::max(1.0, thePFTauRef->pt())));
130 
131  // pfGammas inside the tau signal cone
132  if (dR < signalrad) {
133  numSignalPFGammaCandsInSigCone += 1;
134  }
135  }
136 
137  // loop over the electrons
138  for ( const auto & theGsfElectron : *gsfElectrons_ ) {
139  if ( theGsfElectron.pt() > 10. ) { // CV: only take electrons above some minimal energy/Pt into account...
140  double deltaREleTau = deltaR(theGsfElectron.p4(), thePFTauRef->p4());
141  deltaRDummy = deltaREleTau;
142  if ( deltaREleTau < 0.3 ) {
143  double mva_match = mva_->MVAValue(*thePFTauRef, theGsfElectron);
144  bool hasGsfTrack = thePFTauRef->leadPFChargedHadrCand()->gsfTrackRef().isNonnull();
145  if ( !hasGsfTrack )
146  hasGsfTrack = theGsfElectron.gsfTrack().isNonnull();
147 
149  if ( vetoEcalCracks_ && (isInEcalCrack(tauEtaAtEcalEntrance) || isInEcalCrack(leadChargedPFCandEtaAtEcalEntrance)) ) {
150  // add category index
151  category_output_->setValue(tauIndex_, category);
152  // return MVA output value
153  return -99;
154  }
156 
157  if ( std::abs(tauEtaAtEcalEntrance) < ECALBarrelEndcapEtaBorder ) { // Barrel
158  if ( numSignalPFGammaCandsInSigCone == 0 && hasGsfTrack ) {
159  category = 5.;
160  }
161  else if ( numSignalPFGammaCandsInSigCone >= 1 && hasGsfTrack ) {
162  category = 7.;
163  }
164  } else { // Endcap
165  if ( numSignalPFGammaCandsInSigCone == 0 && hasGsfTrack ) {
166  category = 13.;
167  }
168  else if ( numSignalPFGammaCandsInSigCone >= 1 && hasGsfTrack ) {
169  category = 15.;
170  }
171  }
172 
173  mvaValue = std::min(mvaValue, mva_match);
174  isGsfElectronMatched = true;
175  } // deltaR < 0.3
176  } // electron pt > 10
177  } // end of loop over electrons
178 
179  if ( !isGsfElectronMatched ) {
180  mvaValue = mva_->MVAValue(*thePFTauRef);
181  bool hasGsfTrack = thePFTauRef->leadPFChargedHadrCand()->gsfTrackRef().isNonnull();
182 
184  if ( vetoEcalCracks_ && (isInEcalCrack(tauEtaAtEcalEntrance) || isInEcalCrack(leadChargedPFCandEtaAtEcalEntrance)) ) {
185  // add category index
186  category_output_->setValue(tauIndex_, category);
187  // return MVA output value
188  return -99;
189  }
191 
192  if ( std::abs(tauEtaAtEcalEntrance) < ECALBarrelEndcapEtaBorder ) { // Barrel
193  if ( numSignalPFGammaCandsInSigCone == 0 && !hasGsfTrack ) {
194  category = 0.;
195  }
196  else if ( numSignalPFGammaCandsInSigCone >= 1 && !hasGsfTrack ) {
197  category = 2.;
198  }
199  } else { // Endcap
200  if ( numSignalPFGammaCandsInSigCone == 0 && !hasGsfTrack ) {
201  category = 8.;
202  }
203  else if ( numSignalPFGammaCandsInSigCone >= 1 && !hasGsfTrack ) {
204  category = 10.;
205  }
206  }
207  }
208  }
209 
210  if ( verbosity_ ) {
211  edm::LogPrint("PFTauAgainstEleMVA6") << "<PFRecoTauDiscriminationAgainstElectronMVA6::discriminate>:" ;
212  edm::LogPrint("PFTauAgainstEleMVA6") << " tau: Pt = " << thePFTauRef->pt() << ", eta = " << thePFTauRef->eta() << ", phi = " << thePFTauRef->phi();
213  edm::LogPrint("PFTauAgainstEleMVA6") << " deltaREleTau = " << deltaRDummy << ", isGsfElectronMatched = " << isGsfElectronMatched;
214  edm::LogPrint("PFTauAgainstEleMVA6") << " #Prongs = " << thePFTauRef->signalPFChargedHadrCands().size();
215  edm::LogPrint("PFTauAgainstEleMVA6") << " MVA = " << mvaValue << ", category = " << category;
216  }
217 
218  // add category index
219  category_output_->setValue(tauIndex_, category);
220  // return MVA output value
221  return mvaValue;
222 }
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:253
boostedElectronIsolation_cff.pfGamma
pfGamma
Definition: boostedElectronIsolation_cff.py:90
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:651
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:621
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
min
T min(T a, T b)
Definition: MathUtil.h:58
deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.dR
dR
Definition: PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.py:19
HiIsolationCommonParameters_cff.track
track
Definition: HiIsolationCommonParameters_cff.py:9
taus_updatedMVAIds_cff.category
category
Definition: taus_updatedMVAIds_cff.py:31
void PFRecoTauDiscriminationAgainstElectronMVA6::endEvent ( edm::Event &  evt)
overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 224 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

References eostools::move(), and edm::Event::put().

225 {
226  // add all category indices to event
227  evt.put(std::move(category_output_), "category");
228 }
edm::Event::put
OrphanHandle< PROD > put(std::unique_ptr< PROD > product)
Put a new product.
Definition: Event.h:137
eostools.move
def move(src, dest)
Definition: eostools.py:510
bool PFRecoTauDiscriminationAgainstElectronMVA6::isInEcalCrack ( double  eta) const
private

Definition at line 231 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

References DEFINE_FWK_MODULE.

232 {
233  double absEta = fabs(eta);
234  return (absEta > 1.460 && absEta < 1.558);
235 }

Member Data Documentation

std::unique_ptr<PFTauDiscriminator> PFRecoTauDiscriminationAgainstElectronMVA6::category_output_
private

Definition at line 66 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

edm::Handle<reco::GsfElectronCollection> PFRecoTauDiscriminationAgainstElectronMVA6::gsfElectrons_
private

Definition at line 63 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

edm::EDGetTokenT<reco::GsfElectronCollection> PFRecoTauDiscriminationAgainstElectronMVA6::GsfElectrons_token
private

Definition at line 62 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

std::string PFRecoTauDiscriminationAgainstElectronMVA6::moduleLabel_
private

Definition at line 58 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

Referenced by Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), and Modules.ESProducer::nameInProcessDesc_().

std::unique_ptr<AntiElectronIDMVA6> PFRecoTauDiscriminationAgainstElectronMVA6::mva_
private

Definition at line 59 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

edm::InputTag PFRecoTauDiscriminationAgainstElectronMVA6::srcGsfElectrons_
private

Definition at line 61 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

edm::Handle<TauCollection> PFRecoTauDiscriminationAgainstElectronMVA6::taus_
private

Definition at line 64 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

int PFRecoTauDiscriminationAgainstElectronMVA6::verbosity_
private

Definition at line 70 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

bool PFRecoTauDiscriminationAgainstElectronMVA6::vetoEcalCracks_
private

Definition at line 68 of file PFRecoTauDiscriminationAgainstElectronMVA6.cc.

Generated for CMSSW Reference Manual by doxygen 1.8.11