Reference Manual

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 //
00003 // Package:    ZeeCandidateFilter
00004 // Class:      ZeeCandidateFilter
00005 //
00054 #ifndef ZeeCandidateFilter_H
00055 #define ZeeCandidateFilter_H
00056 
00057 // System include files
00058 #include <memory>
00059 
00060 // User include files
00061 #include "FWCore/Framework/interface/Frameworkfwd.h"
00062 #include "FWCore/Framework/interface/EDFilter.h"
00063 
00064 #include "FWCore/Framework/interface/Event.h"
00065 #include "FWCore/Framework/interface/MakerMacros.h"
00066 
00067 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00068 
00069 #include <vector>
00070 #include <iostream>
00071 #include "FWCore/Utilities/interface/InputTag.h"
00072 #include "DataFormats/PatCandidates/interface/Electron.h"
00073 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
00074 #include "DataFormats/Common/interface/TriggerResults.h"
00075 #include "FWCore/Common/interface/TriggerNames.h"
00076 
00077 #include "TString.h"
00078 #include "TMath.h"
00079 #include "DataFormats/PatCandidates/interface/MET.h"
00080 #include "DataFormats/PatCandidates/interface/CompositeCandidate.h"
00081 #include "DataFormats/PatCandidates/interface/TriggerObject.h"
00082 
00083 // For conversion finder
00084 #include "RecoEgamma/EgammaTools/interface/ConversionFinder.h"
00085 #include "FWCore/Framework/interface/ESHandle.h"
00086 #include "MagneticField/Engine/interface/MagneticField.h"
00087 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
00088 #include "DataFormats/GeometryVector/interface/GlobalPoint.h"
00089 //
00090 #include "DataFormats/Scalers/interface/DcsStatus.h"
00091 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
00092 //#include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h"
00093 #include "RecoEcal/EgammaCoreTools/interface/EcalTools.h"
00094 #include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
00095 #include "DataFormats/VertexReco/interface/Vertex.h"
00096 
00097 
00098 //  Class Declaration
00099 //  -----------------
00100 //
00101 class ZeeCandidateFilter : public edm::EDFilter {
00102 
00103 public:
00104 
00105     explicit ZeeCandidateFilter(const edm::ParameterSet&);
00106 
00107     ~ZeeCandidateFilter();
00108 
00109 private:
00110 
00111     virtual Bool_t filter(edm::Event&, const edm::EventSetup&);
00112 
00113     virtual void endJob() ;
00114 
00115     Bool_t isInFiducial(Double_t eta);
00116 
00117     //Bool_t passEleIDCuts(pat::Electron *ele);
00118 
00119     //  -----   Data Members    -----
00120 
00121     Double_t                    ETCut_                                      ;
00122     Double_t                    METCut_                                     ;
00123 
00124     Bool_t                      useEcalDrivenElectrons_                     ;
00125 
00126     /*  Electron 1  */
00127     Bool_t                      useValidFirstPXBHit1_                       ;
00128     Bool_t                      calculateValidFirstPXBHit1_                 ;
00129     Bool_t                      useConversionRejection1_                    ;
00130     Bool_t                      calculateConversionRejection1_              ;
00131     Bool_t                      useExpectedMissingHits1_                    ;
00132     Bool_t                      calculateExpectedMissingHits1_              ;
00133     Int_t                       maxNumberOfExpectedMissingHits1_            ;
00134 
00135     /*  Electron 2  */
00136     Bool_t                      useValidFirstPXBHit2_                       ;
00137     Bool_t                      calculateValidFirstPXBHit2_                 ;
00138     Bool_t                      useConversionRejection2_                    ;
00139     Bool_t                      calculateConversionRejection2_              ;
00140     Bool_t                      useExpectedMissingHits2_                    ;
00141     Bool_t                      calculateExpectedMissingHits2_              ;
00142     Int_t                       maxNumberOfExpectedMissingHits2_            ;
00143 
00144     /*  Electron 1  */
00145     Double_t                    dist1_                                      ;
00146     Double_t                    dcot1_                                      ;
00147 
00148     /*  Electron 2  */
00149     Double_t                    dist2_                                      ;
00150     Double_t                    dcot2_                                      ;
00151 
00152     Bool_t                      dataMagneticFieldSetUp_                     ;
00153 
00154     edm::InputTag               dcsTag_                                     ;
00155 
00156     Double_t                    BarrelMaxEta_                               ;
00157     Double_t                    EndCapMaxEta_                               ;
00158     Double_t                    EndCapMinEta_                               ;
00159 
00160     std::string                 hltpath_                                    ;
00161     edm::InputTag               triggerCollectionTag_                       ;
00162     edm::InputTag               triggerEventTag_                            ;
00163     edm::InputTag               hltpathFilter_                              ;
00164     Bool_t                      useHLTObjectETCut_                          ;
00165 
00166     Double_t                    hltObjectETCut_                             ;
00167 
00168     Bool_t                      useExtraTrigger_                            ;
00169 
00170     std::vector<std::string>    vHltpathExtra_                              ;
00171     std::vector<edm::InputTag>  vHltpathFilterExtra_                        ;
00172 
00173     Bool_t                      useTriggerInfo_                             ;
00174     Bool_t                      electronMatched2HLT_                        ;
00175     Double_t                    electronMatched2HLT_DR_                     ;
00176 
00177     edm::InputTag               electronCollectionTag_                      ;
00178 
00179     edm::InputTag               metCollectionTag_                           ;
00180     edm::InputTag               pfMetCollectionTag_                         ;
00181     edm::InputTag               tcMetCollectionTag_                         ;
00182 
00183     edm::InputTag               PrimaryVerticesCollection_                  ;
00184 
00185     edm::InputTag               ebRecHits_                                  ;
00186 //     edm::InputTag               eeRecHits_                                  ;
00187 
00188     Bool_t                      useSpikeRejection_                          ;
00189 
00190     Double_t                    spikeCleaningSwissCrossCut_                 ;
00191 
00192 };
00193 
00194 #endif
00195 
00196 //  Constants, Enums and Typedefs
00197 //  -----------------------------
00198 //
00199 
00200 //  Static Data Member Definitions
00201 //  ------------------------------
00202 //
00203 
00204 //  Constructors and Destructor
00205 //  ---------------------------
00206 //
00207 ZeeCandidateFilter::ZeeCandidateFilter(const edm::ParameterSet& iConfig)
00208 {
00209     //
00210     //-------------------------------------//
00211     //         INITIALIZATION              //
00212     //-------------------------------------//
00213     //
00214 
00215 
00216     //  Cuts
00217     //  ----
00218     ETCut_  = iConfig.getUntrackedParameter<Double_t>("ETCut");
00219     METCut_ = iConfig.getUntrackedParameter<Double_t>("METCut");
00220 
00221     useEcalDrivenElectrons_ = iConfig.getUntrackedParameter<Bool_t>("useEcalDrivenElectrons", false);
00222     //--------------------------------------------------------------------------------------------------------------------
00223 
00224 
00225     //  Preselection Criteria: Hit Pattern
00226     //  ----------------------------------
00227     //
00228     /*  Electron 1  */
00229     useValidFirstPXBHit1_             =  iConfig.getUntrackedParameter<Bool_t>("useValidFirstPXBHit1",false);
00230     calculateValidFirstPXBHit1_       =  iConfig.getUntrackedParameter<Bool_t>("calculateValidFirstPXBHit1",false);
00231     useConversionRejection1_          =  iConfig.getUntrackedParameter<Bool_t>("useConversionRejection1",false);
00232     calculateConversionRejection1_    =  iConfig.getUntrackedParameter<Bool_t>("calculateConversionRejection1",false);
00233     useExpectedMissingHits1_          =  iConfig.getUntrackedParameter<Bool_t>("useExpectedMissingHits1",false);
00234     calculateExpectedMissingHits1_    =  iConfig.getUntrackedParameter<Bool_t>("calculateExpectedMissingHits1",false);
00235     maxNumberOfExpectedMissingHits1_  =  iConfig.getUntrackedParameter<Int_t>("maxNumberOfExpectedMissingHits1",1);
00236     //
00237     /*  Electron 2  */
00238     useValidFirstPXBHit2_             =  iConfig.getUntrackedParameter<Bool_t>("useValidFirstPXBHit2",false);
00239     calculateValidFirstPXBHit2_       =  iConfig.getUntrackedParameter<Bool_t>("calculateValidFirstPXBHit2",false);
00240     useConversionRejection2_          =  iConfig.getUntrackedParameter<Bool_t>("useConversionRejection2",false);
00241     calculateConversionRejection2_    =  iConfig.getUntrackedParameter<Bool_t>("calculateConversionRejection2",false);
00242     useExpectedMissingHits2_          =  iConfig.getUntrackedParameter<Bool_t>("useExpectedMissingHits2",false);
00243     calculateExpectedMissingHits2_    =  iConfig.getUntrackedParameter<Bool_t>("calculateExpectedMissingHits2",false);
00244     maxNumberOfExpectedMissingHits2_  =  iConfig.getUntrackedParameter<Int_t>("maxNumberOfExpectedMissingHits2",1);
00245     //--------------------------------------------------------------------------------------------------------------------
00246 
00247 
00248     //  Conversion Rejection Variables
00249     //  ------------------------------
00250     //
00251     /*  Electron 1  */
00252     Double_t dist1_D  = 0.02 ;
00253     Double_t dcot1_D  = 0.02 ;
00254     //
00255     dist1_ = iConfig.getUntrackedParameter<Double_t>("conversionRejectionDist1", dist1_D);
00256     dcot1_ = iConfig.getUntrackedParameter<Double_t>("conversionRejectionDcot1", dcot1_D);
00257     //
00258     /*  Electron 2  */
00259     Double_t dist2_D  = 0.02 ;
00260     Double_t dcot2_D  = 0.02 ;
00261     //
00262     dist2_ = iConfig.getUntrackedParameter<Double_t>("conversionRejectionDist2", dist2_D);
00263     dcot2_ = iConfig.getUntrackedParameter<Double_t>("conversionRejectionDcot2", dcot2_D);
00264     //--------------------------------------------------------------------------------------------------------------------
00265 
00266 
00267     //  Magnetic Field
00268     //  --------------
00269     //
00270     dataMagneticFieldSetUp_ = iConfig.getUntrackedParameter<Bool_t>("dataMagneticFieldSetUp",false);
00271 
00272     if ( dataMagneticFieldSetUp_ ) {
00273         dcsTag_ = iConfig.getUntrackedParameter<edm::InputTag>("dcsTag");
00274     }
00275     //--------------------------------------------------------------------------------------------------------------------
00276 
00277 
00278     //  Detector Fiducial Cuts
00279     //  ----------------------
00280     //
00281     Double_t BarrelMaxEta_D = 1.4442 ;
00282     Double_t EndCapMinEta_D = 1.5660 ;
00283     Double_t EndCapMaxEta_D = 2.5000 ;
00284 
00285     BarrelMaxEta_ = iConfig.getUntrackedParameter<Double_t>("BarrelMaxEta", BarrelMaxEta_D);
00286     EndCapMaxEta_ = iConfig.getUntrackedParameter<Double_t>("EndCapMaxEta", EndCapMaxEta_D);
00287     EndCapMinEta_ = iConfig.getUntrackedParameter<Double_t>("EndCapMinEta", EndCapMinEta_D);
00288     //--------------------------------------------------------------------------------------------------------------------
00289 
00290 
00291     //  Trigger Related
00292     //  ---------------
00293     //
00294     hltpath_              = iConfig.getUntrackedParameter<std::string>("hltpath");
00295     triggerCollectionTag_ = iConfig.getUntrackedParameter<edm::InputTag>("triggerCollectionTag");
00296     triggerEventTag_      = iConfig.getUntrackedParameter<edm::InputTag>("triggerEventTag");
00297     hltpathFilter_        = iConfig.getUntrackedParameter<edm::InputTag>("hltpathFilter");
00298     useHLTObjectETCut_    = iConfig.getUntrackedParameter<Bool_t>("useHLTObjectETCut", false);
00299 
00300     if ( useHLTObjectETCut_ ) {
00301         hltObjectETCut_     = iConfig.getUntrackedParameter<Double_t>("hltObjectETCut");
00302     }
00303 
00304     //  Dirty way to add a second trigger with OR, to be done properly in the next tag
00305     useExtraTrigger_ = iConfig.getUntrackedParameter<Bool_t>("useExtraTrigger");
00306 
00307     if ( useExtraTrigger_ ) {
00308 
00309         vHltpathExtra_       = iConfig.getUntrackedParameter< std::vector<std::string> >("vHltpathExtra");
00310         vHltpathFilterExtra_ = iConfig.getUntrackedParameter< std::vector<edm::InputTag> >("vHltpathFilterExtra");
00311 
00312         if ( Int_t(vHltpathExtra_.size()) != Int_t(vHltpathFilterExtra_.size()) ) {
00313             std::cout << "ZeeCandidateFilter: ERROR IN Configuration: vHltpathExtra and vHltpathFilterExtra" << " should have the same dimensions " << std::endl;
00314         }
00315     }
00316     //--------------------------------------------------------------------------------------------------------------------
00317 
00318 
00319     //  Trigger Matching Related
00320     //  ------------------------
00321     //
00322     useTriggerInfo_         = iConfig.getUntrackedParameter<Bool_t>("useTriggerInfo",true);
00323     electronMatched2HLT_    = iConfig.getUntrackedParameter<Bool_t>("electronMatched2HLT");
00324     electronMatched2HLT_DR_ = iConfig.getUntrackedParameter<Double_t>("electronMatched2HLT_DR");
00325     //--------------------------------------------------------------------------------------------------------------------
00326 
00327 
00328     //  Electrons, MET's Vtx's and other
00329     //  --------------------------------
00330     //
00331     electronCollectionTag_  = iConfig.getUntrackedParameter<edm::InputTag>("electronCollectionTag");
00332 
00333     metCollectionTag_   = iConfig.getUntrackedParameter<edm::InputTag>("metCollectionTag");
00334     pfMetCollectionTag_ = iConfig.getUntrackedParameter<edm::InputTag>("pfMetCollectionTag");
00335     tcMetCollectionTag_ = iConfig.getUntrackedParameter<edm::InputTag>("tcMetCollectionTag");
00336 
00337     PrimaryVerticesCollection_ = iConfig.getUntrackedParameter<edm::InputTag>("PrimaryVerticesCollection");
00338 
00339     ebRecHits_ = iConfig.getUntrackedParameter<edm::InputTag>("ebRecHits");
00340 //     eeRecHits_ = iConfig.getUntrackedParameter<edm::InputTag>("eeRecHits");
00341     //--------------------------------------------------------------------------------------------------------------------
00342 
00343 
00344     //  Spike Cleaning
00345     //  --------------
00346     //
00347     useSpikeRejection_ = iConfig.getUntrackedParameter<Bool_t>("useSpikeRejection");
00348 
00349     if ( useSpikeRejection_ ) {
00350         spikeCleaningSwissCrossCut_ = iConfig.getUntrackedParameter<Double_t>("spikeCleaningSwissCrossCut");
00351     }
00352     //--------------------------------------------------------------------------------------------------------------------
00353 
00354 
00355     //
00356     //-------------------------------------//
00357     //         SUMMARY PRINTOUT            //
00358     //-------------------------------------//
00359     //
00360 
00361     std::cout << "ZeeCandidateFilter: Running Zee Filter..." << std::endl;
00362 
00363     if ( useTriggerInfo_ ) {
00364         std::cout << "ZeeCandidateFilter: HLT Path   " << hltpath_       << std::endl;
00365         std::cout << "ZeeCandidateFilter: HLT Filter " << hltpathFilter_ << std::endl;
00366 
00367         if ( useExtraTrigger_ ) {
00368             for (Int_t itrig=0; itrig < (Int_t)vHltpathExtra_.size(); ++itrig ) {
00369 
00370                 std::cout << "ZeeCandidateFilter: OR " << vHltpathExtra_[itrig] << " with filter: " << vHltpathFilterExtra_[itrig] << std::endl;
00371             }
00372         }
00373     }
00374     else {
00375         std::cout << "ZeeCandidateFilter: Trigger info will not be used here" << std::endl;
00376     }
00377 
00378     std::cout << "ZeeCandidateFilter: ET  > " << ETCut_ << std::endl;
00379     std::cout << "ZeeCandidateFilter: MET > " << METCut_ << std::endl;
00380 
00381 
00382     if ( useEcalDrivenElectrons_ ) {
00383         std::cout << "ZeeCandidateFilter: Electron Candidate(s) is required to be ecal driven" << std::endl;
00384     }
00385 
00386     if ( electronMatched2HLT_ && useTriggerInfo_ ) {
00387         std::cout << "ZeeCandidateFilter: At least one electron is required to match an HLT object with DR < " << electronMatched2HLT_DR_ << std::endl;
00388     }
00389     else {
00390         std::cout << "ZeeCandidateFilter: Electron Candidates NOT required to match HLT object " << std::endl;
00391     }
00392 
00393     if ( useValidFirstPXBHit1_ ) {
00394         std::cout << "ZeeCandidateFilter: Electron Candidate #1 required to have a valid hit in 1st PXB layer " << std::endl;
00395     }
00396 
00397     if ( useValidFirstPXBHit2_ ) {
00398         std::cout << "ZeeCandidateFilter: Electron Candidate #2 required to have a valid hit in 1st PXB layer " << std::endl;
00399     }
00400 
00401     if ( calculateValidFirstPXBHit1_ ) {
00402         std::cout << "ZeeCandidateFilter: Info about whether there is a valid 1st layer PXB hit for electron candidate #1 will be stored: you can access that later by myElec.userInt(\"PassValidFirstPXBHit\")==1" << std::endl;
00403     }
00404 
00405     if ( calculateValidFirstPXBHit2_ ) {
00406         std::cout << "ZeeCandidateFilter: Info about whether there is a valid 1st layer PXB hit for electron candidate #2 will be stored: you can access that later by myElec.userInt(\"PassValidFirstPXBHit\")==1" << std::endl;
00407     }
00408 
00409     if ( useExpectedMissingHits1_ ) {
00410         std::cout << "ZeeCandidateFilter: Electron Candidate #1 is required to have less than " << maxNumberOfExpectedMissingHits1_ << " expected hits missing " << std::endl;
00411     }
00412 
00413     if ( useExpectedMissingHits2_ ) {
00414         std::cout << "ZeeCandidateFilter: Electron Candidate #2 is required to have less than " << maxNumberOfExpectedMissingHits2_ << " expected hits missing " << std::endl;
00415     }
00416 
00417     if ( calculateExpectedMissingHits1_ ) {
00418         std::cout << "ZeeCandidateFilter: Missing Hits from expected inner layers for electron candidate #1 will be calculated and stored: you can access them later by myElec.userInt(\"NumberOfExpectedMissingHits\")"   << std::endl;
00419     }
00420 
00421     if ( calculateExpectedMissingHits2_ ) {
00422         std::cout << "ZeeCandidateFilter: Missing Hits from expected inner layers for electron candidate #2 will be calculated and stored: you can access them later by myElec.userInt(\"NumberOfExpectedMissingHits\")"   << std::endl;
00423     }
00424 
00425     if ( useConversionRejection1_ ) {
00426         std::cout << "ZeeCandidateFilter: Electron Candidate #1 is required to pass EGAMMA Conversion Rejection criteria" << std::endl;
00427     }
00428 
00429     if ( useConversionRejection2_ ) {
00430         std::cout << "ZeeCandidateFilter: Electron Candidate #2 is required to pass EGAMMA Conversion Rejection criteria" << std::endl;
00431     }
00432 
00433     if ( calculateConversionRejection1_ ) {
00434         std::cout << "ZeeCandidateFilter: EGAMMA Conversion Rejection criteria for electron candidate #1 will be calculated and stored: you can access them later by demanding for a successful electron myElec.userInt(\"PassConversionRejection\")==1" << std::endl;
00435     }
00436 
00437     if ( calculateConversionRejection2_ ) {
00438         std::cout << "ZeeCandidateFilter: EGAMMA Conversion Rejection criteria for electron candidate #2 will be calculated and stored: you can access them later by demanding for a successful electron myElec.userInt(\"PassConversionRejection\")==1" << std::endl;
00439     }
00440 
00441     if ( dataMagneticFieldSetUp_ ) {
00442         std::cout << "ZeeCandidateFilter: Data Configuration for Magnetic Field DCS tag " << dcsTag_  << std::endl;
00443     }
00444 
00445     if ( useSpikeRejection_ ) {
00446         std::cout << "ZeeCandidateFilter: Spike Cleaning will be done with the Swiss Cross Criterion cutting at " << spikeCleaningSwissCrossCut_ << std::endl;
00447     }
00448 
00449     std::cout << "ZeeCandidateFilter: Fiducial Cut: "                                                      << std::endl;
00450     std::cout << "ZeeCandidateFilter:    BarrelMax: " << BarrelMaxEta_                                     << std::endl;
00451     std::cout << "ZeeCandidateFilter:    EndcapMin: " << EndCapMinEta_ << "  EndcapMax: " << EndCapMaxEta_ << std::endl;
00452 
00453     //
00454     //------------------------------------------//
00455     //         EXTRA INFO IN THE EVENT          //
00456     //------------------------------------------//
00457     //
00458     produces<pat::CompositeCandidateCollection>("selectedZeeCandidates").setBranchAlias("selectedZeeCandidates");
00459 
00460 }
00461 
00462 
00463 ZeeCandidateFilter::~ZeeCandidateFilter()
00464 {
00465     // do anything here that needs to be done at desctruction time
00466     // (e.g. close files, deallocate resources etc.)
00467 }
00468 
00469 
00470 //  Member Functions
00471 //  ----------------
00472 //
00473 
00474 // ------------ method called on each new Event  ------------
00475 Bool_t ZeeCandidateFilter::filter(edm::Event& iEvent, const edm::EventSetup& iSetup)
00476 {
00477     using namespace edm;
00478     using namespace std;
00479     using namespace pat;
00480 
00481 
00482     std::cout << "FILTER-MSG: Begin Processing ... "
00483               << "Run = "   << iEvent.run() << " " 
00484               << "Lumi = "  << (Int_t) iEvent.luminosityBlock() << " " 
00485               << "Event = " << iEvent.eventAuxiliary().event() << " " 
00486               << std::endl;
00487 
00488 
00489     /***    TRIGGER REQUIREMENT - Event should pass the trigger, otherwise no zee candidate     ***/
00490 
00491     edm::Handle<edm::TriggerResults> HLTResults;
00492     iEvent.getByLabel(triggerCollectionTag_, HLTResults);
00493 
00494     Int_t passTrigger = 0;
00495 
00496     if ( HLTResults.isValid() ) {
00497 
00498         const edm::TriggerNames & triggerNames = iEvent.triggerNames(*HLTResults);
00499 
00500         UInt_t trigger_size     = HLTResults->size();
00501         UInt_t trigger_position = triggerNames.triggerIndex(hltpath_);
00502         UInt_t trigger_position_extra;
00503         
00504         if ( trigger_position < trigger_size ) {
00505             passTrigger = (Int_t)HLTResults->accept(trigger_position);
00506         }
00507             
00508         //  Tested TriggerPath firing results printout
00509         std::cout << "SK_HLT_INFO"
00510                   << " | " << "trigger_size = "         << trigger_size 
00511                   << " | " << "hltpath_ = "             << hltpath_ 
00512                   << " | " << "trigger_position = "     << trigger_position 
00513                   << " | " << "passTrigger = "          << passTrigger
00514         << std::endl;        
00515 
00516         if ( useExtraTrigger_ && passTrigger==0 ) {
00517             for (Int_t itrig=0; itrig < (Int_t)vHltpathExtra_.size(); ++itrig ) {
00518                 trigger_position_extra = triggerNames.triggerIndex(vHltpathExtra_[itrig]);
00519 
00520                 if ( trigger_position_extra < trigger_size ) {
00521                     passTrigger = (Int_t)HLTResults->accept(trigger_position_extra);
00522                 }
00523                 
00524                 //  Tested TriggerPath firing results printout
00525                 std::cout << "SK_HLT_INFO"
00526                           << " | " << "vHltpathExtra_[" << itrig << "] = "      << vHltpathExtra_[itrig] 
00527                           << " | " << "trigger_position_extra = "               << trigger_position_extra 
00528                           << " | " << "passTrigger = "                          << passTrigger
00529                           << " | " << "vHltpathExtra_.size() = "                << vHltpathExtra_.size()
00530                 << std::endl;
00531 
00532                 if ( passTrigger > 0 ) { break ; }
00533                 
00534             }   //  for Loop
00535             
00536         }   // if ( useExtraTrigger_ && passTrigger==0 )
00537         
00538     }
00539     else {  std::cout << "TriggerResults are missing from this event.." << std::endl;
00540         if ( useTriggerInfo_ ) {
00541             return false;    // RETURN if trigger is missing
00542         }
00543     }
00544 
00545     if ( passTrigger == 0 && useTriggerInfo_ ) {    std::cout << "No HLT Path is firing in this event" << std::endl;
00546         return false; // RETURN if event fails the trigger
00547     }
00548     
00549 
00550     edm::Handle<trigger::TriggerEvent> pHLT;
00551     iEvent.getByLabel(triggerEventTag_, pHLT);
00552 
00553     const Int_t nF(pHLT->sizeFilters());
00554     const Int_t filterInd = pHLT->filterIndex(hltpathFilter_);
00555 
00556     std::vector<Int_t> filterIndExtra;
00557 
00558     if ( useExtraTrigger_ ) {
00559         for (Int_t itrig =0; itrig < (Int_t)vHltpathFilterExtra_.size(); ++itrig ) {     std::cout << "working on #" << itrig << std::endl; std::cout << "  ---> " << vHltpathFilterExtra_[itrig] << std::endl;
00560             filterIndExtra.push_back( pHLT->filterIndex(vHltpathFilterExtra_[itrig]) );
00561         }
00562     }
00563 
00564     Bool_t finalpathfound = false;
00565 
00566     if ( nF != filterInd ) {
00567         finalpathfound = true;
00568     }
00569     else {
00570         for (Int_t itrig=0; itrig < (Int_t)filterIndExtra.size(); ++itrig ) {    std::cout << "working on #" << itrig << std::endl; std::cout << "  ---> " << filterIndExtra[itrig] << std::endl;
00571             if ( nF != filterIndExtra[itrig] ) {
00572                 finalpathfound = true;
00573                 break;
00574             }
00575         }
00576     }
00577 
00578     if ( ! finalpathfound ) {   std::cout << "No HLT Filter was not found in this event..." << std::endl;
00579         if ( useTriggerInfo_ ) {
00580             return false;    // RETURN if event fails the trigger
00581         }
00582     }
00583 
00584     const trigger::TriggerObjectCollection& TOC(pHLT->getObjects());
00585 
00586     /***    ET CUT: At least one electron in the event with ET > ETCut_     ***/
00587 
00588     //  Electron Collection
00589     edm::Handle<pat::ElectronCollection> patElectron;
00590     iEvent.getByLabel(electronCollectionTag_, patElectron);
00591 
00592     if ( ! patElectron.isValid() ) {    std::cout << "No electrons found in this event with tag " << electronCollectionTag_  << std::endl;
00593         return false; // RETURN if no elecs in the event
00594     }
00595 
00596     const pat::ElectronCollection *pElecs = patElectron.product();
00597 
00598 //     // MET Collection                                            ->  relocated block bellow
00599 //     edm::Handle<pat::METCollection> patMET;
00600 //     iEvent.getByLabel(metCollectionTag_,   patMET);
00601 //
00602 //     edm::Handle<pat::METCollection> patpfMET;
00603 //     iEvent.getByLabel(pfMetCollectionTag_, patpfMET);
00604 //
00605 //     edm::Handle<pat::METCollection> pattcMET;
00606 //     iEvent.getByLabel(tcMetCollectionTag_, pattcMET);
00607 
00608     //
00609     // Note: best to do Duplicate removal here, since the current
00610     // implementation does not remove triplicates
00611     // duplicate removal is on at PAT, but does it remove triplicates?
00612     //
00613 
00614 //     pat::ElectronCollection::const_iterator elec;   //  relocated bellow
00615 
00616     // check how many electrons there are in the event
00617     const Int_t Nelecs = pElecs->size();
00618 
00619     if ( Nelecs <= 1 ) {    std::cout << "No more than 1 electrons found in this event" << std::endl;
00620         return false; // RETURN if less than 2 elecs in the event
00621     }
00622 
00623     //  Order your electrons: first the ones with the higher ET
00624     Int_t  counter = 0;
00625     std::vector<Int_t> indices;
00626     std::vector<Double_t> ETs;
00627     pat::ElectronCollection myElectrons;
00628 
00629     for (pat::ElectronCollection::const_iterator elec = pElecs->begin(); elec != pElecs->end(); ++elec) {  //  the definition of  the electron ET is wrt Gsf track eta
00630         Double_t sc_et = elec->caloEnergy()/TMath::CosH(elec->gsfTrack()->eta());
00631         indices.push_back(counter);
00632         ETs.push_back(sc_et);
00633         myElectrons.push_back(*elec);
00634         ++counter;
00635     }
00636 
00637     const Int_t  event_elec_number = (Int_t)indices.size();
00638 
00639     if ( event_elec_number <= 1 ) {  std::cout << "No more than 1 electrons in fiducial were found" << std::endl;
00640         return false; // RETURN if no more than 1 electron in fiducial
00641     }
00642 
00643     //  Memory allocation (must be released every time we return back.
00644     Int_t *sorted = new Int_t[event_elec_number];
00645     Double_t *et = new Double_t[event_elec_number];
00646 
00647     for (Int_t i=0; i<event_elec_number; ++i ) {
00648         et[i] = ETs[i];
00649     }
00650 
00651     // array sorted now has the indices of the highest ET electrons
00652     TMath::Sort(event_elec_number, et, sorted, true);
00653     //
00654     // if the 2 highest electrons in the event has ET < ETCut_ return
00655     Int_t max_et_index1 = sorted[0];
00656     Int_t max_et_index2 = sorted[1];
00657 
00658     if ( ( ETs[max_et_index1] < ETCut_ ) || ( ETs[max_et_index2] < ETCut_ ) ) {
00659         delete [] sorted;
00660         delete [] et;
00661         return false; // RETURN: demand the highest ET electrons to have ET > ETcut
00662     }
00663 
00664     // my electrons now:
00665     pat::Electron maxETelec1 = myElectrons[max_et_index1];
00666     pat::Electron maxETelec2 = myElectrons[max_et_index2];
00667 
00668     // demand that they are in fiducial:
00669     if ( ! isInFiducial(maxETelec1.caloPosition().eta()) ) {
00670         delete [] sorted;
00671         delete [] et;
00672         return false; // RETURN highest ET electron is not in fiducial
00673     }
00674 
00675     if ( ! isInFiducial(maxETelec2.caloPosition().eta()) ) {
00676         delete [] sorted;
00677         delete [] et;
00678         return false; // RETURN 2nd highest ET electron is not in fiducial
00679     }
00680 
00681     // demand that they are ecal driven
00682     if ( useEcalDrivenElectrons_ ) {
00683         if ( ( ! maxETelec1.ecalDrivenSeed() ) || ( ! maxETelec2.ecalDrivenSeed() ) ) {
00684             delete [] sorted;
00685             delete [] et;
00686             return false; // RETURN At least one high ET electron is not ecal driven
00687         }
00688     }
00689 
00690     // spike rejection;
00691     if ( useSpikeRejection_ && maxETelec1.isEB() ) {
00692 
00693         edm::Handle<EcalRecHitCollection> recHits;
00694 
00695 //         if ( maxETelec1.isEB() ) {
00696 //             iEvent.getByLabel(ebRecHits_, recHits);
00697 //         }
00698 //         else {
00699 //             iEvent.getByLabel(eeRecHits_, recHits);
00700 //         }
00701 
00702         iEvent.getByLabel(ebRecHits_, recHits);
00703 
00704         const EcalRecHitCollection *myRecHits = recHits.product();
00705         const DetId seedId = maxETelec1.superCluster()->seed()->seed();
00706 
00707         Double_t swissCross = EcalTools::swissCross(seedId, *myRecHits,0.);
00708 
00709         if ( swissCross > spikeCleaningSwissCrossCut_ ) {
00710             delete [] sorted;
00711             delete [] et;
00712             return false; // RETURN highest ET electron is a spike
00713         }
00714     }
00715 
00716     if ( useSpikeRejection_ && maxETelec2.isEB() ) {
00717 
00718         edm::Handle<EcalRecHitCollection> recHits;
00719 
00720 //         if ( maxETelec2.isEB())  {
00721 //             iEvent.getByLabel(ebRecHits_, recHits);
00722 //         }
00723 //         else    {
00724 //             iEvent.getByLabel(eeRecHits_, recHits);
00725 //         }
00726 
00727         iEvent.getByLabel(ebRecHits_, recHits);
00728 
00729         const EcalRecHitCollection *myRecHits = recHits.product();
00730         const DetId seedId = maxETelec2.superCluster()->seed()->seed();
00731 
00732         Double_t swissCross = EcalTools::swissCross(seedId, *myRecHits,0.);
00733 
00734         if ( swissCross > spikeCleaningSwissCrossCut_ ) {
00735             delete [] sorted;
00736             delete [] et;
00737             return false; // RETURN 2nd highest ET electron is a spike
00738         }
00739     }
00740 
00741     // add the primary vtx information in the electron:
00742     edm::Handle< std::vector<reco::Vertex> > pVtx;
00743     iEvent.getByLabel(PrimaryVerticesCollection_, pVtx);
00744 
00745     const std::vector<reco::Vertex> Vtx = *(pVtx.product());
00746 
00747     Double_t pv_x = -999999.;
00748     Double_t pv_y = -999999.;
00749     Double_t pv_z = -999999.;
00750 
00751     Double_t ele_tip_pv1 = -999999.;
00752     Double_t ele_tip_pv2 = -999999.;
00753 
00754     if ( Vtx.size() >=1 ) {
00755         pv_x = Vtx[0].position().x();
00756         pv_y = Vtx[0].position().y();
00757         pv_z = Vtx[0].position().z();
00758         ele_tip_pv1 = (-1.0) * ( maxETelec1.gsfTrack()->dxy(Vtx[0].position()) ) ;
00759         ele_tip_pv2 = (-1.0) * ( maxETelec2.gsfTrack()->dxy(Vtx[0].position()) ) ;
00760     }
00761 
00762     maxETelec1.addUserFloat("pv_x", Float_t(pv_x));
00763     maxETelec1.addUserFloat("pv_x", Float_t(pv_y));
00764     maxETelec1.addUserFloat("pv_z", Float_t(pv_z));
00765     maxETelec1.addUserFloat("ele_tip_pv", Float_t(ele_tip_pv1));
00766 
00767     maxETelec2.addUserFloat("pv_x", Float_t(pv_x));
00768     maxETelec2.addUserFloat("pv_x", Float_t(pv_y));
00769     maxETelec2.addUserFloat("pv_z", Float_t(pv_z));
00770     maxETelec2.addUserFloat("ele_tip_pv", Float_t(ele_tip_pv2));
00771 
00772 //     Double_t pv_x1 = -999999.;
00773 //     Double_t pv_y1 = -999999.;
00774 //     Double_t pv_z1 = -999999.;
00775 //     Double_t ele_tip_pv1 = -999999.;
00776 //
00777 //     if ( Vtx.size() >=1 ) {
00778 //         pv_x1 = Vtx[0].position().x();
00779 //         pv_y1 = Vtx[0].position().y();
00780 //         pv_z1 = Vtx[0].position().z();
00781 //         ele_tip_pv1 = (-1.0) * ( maxETelec1.gsfTrack()->dxy(Vtx[0].position()) ) ;
00782 //     }
00783 //
00784 //     maxETelec1.addUserFloat("pv_x", Float_t(pv_x1));
00785 //     maxETelec1.addUserFloat("pv_x", Float_t(pv_y1));
00786 //     maxETelec1.addUserFloat("pv_z", Float_t(pv_z1));
00787 //     maxETelec1.addUserFloat("ele_tip_pv", Float_t(ele_tip_pv1));
00788 //
00789 //     edm::Handle< std::vector<reco::Vertex> > pVtx2;
00790 //     iEvent.getByLabel(PrimaryVerticesCollection_, pVtx2);
00791 //
00792 //     const std::vector<reco::Vertex> Vtx2 = *(pVtx2.product());
00793 //
00794 //     Double_t pv_x2 = -999999.;
00795 //     Double_t pv_y2 = -999999.;
00796 //     Double_t pv_z2 = -999999.;
00797 //     Double_t ele_tip_pv2 = -999999.;
00798 //
00799 //     if ( Vtx2.size() >=1 ) {
00800 //         pv_x2 = Vtx2[0].position().x();
00801 //         pv_y2 = Vtx2[0].position().y();
00802 //         pv_z2 = Vtx2[0].position().z();
00803 //         ele_tip_pv2 = -maxETelec2.gsfTrack()->dxy(Vtx2[0].position());
00804 //     }
00805 //
00806 //     maxETelec2.addUserFloat("pv_x", Float_t(pv_x1));
00807 //     maxETelec2.addUserFloat("pv_x", Float_t(pv_y1));
00808 //     maxETelec2.addUserFloat("pv_z", Float_t(pv_z1));
00809 //     maxETelec2.addUserFloat("ele_tip_pv", Float_t(ele_tip_pv2));
00810 
00811 
00812     //  Special pre-selection requirements (hit pattern and conversion rejection)
00813 
00814     if ( useValidFirstPXBHit1_ || calculateValidFirstPXBHit1_ ) {
00815 
00816         Bool_t fail = ( ! maxETelec1.gsfTrack()->hitPattern().hasValidHitInFirstPixelBarrel() ) ;
00817 
00818         if ( useValidFirstPXBHit1_ && fail ) {    std::cout << "Filter: there is no valid hit for electron #1 in 1st layer PXB" << std::endl;
00819             delete [] sorted;
00820             delete [] et;
00821             return false;
00822         }
00823 
00824         if ( calculateValidFirstPXBHit1_ ) {
00825 
00826             std::string vfpx("PassValidFirstPXBHit");
00827 
00828             if ( fail ) {
00829                 maxETelec1.addUserInt(vfpx,0);
00830             }
00831             else {
00832                 maxETelec1.addUserInt(vfpx,1);
00833             }
00834 
00835         }
00836 
00837     }
00838 
00839     if ( useValidFirstPXBHit2_ || calculateValidFirstPXBHit2_ ) {
00840 
00841         Bool_t fail = ( ! maxETelec2.gsfTrack()->hitPattern().hasValidHitInFirstPixelBarrel() );
00842 
00843         if ( useValidFirstPXBHit2_ && fail ) {   std::cout << "Filter: there is no valid hit for electron #1 in 1st layer PXB" << std::endl;
00844             delete [] sorted;
00845             delete [] et;
00846             return false;
00847         }
00848 
00849         if ( calculateValidFirstPXBHit2_ ) {
00850 
00851             std::string vfpx("PassValidFirstPXBHit");
00852 
00853             if ( fail ) {
00854                 maxETelec2.addUserInt(vfpx,0);
00855             }
00856             else {
00857                 maxETelec2.addUserInt(vfpx,1);
00858             }
00859 
00860         }
00861 
00862     }
00863 
00864     if ( useExpectedMissingHits1_ || calculateExpectedMissingHits1_ ) {
00865 
00866         Int_t numberOfInnerHits = (Int_t)( maxETelec1.gsfTrack()->trackerExpectedHitsInner().numberOfHits() );
00867 
00868         if ( ( numberOfInnerHits > maxNumberOfExpectedMissingHits1_ ) && useExpectedMissingHits1_ ) {
00869             delete [] sorted;
00870             delete [] et;
00871             return false;
00872         }
00873 
00874         if ( calculateExpectedMissingHits1_ ) {
00875             maxETelec1.addUserInt("NumberOfExpectedMissingHits",numberOfInnerHits);
00876         }
00877 
00878     }
00879 
00880     if ( useExpectedMissingHits2_ || calculateExpectedMissingHits2_ ) {
00881 
00882         Int_t numberOfInnerHits = (Int_t)( maxETelec2.gsfTrack()->trackerExpectedHitsInner().numberOfHits() );
00883 
00884         if ( ( numberOfInnerHits > maxNumberOfExpectedMissingHits2_ ) && useExpectedMissingHits2_ ) {
00885             delete [] sorted;
00886             delete [] et;
00887             return false;
00888         }
00889 
00890         if ( calculateExpectedMissingHits2_ ) {
00891             maxETelec2.addUserInt("NumberOfExpectedMissingHits",numberOfInnerHits);
00892         }
00893     }
00894 
00895     if ( useConversionRejection1_ || calculateConversionRejection1_ ) {
00896         // use of conversion rejection as it is implemented in egamma
00897         // you have to get the general track collection to do that
00898         // WARNING! you have to supply the correct B-field in Tesla
00899         // the magnetic field
00900 
00901         Double_t bfield;
00902 
00903         if ( dataMagneticFieldSetUp_ ) {
00904 
00905             edm::Handle<DcsStatusCollection> dcsHandle;
00906             iEvent.getByLabel(dcsTag_, dcsHandle);
00907             // scale factor = 3.801/18166.0 which are
00908             // average values taken over a stable two
00909             // week period
00910             Double_t currentToBFieldScaleFactor = 2.09237036221512717e-04;
00911             Double_t current = (*dcsHandle)[0].magnetCurrent();
00912             bfield = current*currentToBFieldScaleFactor;
00913 
00914         } else {
00915 
00916             edm::ESHandle<MagneticField> magneticField;
00917             iSetup.get<IdealMagneticFieldRecord>().get(magneticField);
00918             const  MagneticField *mField = magneticField.product();
00919             bfield = mField->inTesla(GlobalPoint(0.0,0.0,0.0)).z();
00920 
00921         }
00922 
00923         edm::Handle<reco::TrackCollection> ctfTracks;
00924 
00925         if ( iEvent.getByLabel("generalTracks", ctfTracks) ) {
00926 
00927             ConversionFinder convFinder;
00928             ConversionInfo convInfo = convFinder.getConversionInfo(maxETelec1, ctfTracks, bfield);
00929 
00930             Float_t dist = convInfo.dist();
00931             Float_t dcot = convInfo.dcot();
00932 
00933             Bool_t isConv = ( ( TMath::Abs(dist) < dist1_ ) && ( TMath::Abs(dcot) < dcot1_ ) ) ;
00934 
00935             std::cout << "Filter: for electron #1 the conversion says " << isConv << std::endl;
00936 
00937             if ( isConv && useConversionRejection1_ ) {
00938                 delete [] sorted;
00939                 delete [] et;
00940                 return false;
00941             }
00942 
00943             if ( calculateConversionRejection1_ ) {
00944 
00945                 maxETelec1.addUserFloat("Dist", Float_t(dist));
00946                 maxETelec1.addUserFloat("Dcot", Float_t(dcot));
00947 
00948                 if ( isConv ) {
00949                     maxETelec1.addUserInt("PassConversionRejection",0);
00950                 }
00951                 else {
00952                     maxETelec1.addUserInt("PassConversionRejection",1);
00953                 }
00954 
00955             }
00956 
00957         }
00958         else {
00959             std::cout << "WARNING! Track Collection with input name: generalTracks was not found. Conversion Rejection for electron #1 is not going to be applied!!!" << std::endl;
00960         }
00961 
00962     }
00963 
00964     if ( useConversionRejection2_ || calculateConversionRejection2_ ) {
00965         // use of conversion rejection as it is implemented in egamma
00966         // you have to get the general track collection to do that
00967         // WARNING! you have to supply the correct B-field in Tesla
00968         // the magnetic field
00969 
00970         Double_t bfield;
00971 
00972         if ( dataMagneticFieldSetUp_ ) {
00973 
00974             edm::Handle<DcsStatusCollection> dcsHandle;
00975             iEvent.getByLabel(dcsTag_, dcsHandle);
00976 
00977             // scale factor = 3.801/18166.0 which are
00978             // average values taken over a stable two
00979             // week period
00980 
00981             Double_t currentToBFieldScaleFactor = 2.09237036221512717e-04;
00982             Double_t current = (*dcsHandle)[0].magnetCurrent();
00983             bfield = current*currentToBFieldScaleFactor;
00984 
00985         } else {
00986 
00987             edm::ESHandle<MagneticField> magneticField;
00988             iSetup.get<IdealMagneticFieldRecord>().get(magneticField);
00989             const  MagneticField *mField = magneticField.product();
00990             bfield = mField->inTesla(GlobalPoint(0.0,0.0,0.0)).z();
00991 
00992         }
00993 
00994         edm::Handle<reco::TrackCollection> ctfTracks;
00995 
00996         if ( iEvent.getByLabel("generalTracks", ctfTracks) ) {
00997 
00998             ConversionFinder convFinder;
00999             ConversionInfo convInfo = convFinder.getConversionInfo(maxETelec2, ctfTracks, bfield);
01000 
01001             Float_t dist = convInfo.dist();
01002             Float_t dcot = convInfo.dcot();
01003 
01004             Bool_t isConv = ( ( TMath::Abs(dist) < dist2_ ) && ( TMath::Abs(dcot) < dcot2_ ) ) ;
01005 
01006             std::cout << "Filter: for electron #2 the conversion says " << isConv << std::endl;
01007 
01008             if ( isConv && useConversionRejection2_ ) {
01009                 delete [] sorted;
01010                 delete [] et;
01011                 return false;
01012             }
01013 
01014             if ( calculateConversionRejection2_ ) {
01015 
01016                 maxETelec2.addUserFloat("Dist", Float_t(dist));
01017                 maxETelec2.addUserFloat("Dcot", Float_t(dcot));
01018 
01019                 if ( isConv ) {
01020                     maxETelec2.addUserInt("PassConversionRejection",0);
01021                 }
01022                 else {
01023                     maxETelec2.addUserInt("PassConversionRejection",1);
01024                 }
01025 
01026             }
01027 
01028         }
01029         else {
01030             std::cout << "WARNING! Track Collection with input name: generalTracks was not found. Conversion Rejection for electron #2 is not going to be applied!!!" << std::endl;
01031         }
01032 
01033     }
01034 
01035     std::cout << "HLT matching starts" << std::endl;
01036 
01037     if ( electronMatched2HLT_ && useTriggerInfo_ ) {
01038 
01039         Double_t matched_dr_distance1 = 999999.;
01040         Int_t trigger_int_probe1 = 0;
01041 
01042         Double_t matched_dr_distance2 = 999999.;
01043         Int_t trigger_int_probe2 = 0;
01044 
01045         if ( finalpathfound ) {
01046 
01047             if ( nF != filterInd ) {
01048 
01049                 const trigger::Keys& KEYS(pHLT->filterKeys(filterInd));
01050                 const Int_t nK(KEYS.size());
01051 
01052                 std::cout << "Found trig objects #" << nK << std::endl;
01053 
01054                 for ( Int_t iTrig = 0; iTrig < nK; ++iTrig ) {
01055 
01056                     const trigger::TriggerObject& TO(TOC[KEYS[iTrig]]);
01057 
01058                     if ( useHLTObjectETCut_ ) {
01059                         if ( TO.et() < hltObjectETCut_ ) {
01060                             continue;
01061                         }
01062                     }
01063 
01064                     Double_t dr_ele_HLT1 = reco::deltaR(maxETelec1.superCluster()->eta(),maxETelec1.superCluster()->phi(),TO.eta(),TO.phi());
01065                     Double_t dr_ele_HLT2 = reco::deltaR(maxETelec2.superCluster()->eta(),maxETelec2.superCluster()->phi(),TO.eta(),TO.phi());
01066 
01067                     //std::cout << "-->found dr=" << dr_ele_HLT << std::endl;
01068 
01069                     if ( TMath::Abs(dr_ele_HLT1) < matched_dr_distance1 ) {
01070                         matched_dr_distance1 = dr_ele_HLT1;
01071                     }
01072 
01073                     if ( TMath::Abs(dr_ele_HLT2) < matched_dr_distance2 ) {
01074                         matched_dr_distance2 = dr_ele_HLT2;
01075                     }
01076 
01077                 }
01078 
01079             }
01080 
01081             if ( useExtraTrigger_ ) {
01082 
01083                 for (Int_t itrig=0; itrig < (Int_t) filterIndExtra.size(); ++itrig ) {
01084 
01085                     if ( filterIndExtra[itrig] == nF ) {
01086                         continue;
01087                     }
01088 
01089                     std::cout << "working on #" << itrig << std::endl; std::cout << "  ---> " << filterIndExtra[itrig] << std::endl;
01090 
01091                     const trigger::Keys& KEYS(pHLT->filterKeys(filterIndExtra[itrig]));
01092                     const Int_t nK(KEYS.size());
01093 
01094                     std::cout << "Found trig objects #" << nK << std::endl;
01095 
01096                     for (Int_t iTrig = 0; iTrig <nK; ++iTrig ) {
01097 
01098                         const trigger::TriggerObject& TO(TOC[KEYS[iTrig]]);
01099 
01100                         Double_t dr_ele_HLT1 = reco::deltaR(maxETelec1.eta(),maxETelec1.phi(),TO.eta(),TO.phi());
01101                         Double_t dr_ele_HLT2 = reco::deltaR(maxETelec2.eta(),maxETelec2.phi(),TO.eta(),TO.phi());
01102 
01103                         //std::cout << "-->found dr=" << dr_ele_HLT << std::endl;
01104 
01105                         if ( TMath::Abs(dr_ele_HLT1) < matched_dr_distance1 ) {
01106                             matched_dr_distance1 = dr_ele_HLT1;
01107                         }
01108 
01109                         if ( TMath::Abs(dr_ele_HLT2) < matched_dr_distance2 ) {
01110                             matched_dr_distance2 = dr_ele_HLT2;
01111                         }
01112                     }
01113                 }
01114             }
01115 
01116             if ( matched_dr_distance1 < electronMatched2HLT_DR_ ) {
01117                 ++trigger_int_probe1;
01118             }
01119 
01120             if ( matched_dr_distance2 < electronMatched2HLT_DR_ ) {
01121                 ++trigger_int_probe2;
01122             }
01123 
01124             if ( ( trigger_int_probe1 == 0 ) && ( trigger_int_probe2 == 0 ) ) {    std::cout << "No electron could be matched to an HLT object with " << std::endl;
01125 
01126                 delete [] sorted;
01127                 delete [] et;
01128 
01129                 return false; // RETURN: electron is not matched to an HLT object
01130             }
01131 
01132             maxETelec1.addUserFloat("HLTMatchingDR", Float_t(matched_dr_distance1));
01133             maxETelec2.addUserFloat("HLTMatchingDR", Float_t(matched_dr_distance2));
01134 
01135         }
01136         else {  //std::cout << "Electron filter not found - should not be like that... " << std::endl;
01137 
01138             delete [] sorted;
01139             delete [] et;
01140 
01141             return false; // RETURN: electron is not matched to an HLT object
01142         }
01143     }
01144 
01145        std::cout << "HLT matching has finished" << std::endl;
01146 
01147     // ___________________________________________________________________
01148     //
01149 
01150     // add information of whether the event passes the following sets of
01151     // triggers. Currently Hardwired, to be changed in the future
01152 
01153     if ( HLTResults.isValid() ) {
01154 
01155         const  std::string process = triggerCollectionTag_.process();
01156         //
01157         std::string  HLTPath[18];
01158         HLTPath[0 ] = "HLT_Photon10_L1R"              ;
01159         HLTPath[1 ] = "HLT_Photon15_L1R"              ;
01160         HLTPath[2 ] = "HLT_Photon20_L1R"              ;
01161         HLTPath[3 ] = "HLT_Photon15_TrackIso_L1R"     ;
01162         HLTPath[4 ] = "HLT_Photon15_LooseEcalIso_L1R" ;
01163         HLTPath[5 ] = "HLT_Photon30_L1R_8E29"         ;
01164         HLTPath[6 ] = "HLT_Photon30_L1R_8E29"         ;
01165         HLTPath[7 ] = "HLT_Ele10_LW_L1R"              ;
01166         HLTPath[8 ] = "HLT_Ele15_LW_L1R"              ;
01167         HLTPath[9 ] = "HLT_Ele20_LW_L1R"              ;
01168         HLTPath[10] = "HLT_Ele10_LW_EleId_L1R"        ;
01169         HLTPath[11] = "HLT_Ele15_SiStrip_L1R"         ;
01170         HLTPath[12] = "HLT_IsoTrackHB_8E29"           ;
01171         HLTPath[13] = "HLT_IsoTrackHE_8E29"           ;
01172         HLTPath[14] = "HLT_DiJetAve15U_8E29"          ;
01173         HLTPath[15] = "HLT_MET45"                     ;
01174         HLTPath[16] = "HLT_L1MET20"                   ;
01175         HLTPath[17] = "HLT_MET100"                    ;
01176         //
01177         edm::InputTag HLTFilterType[15];
01178         HLTFilterType[0 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt10HcalIsolFilter","",process)            ;  //HLT_Photon10_L1R
01179         HLTFilterType[1 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt15HcalIsolFilter" ,"",process)           ;  //HLT_Photon15_L1R
01180         HLTFilterType[2 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt20HcalIsolFilter" ,"",process)           ;  //HLT_Photon20_L1R
01181         HLTFilterType[3 ]= edm::InputTag("hltL1NonIsoSinglePhotonEt15HTITrackIsolFilter","",process)                 ;  //HLT_Photon15_TrackIso_L1R
01182         HLTFilterType[4 ]= edm::InputTag("hltL1NonIsoSinglePhotonEt15LEIHcalIsolFilter","",process)                  ;  //HLT_Photon15_LooseEcalIso_L1R
01183         HLTFilterType[5 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt15EtFilterESet308E29","",process)        ;  //HLT_Photon30_L1R_8E29
01184         HLTFilterType[6 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt15HcalIsolFilter","",process)            ;  //HLT_Photon30_L1R_8E29
01185         HLTFilterType[7 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronLWEt10PixelMatchFilter","",process)      ;
01186         HLTFilterType[8 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronLWEt15PixelMatchFilter","",process)      ;
01187         HLTFilterType[9 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronLWEt15EtFilterESet20","",process)        ;
01188         HLTFilterType[10]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronLWEt10EleIdDphiFilter","",process)       ;
01189         HLTFilterType[11]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronSiStripEt15PixelMatchFilter","",process) ;
01190         HLTFilterType[12]= edm::InputTag("hltIsolPixelTrackL3FilterHB8E29","",process)                               ;
01191         HLTFilterType[13]= edm::InputTag("hltIsolPixelTrackL2FilterHE8E29","",process)                               ;
01192         HLTFilterType[14]= edm::InputTag("hltL1sDiJetAve15U8E29","",process)                                         ;
01193         //
01194         Int_t triggerDecision = 0;
01195         UInt_t trigger_size = HLTResults->size();
01196 
01197         for (Int_t i=0; i<18; ++i ) {
01198 
01199             const edm::TriggerNames & triggerNames = iEvent.triggerNames(*HLTResults);
01200             UInt_t trigger_position = triggerNames.triggerIndex(HLTPath[i]);
01201             Int_t  passTrigger = 0;
01202 
01203             if ( trigger_position < trigger_size ) {
01204                 passTrigger = (Int_t)HLTResults->accept(trigger_position);
01205             }
01206 
01207             if ( passTrigger > 0 ) {
01208                 if ( i >= 15 ) {
01209                     triggerDecision += (Int_t)(TMath::Power(2,i));
01210                 }
01211                 else {
01212                     const Int_t myfilterInd = pHLT->filterIndex(HLTFilterType[i]);
01213                     if ( myfilterInd != nF ) {
01214                         triggerDecision += (Int_t)(TMath::Power(2,i));
01215                     }
01216                 }
01217             }
01218         }
01219 
01220         // add the info in the maxETelec1 and maxETelec2
01221         maxETelec1.addUserInt("triggerDecision",triggerDecision);
01222         maxETelec2.addUserInt("triggerDecision",triggerDecision);
01223     }
01224 
01225     // ___________________________________________________________________
01226     //
01227 
01228     // MET Collection
01229     edm::Handle<pat::METCollection> patMET;
01230     iEvent.getByLabel(metCollectionTag_,   patMET);
01231 
01232     edm::Handle<pat::METCollection> patpfMET;
01233     iEvent.getByLabel(pfMetCollectionTag_, patpfMET);
01234 
01235     edm::Handle<pat::METCollection> pattcMET;
01236     iEvent.getByLabel(tcMetCollectionTag_, pattcMET);
01237 
01238     const pat::METCollection *pMet = patMET.product();
01239     const pat::METCollection::const_iterator met = pMet->begin();
01240     const pat::MET theMET = *met;
01241     //
01242     const pat::METCollection *pPfMet = patpfMET.product();
01243     const pat::METCollection::const_iterator pfmet = pPfMet->begin();
01244     const pat::MET thePfMET = *pfmet;
01245     //
01246     const pat::METCollection *pTcMet = pattcMET.product();
01247     const pat::METCollection::const_iterator tcmet = pTcMet->begin();
01248     const pat::MET theTcMET = *tcmet;
01249 
01250     Double_t metEt = met->et();
01251     //Double_t metEta = met->eta();
01252     //Double_t metMt = met->mt();
01253     //Double_t metPhi = met->phi();
01254     //Double_t metSig = met->mEtSig();
01255     //std::cout<<"met properties: et=" << met->et() << ", eta: " <<  met->eta()
01256     //       << std::endl;
01257     //
01258     if ( metEt < METCut_ ) {    std::cout << "MET is " << metEt << std::endl;
01259 
01260         delete [] sorted;
01261         delete [] et;
01262 
01263         return false;  // RETURN if MET is < Metcut
01264     }
01265 
01266 
01267     // if you have indeed reached this point then you have a zeeCandidate!!!
01268 
01269     pat::CompositeCandidate zeeCandidate;
01270 
01271     zeeCandidate.addDaughter(maxETelec1, "electron1");
01272     zeeCandidate.addDaughter(maxETelec2, "electron2");
01273 
01274     zeeCandidate.addDaughter(theMET, "met");
01275     zeeCandidate.addDaughter(thePfMET, "pfmet");
01276     zeeCandidate.addDaughter(theTcMET, "tcmet");
01277 
01278     auto_ptr<pat::CompositeCandidateCollection>selectedZeeCandidates(new pat::CompositeCandidateCollection);
01279 
01280     selectedZeeCandidates->push_back(zeeCandidate);
01281 
01282     iEvent.put(selectedZeeCandidates, "selectedZeeCandidates");
01283 
01284     // release your memory
01285     delete [] sorted;
01286     delete [] et;
01287 
01288     std::cout << "Run = "   << iEvent.run() << " " 
01289               << "Lumi = "  << (Int_t)iEvent.luminosityBlock() << " " 
01290               << "Event = " << iEvent.eventAuxiliary().event() << " " 
01291               << "FILTER-MSG: Event Accepted for Z Candidate"
01292               << std::endl;
01293 
01294     return true;
01295 
01296 }
01297 
01298 // ------------ method called once each job just after ending the event loop  -
01299 void ZeeCandidateFilter::endJob() {}
01300 
01301 Bool_t ZeeCandidateFilter::isInFiducial(Double_t eta)
01302 {
01303     if ( TMath::Abs(eta) < BarrelMaxEta_ ) {
01304         return true;
01305     }
01306     else if ( ( TMath::Abs(eta) < EndCapMaxEta_ ) && ( TMath::Abs(eta) > EndCapMinEta_ ) ) {
01307         return true;
01308     }
01309 
01310     return false;
01311 
01312 }
01313 
01314 // Bool_t ZeeCandidateFilter::passEleIDCuts(pat::Electron *ele)
01315 // {
01316 //     if ( ! useVetoSecondElectronID_)  return true;
01317 //     if ( ! ele->isElectronIDAvailable(vetoSecondElectronIDType_) ) {
01318 //         std::cout << "ZeeCandidateFilter: request ignored: 2nd electron ID type "
01319 //                   << "not found in electron object" << std::endl;
01320 //         return true;
01321 //     }
01322 //     if ( vetoSecondElectronIDSign_ == ">" ) {
01323 //         if ( ele->electronID(vetoSecondElectronIDType_)>vetoSecondElectronIDValue_)
01324 //             return true;
01325 //         else return false;
01326 //     }
01327 //     else if ( vetoSecondElectronIDSign_ == "<" ) {
01328 //         if ( ele->electronID(vetoSecondElectronIDType_)<vetoSecondElectronIDValue_)
01329 //             return true;
01330 //         else return false;
01331 //     }
01332 //     else {
01333 //         if ( TMath::Abs(ele->electronID(vetoSecondElectronIDType_)-
01334 //                        vetoSecondElectronIDValue_) < 0.1)
01335 //             return true;
01336 //         else return false;
01337 //     }
01338 // }
01339 
01340 //define this as a plug-in
01341 DEFINE_FWK_MODULE(ZeeCandidateFilter);
/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/ElectroWeakAnalysis/ZEE/src/ZeeCandidateFilter.cc
