CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Member Functions | Private Attributes
PFRecoTauDiscriminationAgainstElectronMVA5GBR Class Reference
Inheritance diagram for PFRecoTauDiscriminationAgainstElectronMVA5GBR:
TauDiscriminationProducerBase< TauType, TauDiscriminator > edm::EDProducer edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

Public Member Functions

void beginEvent (const edm::Event &, const edm::EventSetup &)
 
double discriminate (const PFTauRef &)
 
void endEvent (edm::Event &)
 
 PFRecoTauDiscriminationAgainstElectronMVA5GBR (const edm::ParameterSet &iConfig)
 
 ~PFRecoTauDiscriminationAgainstElectronMVA5GBR ()
 
- Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
virtual double discriminate (const TauRef &tau)=0
 
void produce (edm::Event &, const edm::EventSetup &)
 
 TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)
 
 TauDiscriminationProducerBase ()
 
virtual ~TauDiscriminationProducerBase ()
 
- Public Member Functions inherited from edm::EDProducer
 EDProducer ()
 
ModuleDescription const & moduleDescription () const
 
virtual ~EDProducer ()
 
- Public Member Functions inherited from edm::ProducerBase
 ProducerBase ()
 
void registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
 
std::function< void(BranchDescription
const &)> 		registrationCallback () const
 used by the fwk to register list of products More...
 
virtual ~ProducerBase ()
 
- Public Member Functions inherited from edm::EDConsumerBase
 EDConsumerBase ()
 
ProductHolderIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
std::vector
< ProductHolderIndexAndSkipBit >
const & 		itemsToGetFromEvent () const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
 
bool registeredToConsume (ProductHolderIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
 
virtual ~EDConsumerBase ()
 

Private Member Functions

bool isInEcalCrack (double) const
 

Private Attributes

std::auto_ptr< PFTauDiscriminator > category_output_
 
edm::FileInPath gbrFile_
 
edm::Handle
< reco::GsfElectronCollection > 		gsfElectrons_
 
edm::EDGetTokenT
< reco::GsfElectronCollection > 		GsfElectrons_token
 
std::string method_
 
double minMVANoEleMatchWgWgsfBL_
 
double minMVANoEleMatchWgWgsfEC_
 
double minMVANoEleMatchWgWOgsfBL_
 
double minMVANoEleMatchWgWOgsfEC_
 
double minMVANoEleMatchWOgWgsfBL_
 
double minMVANoEleMatchWOgWgsfEC_
 
double minMVANoEleMatchWOgWOgsfBL_
 
double minMVANoEleMatchWOgWOgsfEC_
 
double minMVAWgWgsfBL_
 
double minMVAWgWgsfEC_
 
double minMVAWgWOgsfBL_
 
double minMVAWgWOgsfEC_
 
double minMVAWOgWgsfBL_
 
double minMVAWOgWgsfEC_
 
double minMVAWOgWOgsfBL_
 
double minMVAWOgWOgsfEC_
 
AntiElectronIDMVA5GBR * mva_
 
bool returnMVA_
 
edm::InputTag srcGsfElectrons_
 
size_t tauIndex_
 
edm::Handle< TauCollection > taus_
 
int verbosity_
 

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::EDProducer
typedef EDProducer ModuleType
 
- Public Types inherited from edm::ProducerBase
typedef
ProductRegistryHelper::TypeLabelList 		TypeLabelList
 
- Static Public Member Functions inherited from edm::EDProducer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 
- Protected Member Functions inherited from edm::ProducerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
- Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
std::string moduleLabel_
 
double prediscriminantFailValue_
 
edm::EDGetTokenT< TauCollection > Tau_token
 
edm::InputTag TauProducer_
 

Detailed Description

Definition at line 29 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

Constructor & Destructor Documentation

PFRecoTauDiscriminationAgainstElectronMVA5GBR::PFRecoTauDiscriminationAgainstElectronMVA5GBR ( const edm::ParameterSet &  iConfig)
inlineexplicit

Definition at line 31 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::FileInPath::Unknown.

32  : PFTauDiscriminationProducerBase(iConfig),
33  mva_(0),
34  category_output_(0)
35  {
36  method_ = iConfig.getParameter<std::string>("method");
37  gbrFile_ = iConfig.getParameter<edm::FileInPath>("gbrFile");
38  if ( gbrFile_.location() == edm::FileInPath::Unknown)
39  throw cms::Exception("PFRecoTauDiscriminationAgainstElectronMVA5GBR")
40  << " Failed to find File = " << gbrFile_ << " !!\n";
41 
42  returnMVA_ = iConfig.getParameter<bool>("returnMVA");
43  minMVANoEleMatchWOgWOgsfBL_ = iConfig.getParameter<double>("minMVANoEleMatchWOgWOgsfBL");
44  minMVANoEleMatchWOgWgsfBL_ = iConfig.getParameter<double>("minMVANoEleMatchWOgWgsfBL");
45  minMVANoEleMatchWgWOgsfBL_ = iConfig.getParameter<double>("minMVANoEleMatchWgWOgsfBL");
46  minMVANoEleMatchWgWgsfBL_ = iConfig.getParameter<double>("minMVANoEleMatchWgWgsfBL");
47  minMVAWOgWOgsfBL_ = iConfig.getParameter<double>("minMVAWOgWOgsfBL");
48  minMVAWOgWgsfBL_ = iConfig.getParameter<double>("minMVAWOgWgsfBL");
49  minMVAWgWOgsfBL_ = iConfig.getParameter<double>("minMVAWgWOgsfBL");
50  minMVAWgWgsfBL_ = iConfig.getParameter<double>("minMVAWgWgsfBL");
51  minMVANoEleMatchWOgWOgsfEC_ = iConfig.getParameter<double>("minMVANoEleMatchWOgWOgsfEC");
52  minMVANoEleMatchWOgWgsfEC_ = iConfig.getParameter<double>("minMVANoEleMatchWOgWgsfEC");
53  minMVANoEleMatchWgWOgsfEC_ = iConfig.getParameter<double>("minMVANoEleMatchWgWOgsfEC");
54  minMVANoEleMatchWgWgsfEC_ = iConfig.getParameter<double>("minMVANoEleMatchWgWgsfEC");
55  minMVAWOgWOgsfEC_ = iConfig.getParameter<double>("minMVAWOgWOgsfEC");
56  minMVAWOgWgsfEC_ = iConfig.getParameter<double>("minMVAWOgWgsfEC");
57  minMVAWgWOgsfEC_ = iConfig.getParameter<double>("minMVAWgWOgsfEC");
58  minMVAWgWgsfEC_ = iConfig.getParameter<double>("minMVAWgWgsfEC");
59 
60  srcGsfElectrons_ = iConfig.getParameter<edm::InputTag>("srcGsfElectrons");
61  GsfElectrons_token = consumes<reco::GsfElectronCollection>(srcGsfElectrons_);
62 
63  mva_ = new AntiElectronIDMVA5GBR();
64  mva_->Initialize_from_file(method_, gbrFile_.fullPath().data());
65 
66  verbosity_ = ( iConfig.exists("verbosity") ) ?
67  iConfig.getParameter<int>("verbosity") : 0;
68 
69  // add category index
70  if ( returnMVA_ ) {
71  produces<PFTauDiscriminator>("category");
72  }
73  }
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:759
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
PFTauDiscriminationProducerBase
TauDiscriminationProducerBase< reco::PFTau, reco::PFTauDiscriminator > PFTauDiscriminationProducerBase
Definition: TauDiscriminationProducerBase.h:105
PFRecoTauDiscriminationAgainstElectronMVA5GBR::GsfElectrons_token
edm::EDGetTokenT< reco::GsfElectronCollection > GsfElectrons_token
Definition: PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc:110
PFRecoTauDiscriminationAgainstElectronMVA5GBR::~PFRecoTauDiscriminationAgainstElectronMVA5GBR ( )
inline

Definition at line 81 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

82  {
83  delete mva_;
84  }

Member Function Documentation

void PFRecoTauDiscriminationAgainstElectronMVA5GBR::beginEvent ( const edm::Event &  evt,
const edm::EventSetup &  es 
)
virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 119 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

References edm::Event::getByToken().

120 {
121  if ( returnMVA_ ) {
122  evt.getByToken(Tau_token, taus_);
123  category_output_.reset(new PFTauDiscriminator(TauRefProd(taus_)));
124  tauIndex_ = 0;
125  }
126  evt.getByToken(GsfElectrons_token, gsfElectrons_);
127 }
TauDiscriminationProducerBase::TauRefProd
edm::RefProd< TauCollection > TauRefProd
Definition: TauDiscriminationProducerBase.h:53
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
TauDiscriminationProducerBase::Tau_token
edm::EDGetTokenT< TauCollection > Tau_token
Definition: TauDiscriminationProducerBase.h:95
PFRecoTauDiscriminationAgainstElectronMVA5GBR::GsfElectrons_token
edm::EDGetTokenT< reco::GsfElectronCollection > GsfElectrons_token
Definition: PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc:110
double PFRecoTauDiscriminationAgainstElectronMVA5GBR::discriminate ( const PFTauRef &  thePFTauRef)

Definition at line 129 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

References Abs(), python.rootplot.argparse::category, reco::deltaR(), reco::TrackBase::eta(), edm::Ref< C, T, F >::isNonnull(), Min(), and reco::TrackBase::pt().

130 {
131  double mva = 1.;
132  double workingPoint = 1.;
133  double category = -1.;
134  bool isGsfElectronMatched = false;
135 
136  float deltaRDummy = 9.9;
137  float mvaCutDummy = 999;
138 
139  float tauEtaAtEcalEntrance = -99.;
140  float sumEtaTimesEnergy = 0.;
141  float sumEnergy = 0.;
142  const std::vector<reco::PFCandidatePtr>& signalPFCands = thePFTauRef->signalPFCands();
143  for ( std::vector<reco::PFCandidatePtr>::const_iterator pfCandidate = signalPFCands.begin();
144  pfCandidate != signalPFCands.end(); ++pfCandidate ) {
145  sumEtaTimesEnergy += ((*pfCandidate)->positionAtECALEntrance().eta()*(*pfCandidate)->energy());
146  sumEnergy += (*pfCandidate)->energy();
147  }
148  if ( sumEnergy > 0. ) {
149  tauEtaAtEcalEntrance = sumEtaTimesEnergy/sumEnergy;
150  }
151 
152  float leadChargedPFCandEtaAtEcalEntrance = -99.;
153  float leadChargedPFCandPt = -99.;
154  for ( std::vector<reco::PFCandidatePtr>::const_iterator pfCandidate = signalPFCands.begin();
155  pfCandidate != signalPFCands.end(); ++pfCandidate ) {
156  const reco::Track* track = 0;
157  if ( (*pfCandidate)->trackRef().isNonnull() ) track = (*pfCandidate)->trackRef().get();
158  else if ( (*pfCandidate)->muonRef().isNonnull() && (*pfCandidate)->muonRef()->innerTrack().isNonnull() ) track = (*pfCandidate)->muonRef()->innerTrack().get();
159  else if ( (*pfCandidate)->muonRef().isNonnull() && (*pfCandidate)->muonRef()->globalTrack().isNonnull() ) track = (*pfCandidate)->muonRef()->globalTrack().get();
160  else if ( (*pfCandidate)->muonRef().isNonnull() && (*pfCandidate)->muonRef()->outerTrack().isNonnull() ) track = (*pfCandidate)->muonRef()->outerTrack().get();
161  else if ( (*pfCandidate)->gsfTrackRef().isNonnull() ) track = (*pfCandidate)->gsfTrackRef().get();
162  if ( track ) {
163  if ( track->pt() > leadChargedPFCandPt ) {
164  leadChargedPFCandEtaAtEcalEntrance = (*pfCandidate)->positionAtECALEntrance().eta();
165  leadChargedPFCandPt = track->pt();
166  }
167  }
168  }
169 
170  if( (*thePFTauRef).leadPFChargedHadrCand().isNonnull()) {
171  for ( reco::GsfElectronCollection::const_iterator theGsfElectron = gsfElectrons_->begin();
172  theGsfElectron != gsfElectrons_->end(); ++theGsfElectron ) {
173  if ( theGsfElectron->pt() > 10. ) { // CV: only take electrons above some minimal energy/Pt into account...
174  double deltaREleTau = deltaR(theGsfElectron->p4(), thePFTauRef->p4());
175  deltaRDummy = deltaREleTau;
176  if ( deltaREleTau < 0.3 ) {
177  double mva_match = mva_->MVAValue(*thePFTauRef, *theGsfElectron);
178  double workingPoint_match = 0.;
179  size_t numSignalPFGammaCands = thePFTauRef->signalPFGammaCands().size();
180  bool hasGsfTrack = thePFTauRef->leadPFChargedHadrCand()->gsfTrackRef().isNonnull();
181 
183  if ( isInEcalCrack(tauEtaAtEcalEntrance) || isInEcalCrack(leadChargedPFCandEtaAtEcalEntrance) ) {
184  if ( returnMVA_ ) {
185  // add category index
186  category_output_->setValue(tauIndex_, category);
187  ++tauIndex_;
188  // return MVA output value
189  return -99;
190  } else {
191  //return Workingpoint 0
192  return 0;
193  }
194  }
196 
197  double mvaCut = 999.;
198  if ( TMath::Abs(tauEtaAtEcalEntrance) < 1.479 ) { // Barrel
199  if ( numSignalPFGammaCands == 0 && !hasGsfTrack ) {
200  category = 4.;
201  mvaCut = minMVAWOgWOgsfBL_;
202  } else if ( numSignalPFGammaCands == 0 && hasGsfTrack ) {
203  category = 5.;
204  mvaCut = minMVAWOgWgsfBL_;
205  } else if ( numSignalPFGammaCands >= 1 && !hasGsfTrack ) {
206  category = 6.;
207  mvaCut = minMVAWgWOgsfBL_;
208  } else if ( numSignalPFGammaCands >= 1 && hasGsfTrack ) {
209  category = 7.;
210  mvaCut = minMVAWgWgsfBL_;
211  }
212  } else { // Endcap
213  if ( numSignalPFGammaCands == 0 && !hasGsfTrack ) {
214  category = 12.;
215  mvaCut = minMVAWOgWOgsfEC_;
216  } else if ( numSignalPFGammaCands == 0 && hasGsfTrack ) {
217  category = 13.;
218  mvaCut = minMVAWOgWgsfEC_;
219  } else if ( numSignalPFGammaCands >= 1 && !hasGsfTrack ) {
220  category = 14.;
221  mvaCut = minMVAWgWOgsfEC_;
222  } else if ( numSignalPFGammaCands >= 1 && hasGsfTrack ) {
223  category = 15.;
224  mvaCut = minMVAWgWgsfEC_;
225  }
226  }
227  workingPoint_match = (mva_match > mvaCut);
228  mvaCutDummy = mvaCut;
229 
230  mva = TMath::Min(mva, mva_match);
231  workingPoint = TMath::Min(workingPoint, workingPoint_match);
232  isGsfElectronMatched = true;
233  } // deltaR < 0.3
234  } // electron pt > 10
235  } // end of loop over electrons
236 
237  if ( !isGsfElectronMatched ) {
238  mva = mva_->MVAValue(*thePFTauRef);
239  size_t numSignalPFGammaCands = thePFTauRef->signalPFGammaCands().size();
240  bool hasGsfTrack = thePFTauRef->leadPFChargedHadrCand()->gsfTrackRef().isNonnull();
241 
243  if ( isInEcalCrack(tauEtaAtEcalEntrance) || isInEcalCrack(leadChargedPFCandEtaAtEcalEntrance) ) {
244  if ( returnMVA_ ) {
245  // add category index
246  category_output_->setValue(tauIndex_, category);
247  ++tauIndex_;
248  // return MVA output value
249  return -99;
250  } else {
251  //return Workingpoint 0
252  return 0;
253  }
254  }
256 
257  double mvaCut = 999.;
258  if ( TMath::Abs(tauEtaAtEcalEntrance) < 1.479 ) { // Barrel
259  if ( numSignalPFGammaCands == 0 && !hasGsfTrack ) {
260  category = 0.;
261  mvaCut = minMVANoEleMatchWOgWOgsfBL_;
262  } else if ( numSignalPFGammaCands == 0 && hasGsfTrack ) {
263  category = 1.;
264  mvaCut = minMVANoEleMatchWOgWgsfBL_;
265  } else if ( numSignalPFGammaCands >= 1 && !hasGsfTrack ) {
266  category = 2.;
267  mvaCut = minMVANoEleMatchWgWOgsfBL_;
268  } else if ( numSignalPFGammaCands >= 1 && hasGsfTrack ) {
269  category = 3.;
270  mvaCut = minMVANoEleMatchWgWgsfBL_;
271  }
272  } else { // Endcap
273  if ( numSignalPFGammaCands == 0 && !hasGsfTrack ) {
274  category = 8.;
275  mvaCut = minMVANoEleMatchWOgWOgsfEC_;
276  } else if ( numSignalPFGammaCands == 0 && hasGsfTrack ) {
277  category = 9.;
278  mvaCut = minMVANoEleMatchWOgWgsfEC_;
279  } else if ( numSignalPFGammaCands >= 1 && !hasGsfTrack ) {
280  category = 10.;
281  mvaCut = minMVANoEleMatchWgWOgsfEC_;
282  } else if ( numSignalPFGammaCands >= 1 && hasGsfTrack ) {
283  category = 11.;
284  mvaCut = minMVANoEleMatchWgWgsfEC_;
285  }
286  }
287  workingPoint = (mva > mvaCut);
288  mvaCutDummy = mvaCut;
289  }
290  }
291 
292  if ( verbosity_ ) {
293  edm::LogPrint("PFTauAgainstEleMVA5") <<" Taus : "<<TauProducer_;
294  edm::LogPrint("PFTauAgainstEleMVA5") << "<PFRecoTauDiscriminationAgainstElectronMVA5::discriminate>:" ;
295  edm::LogPrint("PFTauAgainstEleMVA5") << " tau: Pt = " << thePFTauRef->pt() << ", eta = " << thePFTauRef->eta() << ", phi = " << thePFTauRef->phi() ;
296  edm::LogPrint("PFTauAgainstEleMVA5") << " mva = " << mva << ", mvaCut = " << mvaCutDummy << ", isGsfElectronMatched = " << isGsfElectronMatched ;
297  edm::LogPrint("PFTauAgainstEleMVA5") << " category = " << category << ": workingPoint = " << workingPoint ;
298  edm::LogPrint("PFTauAgainstEleMVA5") << " deltaREleTau = " << deltaRDummy ;
299  edm::LogPrint("PFTauAgainstEleMVA5") << " charged hadron in tau: "<<(*thePFTauRef).leadPFChargedHadrCand().isNonnull() ;
300  edm::LogPrint("PFTauAgainstEleMVA5") << " Prongs in tau: " << thePFTauRef->signalPFChargedHadrCands().size() ;
301  edm::LogPrint("PFTauAgainstEleMVA5") << " MVA GBR:" << mva ;
302  }
303 
304  if ( returnMVA_ ) {
305  // add category index
306  category_output_->setValue(tauIndex_, category);
307  ++tauIndex_;
308  // return MVA output value
309  return mva;
310  } else {
311  return workingPoint;
312  }
313 }
Min
T Min(T a, T b)
Definition: MathUtil.h:39
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:250
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:139
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:129
Abs
T Abs(T a)
Definition: MathUtil.h:49
deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
AntiElectronIDMVA5GBR::MVAValue
double MVAValue(Float_t TauEtaAtEcalEntrance, Float_t TauPt, Float_t TauLeadChargedPFCandEtaAtEcalEntrance, Float_t TauLeadChargedPFCandPt, Float_t TaudCrackEta, Float_t TaudCrackPhi, Float_t TauEmFraction, Float_t TauSignalPFGammaCands, Float_t TauLeadPFChargedHadrHoP, Float_t TauLeadPFChargedHadrEoP, Float_t TauVisMass, Float_t TauHadrMva, const std::vector< Float_t > &GammasdEta, const std::vector< Float_t > &GammasdPhi, const std::vector< Float_t > &GammasPt, Float_t TauKFNumHits, Float_t TauGSFNumHits, Float_t TauGSFChi2, Float_t TauGSFTrackResol, Float_t TauGSFTracklnPt, Float_t TauGSFTrackEta, Float_t TauPhi, Float_t TauSignalPFChargedCands, Float_t TauHasGsf, Float_t ElecEta, Float_t ElecPhi, Float_t ElecPt, Float_t ElecEe, Float_t ElecEgamma, Float_t ElecPin, Float_t ElecPout, Float_t ElecFbrem, Float_t ElecChi2GSF, Float_t ElecGSFNumHits, Float_t ElecGSFTrackResol, Float_t ElecGSFTracklnPt, Float_t ElecGSFTrackEta)
Definition: AntiElectronIDMVA5GBR.cc:106
void PFRecoTauDiscriminationAgainstElectronMVA5GBR::endEvent ( edm::Event &  evt)
virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 315 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

References edm::Event::put().

316 {
317  // add all category indices to event
318  if ( returnMVA_ ) {
319  evt.put(category_output_, "category");
320  }
321 }
edm::Event::put
OrphanHandle< PROD > put(std::auto_ptr< PROD > product)
Put a new product.
Definition: Event.h:116
bool PFRecoTauDiscriminationAgainstElectronMVA5GBR::isInEcalCrack ( double  eta) const
private

Definition at line 324 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

325 {
326  double absEta = fabs(eta);
327  return (absEta > 1.460 && absEta < 1.558);
328 }
eta
T eta() const
Definition: Basic3DVectorLD.h:177

Member Data Documentation

std::auto_ptr<PFTauDiscriminator> PFRecoTauDiscriminationAgainstElectronMVA5GBR::category_output_
private

Definition at line 113 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

edm::FileInPath PFRecoTauDiscriminationAgainstElectronMVA5GBR::gbrFile_
private

Definition at line 90 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

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

Definition at line 111 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

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

Definition at line 110 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

std::string PFRecoTauDiscriminationAgainstElectronMVA5GBR::method_
private

Definition at line 89 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVANoEleMatchWgWgsfBL_
private

Definition at line 96 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVANoEleMatchWgWgsfEC_
private

Definition at line 104 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVANoEleMatchWgWOgsfBL_
private

Definition at line 95 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVANoEleMatchWgWOgsfEC_
private

Definition at line 103 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVANoEleMatchWOgWgsfBL_
private

Definition at line 94 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVANoEleMatchWOgWgsfEC_
private

Definition at line 102 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVANoEleMatchWOgWOgsfBL_
private

Definition at line 93 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVANoEleMatchWOgWOgsfEC_
private

Definition at line 101 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVAWgWgsfBL_
private

Definition at line 100 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVAWgWgsfEC_
private

Definition at line 108 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVAWgWOgsfBL_
private

Definition at line 99 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVAWgWOgsfEC_
private

Definition at line 107 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVAWOgWgsfBL_
private

Definition at line 98 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVAWOgWgsfEC_
private

Definition at line 106 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVAWOgWOgsfBL_
private

Definition at line 97 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

double PFRecoTauDiscriminationAgainstElectronMVA5GBR::minMVAWOgWOgsfEC_
private

Definition at line 105 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

AntiElectronIDMVA5GBR* PFRecoTauDiscriminationAgainstElectronMVA5GBR::mva_
private

Definition at line 91 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

bool PFRecoTauDiscriminationAgainstElectronMVA5GBR::returnMVA_
private

Definition at line 92 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

edm::InputTag PFRecoTauDiscriminationAgainstElectronMVA5GBR::srcGsfElectrons_
private

Definition at line 109 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

size_t PFRecoTauDiscriminationAgainstElectronMVA5GBR::tauIndex_
private

Definition at line 114 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

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

Definition at line 112 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

int PFRecoTauDiscriminationAgainstElectronMVA5GBR::verbosity_
private

Definition at line 116 of file PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc.

Generated for CMSSW Reference Manual by doxygen 1.8.5