Reference Manual

Go to the documentation of this file.
00001 /* class PFRecoTauDiscriminationAgainstElectronMVA3
00002  * created : Oct 18 2012,
00003  * revised : ,
00004  * Authorss : Ivo Naranjo (LLR Ecole-Polytechnique)
00005  */
00006 
00007 #include "RecoTauTag/RecoTau/interface/TauDiscriminationProducerBase.h"
00008 #include "FWCore/ParameterSet/interface/FileInPath.h"
00009 #include "FWCore/Utilities/interface/Exception.h"
00010 #include "RecoTauTag/RecoTau/interface/AntiElectronIDMVA3.h"
00011 #include "DataFormats/Math/interface/deltaR.h"
00012 #include "PhysicsTools/MVAComputer/interface/zstream.h"
00013 #include "DataFormats/TauReco/interface/PFTauDiscriminator.h"
00014 
00015 #include <TMath.h>
00016 
00017 #include <iostream>
00018 #include <sstream>
00019 #include <fstream>
00020 
00021 using namespace reco;
00022 
00023 class PFRecoTauDiscriminationAgainstElectronMVA3 : public PFTauDiscriminationProducerBase  
00024 {
00025  public:
00026   explicit PFRecoTauDiscriminationAgainstElectronMVA3(const edm::ParameterSet& iConfig)
00027     : PFTauDiscriminationProducerBase(iConfig),
00028       moduleLabel_(iConfig.getParameter<std::string>("@module_label")),
00029       mva_(0),
00030       category_output_(0)
00031   {
00032     //std::cout << "<PFRecoTauDiscriminationAgainstElectronMVA3::PFRecoTauDiscriminationAgainstElectronMVA3>:" << std::endl;
00033     //std::cout << " moduleLabel = " << moduleLabel_ << std::endl;
00034 
00035     method_                                    = iConfig.getParameter<std::string>("method");
00036     inputFileName1prongNoEleMatchWOgWOgsfBL_   = iConfig.getParameter<edm::FileInPath>("inputFileName1prongNoEleMatchWOgWOgsfBL");
00037     inputFileName1prongNoEleMatchWOgWgsfBL_    = iConfig.getParameter<edm::FileInPath>("inputFileName1prongNoEleMatchWOgWgsfBL");
00038     inputFileName1prongNoEleMatchWgWOgsfBL_    = iConfig.getParameter<edm::FileInPath>("inputFileName1prongNoEleMatchWgWOgsfBL");
00039     inputFileName1prongNoEleMatchWgWgsfBL_     = iConfig.getParameter<edm::FileInPath>("inputFileName1prongNoEleMatchWgWgsfBL");
00040     inputFileName1prongWOgWOgsfBL_             = iConfig.getParameter<edm::FileInPath>("inputFileName1prongWOgWOgsfBL");
00041     inputFileName1prongWOgWgsfBL_              = iConfig.getParameter<edm::FileInPath>("inputFileName1prongWOgWgsfBL");
00042     inputFileName1prongWgWOgsfBL_              = iConfig.getParameter<edm::FileInPath>("inputFileName1prongWgWOgsfBL");
00043     inputFileName1prongWgWgsfBL_               = iConfig.getParameter<edm::FileInPath>("inputFileName1prongWgWgsfBL");
00044     inputFileName1prongNoEleMatchWOgWOgsfEC_   = iConfig.getParameter<edm::FileInPath>("inputFileName1prongNoEleMatchWOgWOgsfEC");
00045     inputFileName1prongNoEleMatchWOgWgsfEC_    = iConfig.getParameter<edm::FileInPath>("inputFileName1prongNoEleMatchWOgWgsfEC");
00046     inputFileName1prongNoEleMatchWgWOgsfEC_    = iConfig.getParameter<edm::FileInPath>("inputFileName1prongNoEleMatchWgWOgsfEC");
00047     inputFileName1prongNoEleMatchWgWgsfEC_     = iConfig.getParameter<edm::FileInPath>("inputFileName1prongNoEleMatchWgWgsfEC");
00048     inputFileName1prongWOgWOgsfEC_             = iConfig.getParameter<edm::FileInPath>("inputFileName1prongWOgWOgsfEC");
00049     inputFileName1prongWOgWgsfEC_              = iConfig.getParameter<edm::FileInPath>("inputFileName1prongWOgWgsfEC");
00050     inputFileName1prongWgWOgsfEC_              = iConfig.getParameter<edm::FileInPath>("inputFileName1prongWgWOgsfEC");
00051     inputFileName1prongWgWgsfEC_               = iConfig.getParameter<edm::FileInPath>("inputFileName1prongWgWgsfEC");
00052 
00053     returnMVA_                          = iConfig.getParameter<bool>("returnMVA");
00054     minMVA1prongNoEleMatchWOgWOgsfBL_   = iConfig.getParameter<double>("minMVA1prongNoEleMatchWOgWOgsfBL");
00055     minMVA1prongNoEleMatchWOgWgsfBL_    = iConfig.getParameter<double>("minMVA1prongNoEleMatchWOgWgsfBL");
00056     minMVA1prongNoEleMatchWgWOgsfBL_    = iConfig.getParameter<double>("minMVA1prongNoEleMatchWgWOgsfBL");
00057     minMVA1prongNoEleMatchWgWgsfBL_     = iConfig.getParameter<double>("minMVA1prongNoEleMatchWgWgsfBL");
00058     minMVA1prongWOgWOgsfBL_             = iConfig.getParameter<double>("minMVA1prongWOgWOgsfBL");
00059     minMVA1prongWOgWgsfBL_              = iConfig.getParameter<double>("minMVA1prongWOgWgsfBL");
00060     minMVA1prongWgWOgsfBL_              = iConfig.getParameter<double>("minMVA1prongWgWOgsfBL");
00061     minMVA1prongWgWgsfBL_               = iConfig.getParameter<double>("minMVA1prongWgWgsfBL");
00062     minMVA1prongNoEleMatchWOgWOgsfEC_   = iConfig.getParameter<double>("minMVA1prongNoEleMatchWOgWOgsfEC");
00063     minMVA1prongNoEleMatchWOgWgsfEC_    = iConfig.getParameter<double>("minMVA1prongNoEleMatchWOgWgsfEC");
00064     minMVA1prongNoEleMatchWgWOgsfEC_    = iConfig.getParameter<double>("minMVA1prongNoEleMatchWgWOgsfEC");
00065     minMVA1prongNoEleMatchWgWgsfEC_     = iConfig.getParameter<double>("minMVA1prongNoEleMatchWgWgsfEC");
00066     minMVA1prongWOgWOgsfEC_             = iConfig.getParameter<double>("minMVA1prongWOgWOgsfEC");
00067     minMVA1prongWOgWgsfEC_              = iConfig.getParameter<double>("minMVA1prongWOgWgsfEC");
00068     minMVA1prongWgWOgsfEC_              = iConfig.getParameter<double>("minMVA1prongWgWOgsfEC");
00069     minMVA1prongWgWgsfEC_               = iConfig.getParameter<double>("minMVA1prongWgWgsfEC");
00070     minMVA3prongMatch_                  = iConfig.getParameter<double>("minMVA3prongMatch");
00071     minMVA3prongNoMatch_                = iConfig.getParameter<double>("minMVA3prongNoMatch");
00072   
00073     srcGsfElectrons_ = iConfig.getParameter<edm::InputTag>("srcGsfElectrons");
00074 
00075     mva_ = new AntiElectronIDMVA3();
00076     // CV: working version of file compression not implemented yet
00077 //     mva_->Initialize_from_string(method_,
00078 //                               readZippedFile(inputFileName1prongNoEleMatchWOgWOgsfBL_.fullPath()),
00079 //                               readZippedFile(inputFileName1prongNoEleMatchWOgWgsfBL_.fullPath()),
00080 //                               readZippedFile(inputFileName1prongNoEleMatchWgWOgsfBL_.fullPath()),
00081 //                               readZippedFile(inputFileName1prongNoEleMatchWgWgsfBL_.fullPath()),
00082 //                               readZippedFile(inputFileName1prongWOgWOgsfBL_.fullPath()),
00083 //                               readZippedFile(inputFileName1prongWOgWgsfBL_.fullPath()),
00084 //                               readZippedFile(inputFileName1prongWgWOgsfBL_.fullPath()),
00085 //                               readZippedFile(inputFileName1prongWgWgsfBL_.fullPath()),
00086 //                               readZippedFile(inputFileName1prongNoEleMatchWOgWOgsfEC_.fullPath()),
00087 //                               readZippedFile(inputFileName1prongNoEleMatchWOgWgsfEC_.fullPath()),
00088 //                               readZippedFile(inputFileName1prongNoEleMatchWgWOgsfEC_.fullPath()),
00089 //                               readZippedFile(inputFileName1prongNoEleMatchWgWgsfEC_.fullPath()),
00090 //                               readZippedFile(inputFileName1prongWOgWOgsfEC_.fullPath()),
00091 //                               readZippedFile(inputFileName1prongWOgWgsfEC_.fullPath()),
00092 //                               readZippedFile(inputFileName1prongWgWOgsfEC_.fullPath()),
00093 //                               readZippedFile(inputFileName1prongWgWgsfEC_.fullPath()));
00094     mva_->Initialize_from_file(method_,
00095                                inputFileName1prongNoEleMatchWOgWOgsfBL_.fullPath(),
00096                                inputFileName1prongNoEleMatchWOgWgsfBL_.fullPath(),
00097                                inputFileName1prongNoEleMatchWgWOgsfBL_.fullPath(),
00098                                inputFileName1prongNoEleMatchWgWgsfBL_.fullPath(),
00099                                inputFileName1prongWOgWOgsfBL_.fullPath(),
00100                                inputFileName1prongWOgWgsfBL_.fullPath(),
00101                                inputFileName1prongWgWOgsfBL_.fullPath(),
00102                                inputFileName1prongWgWgsfBL_.fullPath(),
00103                                inputFileName1prongNoEleMatchWOgWOgsfEC_.fullPath(),
00104                                inputFileName1prongNoEleMatchWOgWgsfEC_.fullPath(),
00105                                inputFileName1prongNoEleMatchWgWOgsfEC_.fullPath(),
00106                                inputFileName1prongNoEleMatchWgWgsfEC_.fullPath(),
00107                                inputFileName1prongWOgWOgsfEC_.fullPath(),
00108                                inputFileName1prongWOgWgsfEC_.fullPath(),
00109                                inputFileName1prongWgWOgsfEC_.fullPath(),
00110                                inputFileName1prongWgWgsfEC_.fullPath());
00111 
00112     // add category index
00113     if ( returnMVA_ ) {
00114       produces<PFTauDiscriminator>("category");
00115     }
00116   }
00117 
00118   void beginEvent(const edm::Event&, const edm::EventSetup&);
00119 
00120   double discriminate(const PFTauRef&);
00121 
00122   void endEvent(edm::Event&);
00123 
00124   ~PFRecoTauDiscriminationAgainstElectronMVA3()
00125   {
00126     delete mva_;
00127   }
00128 
00129  private:
00130   bool isInEcalCrack(double) const;
00131   std::string readZippedFile(const std::string& fileName)
00132   {
00133     //std::cout << "<PFRecoTauDiscriminationAgainstElectronMVA3::readZippedFile>:" << std::endl;
00134     //std::cout << " fileName = " << fileName << std::endl;
00135     // CV: code adapted from PhysicsTools/MVAComputer/src/MVAComputer.cc
00136     std::ifstream file;
00137     file.open(fileName.c_str());
00138     if ( !file.good() ) throw cms::Exception("InvalidFileState")
00139       << "Failed to open MVA file = " << fileName << " !!\n";
00140     std::ostringstream buffer_zipped;
00141     while ( file.good() ) {
00142       buffer_zipped << (char)file.get();
00143     }
00144     file.close();
00145     //std::cout << " buffer (zipped) = " << buffer_zipped.str() << std::endl;
00146     ext::izstream gunzip(&file);
00147     std::ostringstream buffer_unzipped;
00148     buffer_unzipped << gunzip.rdbuf();
00149     //std::cout << " buffer (unzipped) = " << buffer_unzipped.str() << std::endl;
00150     return buffer_unzipped.str();
00151   }
00152 
00153   std::string moduleLabel_;
00154   std::string method_ ;
00155   edm::FileInPath inputFileName1prongNoEleMatchWOgWOgsfBL_;
00156   edm::FileInPath inputFileName1prongNoEleMatchWOgWgsfBL_;
00157   edm::FileInPath inputFileName1prongNoEleMatchWgWOgsfBL_;
00158   edm::FileInPath inputFileName1prongNoEleMatchWgWgsfBL_;
00159   edm::FileInPath inputFileName1prongWOgWOgsfBL_;
00160   edm::FileInPath inputFileName1prongWOgWgsfBL_;
00161   edm::FileInPath inputFileName1prongWgWOgsfBL_;
00162   edm::FileInPath inputFileName1prongWgWgsfBL_;
00163   edm::FileInPath inputFileName1prongNoEleMatchWOgWOgsfEC_;
00164   edm::FileInPath inputFileName1prongNoEleMatchWOgWgsfEC_;
00165   edm::FileInPath inputFileName1prongNoEleMatchWgWOgsfEC_;
00166   edm::FileInPath inputFileName1prongNoEleMatchWgWgsfEC_;
00167   edm::FileInPath inputFileName1prongWOgWOgsfEC_;
00168   edm::FileInPath inputFileName1prongWOgWgsfEC_;
00169   edm::FileInPath inputFileName1prongWgWOgsfEC_;
00170   edm::FileInPath inputFileName1prongWgWgsfEC_;
00171   AntiElectronIDMVA3* mva_;
00172   bool returnMVA_ ;
00173   double minMVA1prongNoEleMatchWOgWOgsfBL_ ;
00174   double minMVA1prongNoEleMatchWOgWgsfBL_ ;
00175   double minMVA1prongNoEleMatchWgWOgsfBL_ ;
00176   double minMVA1prongNoEleMatchWgWgsfBL_ ;
00177   double minMVA1prongWOgWOgsfBL_ ;
00178   double minMVA1prongWOgWgsfBL_ ;
00179   double minMVA1prongWgWOgsfBL_ ;
00180   double minMVA1prongWgWgsfBL_ ;
00181   double minMVA1prongNoEleMatchWOgWOgsfEC_ ;
00182   double minMVA1prongNoEleMatchWOgWgsfEC_ ;
00183   double minMVA1prongNoEleMatchWgWOgsfEC_ ;
00184   double minMVA1prongNoEleMatchWgWgsfEC_ ;
00185   double minMVA1prongWOgWOgsfEC_ ;
00186   double minMVA1prongWOgWgsfEC_ ;
00187   double minMVA1prongWgWOgsfEC_ ;
00188   double minMVA1prongWgWgsfEC_ ;
00189   double minMVA3prongMatch_ ;
00190   double minMVA3prongNoMatch_ ;
00191   edm::InputTag srcGsfElectrons_;
00192   edm::Handle<reco::GsfElectronCollection> gsfElectrons_;
00193   edm::Handle<TauCollection> taus_;
00194   std::auto_ptr<PFTauDiscriminator> category_output_;
00195   size_t tauIndex_;
00196 };
00197 
00198 void PFRecoTauDiscriminationAgainstElectronMVA3::beginEvent(const edm::Event& evt, const edm::EventSetup& es)
00199 {
00200   if ( returnMVA_ ) {
00201     evt.getByLabel(TauProducer_, taus_);
00202     category_output_.reset(new PFTauDiscriminator(TauRefProd(taus_)));
00203     tauIndex_ = 0;
00204   }
00205   evt.getByLabel(srcGsfElectrons_, gsfElectrons_);
00206 }
00207 
00208 double PFRecoTauDiscriminationAgainstElectronMVA3::discriminate(const PFTauRef& thePFTauRef)
00209 {
00210   double mva = 1.;
00211   double workingPoint = 1.;
00212   double category = -1.;
00213   bool isGsfElectronMatched = false;
00214 
00215   //float deltaRTestigo = 9.9;
00216   //float mvaCutTestigo = 999;
00217 
00218   if( (*thePFTauRef).leadPFChargedHadrCand().isNonnull()) {
00219     for ( reco::GsfElectronCollection::const_iterator theGsfElectron = gsfElectrons_->begin();
00220           theGsfElectron != gsfElectrons_->end(); ++theGsfElectron ) {
00221       if ( theGsfElectron->pt() > 10. ) { // CV: only take electrons above some minimal energy/Pt into account...
00222         double deltaREleTau = deltaR(theGsfElectron->p4(), thePFTauRef->p4());
00223         //deltaRTestigo = deltaREleTau;
00224         if ( deltaREleTau < 0.3 ) {
00225           double mva_match = mva_->MVAValue(*thePFTauRef, *theGsfElectron);
00226           double workingPoint_match = 0.;
00227           size_t numSignalPFGammaCands = thePFTauRef->signalPFGammaCands().size();
00228           bool hasGsfTrack = thePFTauRef->leadPFChargedHadrCand()->gsfTrackRef().isNonnull();
00229   
00230           if ( thePFTauRef->signalPFChargedHadrCands().size() == 1 ) {
00232             Float_t TauEtaAtEcalEntrance = -99.;
00233             float sumEtaTimesEnergy = 0;
00234             float sumEnergy = 0;
00235             for(unsigned int j = 0 ; j < ((*thePFTauRef).signalPFCands()).size() ; j++){
00236               reco::PFCandidateRef pfcandidate = ((*thePFTauRef).signalPFCands()).at(j);
00237               sumEtaTimesEnergy += pfcandidate->positionAtECALEntrance().eta()*pfcandidate->energy();
00238               sumEnergy += pfcandidate->energy();
00239             }
00240             if(sumEnergy>0)TauEtaAtEcalEntrance = sumEtaTimesEnergy/sumEnergy;
00241             
00242             if (isInEcalCrack(TauEtaAtEcalEntrance)){
00243               if ( returnMVA_ ) {
00244                 // add category index
00245                 category_output_->setValue(tauIndex_, category);
00246                 ++tauIndex_;
00247                 // return MVA output value
00248                 return -99;
00249               } else {
00250                 //return Workingpoint 0
00251                 return 0;
00252               }
00253             }
00255 
00256             double mvaCut = 999.;
00257             if ( TMath::Abs(thePFTauRef->eta()) < 1.5 ) { // Barrel
00258               if        ( numSignalPFGammaCands == 0 && !hasGsfTrack ) {
00259                 category = 4.;
00260                 mvaCut = minMVA1prongWOgWOgsfBL_;
00261               } else if ( numSignalPFGammaCands == 0 &&  hasGsfTrack ) {
00262                 category = 5.;
00263                 mvaCut = minMVA1prongWOgWgsfBL_;
00264               } else if ( numSignalPFGammaCands >= 1 && !hasGsfTrack ) {
00265                 category = 6.;
00266                 mvaCut = minMVA1prongWgWOgsfBL_;
00267               } else if ( numSignalPFGammaCands >= 1 &&  hasGsfTrack ) {
00268                 category = 7.;
00269                 mvaCut = minMVA1prongWgWgsfBL_;
00270               }
00271             } else { // Endcap
00272               if       ( numSignalPFGammaCands == 0 && !hasGsfTrack ) {
00273                 category = 12.;
00274                 mvaCut = minMVA1prongWOgWOgsfEC_;
00275               } else if ( numSignalPFGammaCands == 0 &&  hasGsfTrack ) {
00276                 category = 13.;
00277                 mvaCut = minMVA1prongWOgWgsfEC_;
00278               } else if ( numSignalPFGammaCands >= 1 && !hasGsfTrack ) {
00279                 category = 14.;
00280                 mvaCut = minMVA1prongWgWOgsfEC_;
00281               } else if ( numSignalPFGammaCands >= 1 &&  hasGsfTrack ) {
00282                 category = 15.;
00283                 mvaCut = minMVA1prongWgWgsfEC_;
00284               }
00285             }
00286             workingPoint_match = (mva_match > mvaCut);
00287             //mvaCutTestigo = mvaCut;
00288           } else {
00289             category = 16.;
00290             workingPoint_match = (mva_match > minMVA3prongMatch_);
00291           }
00292           mva = TMath::Min(mva, mva_match);
00293           workingPoint = TMath::Min(workingPoint, workingPoint_match);
00294           isGsfElectronMatched = true;
00295         }//deltaR<0.3
00296       }//electron pt>10
00297     }//loop electrons
00298 
00299     if ( !isGsfElectronMatched ) {
00300       mva = mva_->MVAValue(*thePFTauRef);
00301       size_t numSignalPFGammaCands = thePFTauRef->signalPFGammaCands().size();
00302       bool hasGsfTrack = thePFTauRef->leadPFChargedHadrCand()->gsfTrackRef().isNonnull();
00303       if ( thePFTauRef->signalPFChargedHadrCands().size() == 1 ) {
00305         Float_t TauEtaAtEcalEntrance = -99.;
00306         float sumEtaTimesEnergy = 0;
00307         float sumEnergy = 0;
00308         for(unsigned int j = 0 ; j < ((*thePFTauRef).signalPFCands()).size() ; j++){
00309           reco::PFCandidateRef pfcandidate = ((*thePFTauRef).signalPFCands()).at(j);
00310           sumEtaTimesEnergy += pfcandidate->positionAtECALEntrance().eta()*pfcandidate->energy();
00311           sumEnergy += pfcandidate->energy();
00312         }
00313         if(sumEnergy>0)TauEtaAtEcalEntrance = sumEtaTimesEnergy/sumEnergy;
00314         
00315         if (isInEcalCrack(TauEtaAtEcalEntrance)){
00316           if ( returnMVA_ ) {
00317             // add category index
00318             category_output_->setValue(tauIndex_, category);
00319             ++tauIndex_;
00320             // return MVA output value
00321             return -99;
00322           } else {
00323             //return Workingpoint 0
00324             return 0;
00325           }
00326         }
00328 
00329         double mvaCut = 999.;
00330         if ( TMath::Abs(thePFTauRef->eta()) < 1.5 ) { // Barrel
00331           if        ( numSignalPFGammaCands == 0 && !hasGsfTrack ) {
00332             category = 0.;
00333             mvaCut = minMVA1prongNoEleMatchWOgWOgsfBL_;
00334           } else if ( numSignalPFGammaCands == 0 &&  hasGsfTrack ) {
00335             category = 1.;
00336             mvaCut = minMVA1prongNoEleMatchWOgWgsfBL_;
00337           } else if ( numSignalPFGammaCands >= 1 && !hasGsfTrack ) {
00338             category = 2.;
00339             mvaCut = minMVA1prongNoEleMatchWgWOgsfBL_;
00340           } else if ( numSignalPFGammaCands >= 1 &&  hasGsfTrack ) {
00341             category = 3.;
00342             mvaCut = minMVA1prongNoEleMatchWgWgsfBL_;
00343           }
00344         } else { // Endcap
00345           if        ( numSignalPFGammaCands == 0 && !hasGsfTrack ) {
00346             category = 8.;
00347             mvaCut = minMVA1prongNoEleMatchWOgWOgsfEC_;
00348           } else if ( numSignalPFGammaCands == 0 &&  hasGsfTrack ) {
00349             category = 9.;
00350             mvaCut = minMVA1prongNoEleMatchWOgWgsfEC_;
00351           } else if ( numSignalPFGammaCands >= 1 && !hasGsfTrack ) {
00352             category = 10.;
00353             mvaCut = minMVA1prongNoEleMatchWgWOgsfEC_;
00354           } else if ( numSignalPFGammaCands >= 1 &&  hasGsfTrack ) {
00355             category = 11.;
00356             mvaCut = minMVA1prongNoEleMatchWgWgsfEC_;
00357           }
00358         }
00359         workingPoint = (mva > mvaCut);
00360         //mvaCutTestigo = mvaCut;
00361       } else {
00362         category = 17.; 
00363         workingPoint = (mva > minMVA3prongNoMatch_);
00364       }
00365     }
00366   }
00367 
00368   // std::cout<<" Taus : "<<TauProducer_<<std::endl;
00369   // std::cout << "<PFRecoTauDiscriminationAgainstElectronMVA3::discriminate>:" << std::endl;
00370   // std::cout << " tau: Pt = " << thePFTauRef->pt() << ", eta = " << thePFTauRef->eta() << ", phi = " << thePFTauRef->phi() << std::endl;
00371   // std::cout << " mva = " << mva <<  " mvaCut = " << mvaCutTestigo <<" isGsfElectronMatched = "<<isGsfElectronMatched<< std::endl;
00372   // std::cout << " category = " << category << " : workingPoint = " << workingPoint << std::endl;
00373   // std::cout << " deltaREleTau = " << deltaRTestigo << std::endl;
00374   // std::cout << " charged hadron in tau : "<<(*thePFTauRef).leadPFChargedHadrCand().isNonnull()<< std::endl;
00375   // std::cout << " Prongs in tau : "<<thePFTauRef->signalPFChargedHadrCands().size()<< std::endl;
00376 
00377   if ( returnMVA_ ) {
00378     // add category index
00379     category_output_->setValue(tauIndex_, category);
00380     ++tauIndex_;
00381     // return MVA output value
00382     return mva;
00383   } else {
00384     return workingPoint;
00385   }
00386 }
00387 
00388 void PFRecoTauDiscriminationAgainstElectronMVA3::endEvent(edm::Event& evt)
00389 {
00390   // add all category indices to event
00391   if ( returnMVA_ ) {
00392     evt.put(category_output_, "category");
00393   }
00394 }
00395 
00396 bool
00397 PFRecoTauDiscriminationAgainstElectronMVA3::isInEcalCrack(double eta) const
00398 {
00399   eta = fabs(eta);
00400   return (eta>1.460 && eta<1.558);
00401 }
00402 
00403 DEFINE_FWK_MODULE(PFRecoTauDiscriminationAgainstElectronMVA3);
/data/refman/pasoursint/CMSSW_6_1_2_SLHC2/src/RecoTauTag/RecoTau/plugins/PFRecoTauDiscriminationAgainstElectronMVA3.cc
