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
ZeeCandidateFilter Class Reference

#include <EWKSoftware/EDMTupleSkimmerFilter/src/ZeeCandidateFilter.cc>

Inheritance diagram for ZeeCandidateFilter:
edm::EDFilter edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

Public Member Functions

 ZeeCandidateFilter (const edm::ParameterSet &)
 
 ~ZeeCandidateFilter ()
 
- Public Member Functions inherited from edm::EDFilter
 EDFilter ()
 
ModuleDescription const & moduleDescription () const
 
virtual ~EDFilter ()
 
- Public Member Functions inherited from edm::ProducerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 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
std::vector< ConsumesInfo > consumesInfo () const
 
 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
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
bool registeredToConsume (ProductHolderIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
 
virtual ~EDConsumerBase ()
 

Private Member Functions

virtual void endJob () override
 
virtual Bool_t filter (edm::Event &, const edm::EventSetup &) override
 
Bool_t isInFiducial (Double_t eta)
 

Private Attributes

Double_t BarrelMaxEta_
 
Bool_t calculateConversionRejection1_
 
Bool_t calculateConversionRejection2_
 
Bool_t calculateExpectedMissingHits1_
 
Bool_t calculateExpectedMissingHits2_
 
Bool_t calculateValidFirstPXBHit1_
 
Bool_t calculateValidFirstPXBHit2_
 
Bool_t dataMagneticFieldSetUp_
 
Double_t dcot1_
 
Double_t dcot2_
 
edm::InputTag dcsTag_
 
edm::EDGetTokenT
< DcsStatusCollection > 		dcsToken_
 
Double_t dist1_
 
Double_t dist2_
 
edm::EDGetTokenT
< EcalRecHitCollection > 		ebRecHitsToken_
 
edm::EDGetTokenT
< EcalRecHitCollection > 		eeRecHitsToken_
 
edm::InputTag electronCollectionTag_
 
edm::EDGetTokenT
< pat::ElectronCollection > 		electronCollectionToken_
 
Bool_t electronMatched2HLT_
 
Double_t electronMatched2HLT_DR_
 
Double_t EndCapMaxEta_
 
Double_t EndCapMinEta_
 
Double_t ETCut_
 
Double_t hltObjectETCut_
 
std::string hltpath_
 
edm::InputTag hltpathFilter_
 
Int_t maxNumberOfExpectedMissingHits1_
 
Int_t maxNumberOfExpectedMissingHits2_
 
edm::EDGetTokenT
< pat::METCollection > 		metCollectionToken_
 
Double_t METCut_
 
edm::EDGetTokenT
< pat::METCollection > 		pfMetCollectionToken_
 
edm::EDGetTokenT< std::vector
< reco::Vertex > > 		PrimaryVerticesCollectionToken_
 
Double_t spikeCleaningSwissCrossCut_
 
edm::EDGetTokenT
< pat::METCollection > 		tcMetCollectionToken_
 
edm::EDGetTokenT
< reco::TrackCollection > 		tracksToken_
 
edm::InputTag triggerCollectionTag_
 
edm::EDGetTokenT
< edm::TriggerResults > 		triggerCollectionToken_
 
edm::EDGetTokenT
< trigger::TriggerEvent > 		triggerEventToken_
 
Bool_t useConversionRejection1_
 
Bool_t useConversionRejection2_
 
Bool_t useEcalDrivenElectrons_
 
Bool_t useExpectedMissingHits1_
 
Bool_t useExpectedMissingHits2_
 
Bool_t useExtraTrigger_
 
Bool_t useHLTObjectETCut_
 
Bool_t useSpikeRejection_
 
Bool_t useTriggerInfo_
 
Bool_t useValidFirstPXBHit1_
 
Bool_t useValidFirstPXBHit2_
 
std::vector< std::string > vHltpathExtra_
 
std::vector< edm::InputTag > vHltpathFilterExtra_
 

Additional Inherited Members

- Public Types inherited from edm::EDFilter
typedef EDFilter ModuleType
 
- Public Types inherited from edm::ProducerBase
typedef
ProductRegistryHelper::TypeLabelList 		TypeLabelList
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from edm::EDFilter
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &)
 
- 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)
 

Detailed Description

Description: <one line="" class="" summary>="">

Implementation:

This class contains a filter that searches the event and finds whether it fulfills the Z Candidate Criteria. If it fullfills them it creates a ZeeCandidate and stores it in the event.

Definition of the Zee Caldidate: event that passes the trigger has 2 Gsf electrons in fiducial with ET greater than a (configurable) threshold at least one of them matched to an HLT Object (configurable) with DR < (configurable)

Changes Log:

12Feb09 First Release of the code for CMSSW_2_2_X

17Sep09 First Release for CMSSW_3_1_X

09Dec09 Option to ignore trigger

25Feb10 Added options to use Conversion Rejection, Expected missing hits and valid hit at first PXB 

     Added option to calculate these criteria and store them in the pat electron object this is done by setting in the configuration the flags

           calculateValidFirstPXBHit = true
           calculateConversionRejection = true
           calculateExpectedMissinghits = true

     Then the code calculates them and you can access all these from pat::Electron

           myElec.userInt("PassValidFirstPXBHit")      0 fail, 1 passes
           myElec.userInt("PassConversionRejection")   0 fail, 1 passes
           myElec.userInt("NumberOfExpectedMissingHits") the number of lost hits

28May10 Implementation of Spring10 selections Contact: Stilianos Kesisoglou - Institute of Nuclear Physics NCSR Demokritos Original Author: Nikolaos Rompotis

Nikol.nosp@m.aos..nosp@m.Rompo.nosp@m.tis@.nosp@m.Cern..nosp@m.ch Imperial College London

Definition at line 101 of file ZeeCandidateFilter.cc.

Constructor & Destructor Documentation

ZeeCandidateFilter::ZeeCandidateFilter ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 211 of file ZeeCandidateFilter.cc.

References BarrelMaxEta_, calculateConversionRejection1_, calculateConversionRejection2_, calculateExpectedMissingHits1_, calculateExpectedMissingHits2_, calculateValidFirstPXBHit1_, calculateValidFirstPXBHit2_, gather_cfg::cout, dataMagneticFieldSetUp_, dcot1_, dcot2_, dcsTag_, dcsToken_, dist1_, dist2_, ebRecHitsToken_, eeRecHitsToken_, electronCollectionTag_, electronCollectionToken_, electronMatched2HLT_, electronMatched2HLT_DR_, EndCapMaxEta_, EndCapMinEta_, ETCut_, edm::ParameterSet::getUntrackedParameter(), hltObjectETCut_, hltpath_, hltpathFilter_, HLT_25ns14e33_v1_cff::InputTag, maxNumberOfExpectedMissingHits1_, maxNumberOfExpectedMissingHits2_, metCollectionToken_, METCut_, pfMetCollectionToken_, PrimaryVerticesCollectionToken_, spikeCleaningSwissCrossCut_, AlCaHLTBitMon_QueryRunRegistry::string, tcMetCollectionToken_, tracksToken_, triggerCollectionTag_, triggerCollectionToken_, triggerEventToken_, useConversionRejection1_, useConversionRejection2_, useEcalDrivenElectrons_, useExpectedMissingHits1_, useExpectedMissingHits2_, useExtraTrigger_, useHLTObjectETCut_, useSpikeRejection_, useTriggerInfo_, useValidFirstPXBHit1_, useValidFirstPXBHit2_, vHltpathExtra_, and vHltpathFilterExtra_.

212 {
213  //
214  //-------------------------------------//
215  // INITIALIZATION //
216  //-------------------------------------//
217  //
218 
219 
220  // Cuts
221  // ----
222  ETCut_ = iConfig.getUntrackedParameter<Double_t>("ETCut");
223  METCut_ = iConfig.getUntrackedParameter<Double_t>("METCut");
224 
225  useEcalDrivenElectrons_ = iConfig.getUntrackedParameter<Bool_t>("useEcalDrivenElectrons", false);
226  //--------------------------------------------------------------------------------------------------------------------
227 
228 
229  // Preselection Criteria: Hit Pattern
230  // ----------------------------------
231  //
232  /* Electron 1 */
233  useValidFirstPXBHit1_ = iConfig.getUntrackedParameter<Bool_t>("useValidFirstPXBHit1",false);
234  calculateValidFirstPXBHit1_ = iConfig.getUntrackedParameter<Bool_t>("calculateValidFirstPXBHit1",false);
235  useConversionRejection1_ = iConfig.getUntrackedParameter<Bool_t>("useConversionRejection1",false);
236  calculateConversionRejection1_ = iConfig.getUntrackedParameter<Bool_t>("calculateConversionRejection1",false);
237  useExpectedMissingHits1_ = iConfig.getUntrackedParameter<Bool_t>("useExpectedMissingHits1",false);
238  calculateExpectedMissingHits1_ = iConfig.getUntrackedParameter<Bool_t>("calculateExpectedMissingHits1",false);
239  maxNumberOfExpectedMissingHits1_ = iConfig.getUntrackedParameter<Int_t>("maxNumberOfExpectedMissingHits1",1);
240  //
241  /* Electron 2 */
242  useValidFirstPXBHit2_ = iConfig.getUntrackedParameter<Bool_t>("useValidFirstPXBHit2",false);
243  calculateValidFirstPXBHit2_ = iConfig.getUntrackedParameter<Bool_t>("calculateValidFirstPXBHit2",false);
244  useConversionRejection2_ = iConfig.getUntrackedParameter<Bool_t>("useConversionRejection2",false);
245  calculateConversionRejection2_ = iConfig.getUntrackedParameter<Bool_t>("calculateConversionRejection2",false);
246  useExpectedMissingHits2_ = iConfig.getUntrackedParameter<Bool_t>("useExpectedMissingHits2",false);
247  calculateExpectedMissingHits2_ = iConfig.getUntrackedParameter<Bool_t>("calculateExpectedMissingHits2",false);
248  maxNumberOfExpectedMissingHits2_ = iConfig.getUntrackedParameter<Int_t>("maxNumberOfExpectedMissingHits2",1);
249  //--------------------------------------------------------------------------------------------------------------------
250 
251 
252  // Conversion Rejection Variables
253  // ------------------------------
254  //
255  /* Electron 1 */
256  Double_t dist1_D = 0.02 ;
257  Double_t dcot1_D = 0.02 ;
258  //
259  dist1_ = iConfig.getUntrackedParameter<Double_t>("conversionRejectionDist1", dist1_D);
260  dcot1_ = iConfig.getUntrackedParameter<Double_t>("conversionRejectionDcot1", dcot1_D);
261  //
262  /* Electron 2 */
263  Double_t dist2_D = 0.02 ;
264  Double_t dcot2_D = 0.02 ;
265  //
266  dist2_ = iConfig.getUntrackedParameter<Double_t>("conversionRejectionDist2", dist2_D);
267  dcot2_ = iConfig.getUntrackedParameter<Double_t>("conversionRejectionDcot2", dcot2_D);
268  //--------------------------------------------------------------------------------------------------------------------
269 
270 
271  // Magnetic Field
272  // --------------
273  //
274  dataMagneticFieldSetUp_ = iConfig.getUntrackedParameter<Bool_t>("dataMagneticFieldSetUp",false);
275 
276  if ( dataMagneticFieldSetUp_ ) {
277  dcsTag_ = iConfig.getUntrackedParameter<edm::InputTag>("dcsTag");
278  dcsToken_ = mayConsume<DcsStatusCollection>(dcsTag_);
279  }
280  tracksToken_ = mayConsume<reco::TrackCollection>(edm::InputTag("generalTracks"));
281  //--------------------------------------------------------------------------------------------------------------------
282 
283 
284  // Detector Fiducial Cuts
285  // ----------------------
286  //
287  Double_t BarrelMaxEta_D = 1.4442 ;
288  Double_t EndCapMinEta_D = 1.5660 ;
289  Double_t EndCapMaxEta_D = 2.5000 ;
290 
291  BarrelMaxEta_ = iConfig.getUntrackedParameter<Double_t>("BarrelMaxEta", BarrelMaxEta_D);
292  EndCapMaxEta_ = iConfig.getUntrackedParameter<Double_t>("EndCapMaxEta", EndCapMaxEta_D);
293  EndCapMinEta_ = iConfig.getUntrackedParameter<Double_t>("EndCapMinEta", EndCapMinEta_D);
294  //--------------------------------------------------------------------------------------------------------------------
295 
296 
297  // Trigger Related
298  // ---------------
299  //
300  hltpath_ = iConfig.getUntrackedParameter<std::string>("hltpath");
301  triggerCollectionTag_ = iConfig.getUntrackedParameter<edm::InputTag>("triggerCollectionTag");
302  triggerCollectionToken_ = consumes<edm::TriggerResults>(triggerCollectionTag_);
303  triggerEventToken_ = consumes<trigger::TriggerEvent>(iConfig.getUntrackedParameter<edm::InputTag>("triggerEventTag"));
304  hltpathFilter_ = iConfig.getUntrackedParameter<edm::InputTag>("hltpathFilter");
305  useHLTObjectETCut_ = iConfig.getUntrackedParameter<Bool_t>("useHLTObjectETCut", false);
306 
307  if ( useHLTObjectETCut_ ) {
308  hltObjectETCut_ = iConfig.getUntrackedParameter<Double_t>("hltObjectETCut");
309  }
310 
311  // Dirty way to add a second trigger with OR, to be done properly in the next tag
312  useExtraTrigger_ = iConfig.getUntrackedParameter<Bool_t>("useExtraTrigger");
313 
314  if ( useExtraTrigger_ ) {
315 
316  vHltpathExtra_ = iConfig.getUntrackedParameter< std::vector<std::string> >("vHltpathExtra");
317  vHltpathFilterExtra_ = iConfig.getUntrackedParameter< std::vector<edm::InputTag> >("vHltpathFilterExtra");
318 
319  if ( Int_t(vHltpathExtra_.size()) != Int_t(vHltpathFilterExtra_.size()) ) {
320  std::cout << "ZeeCandidateFilter: ERROR IN Configuration: vHltpathExtra and vHltpathFilterExtra" << " should have the same dimensions " << std::endl;
321  }
322  }
323  //--------------------------------------------------------------------------------------------------------------------
324 
325 
326  // Trigger Matching Related
327  // ------------------------
328  //
329  useTriggerInfo_ = iConfig.getUntrackedParameter<Bool_t>("useTriggerInfo",true);
330  electronMatched2HLT_ = iConfig.getUntrackedParameter<Bool_t>("electronMatched2HLT");
331  electronMatched2HLT_DR_ = iConfig.getUntrackedParameter<Double_t>("electronMatched2HLT_DR");
332  //--------------------------------------------------------------------------------------------------------------------
333 
334 
335  // Electrons, MET's Vtx's and other
336  // --------------------------------
337  //
338  electronCollectionTag_ = iConfig.getUntrackedParameter<edm::InputTag>("electronCollectionTag");
339  electronCollectionToken_ = consumes<pat::ElectronCollection>(electronCollectionTag_);
340 
341  metCollectionToken_ = consumes<pat::METCollection>(iConfig.getUntrackedParameter<edm::InputTag>("metCollectionTag"));
342  pfMetCollectionToken_ = consumes<pat::METCollection>(iConfig.getUntrackedParameter<edm::InputTag>("pfMetCollectionTag"));
343  tcMetCollectionToken_ = consumes<pat::METCollection>(iConfig.getUntrackedParameter<edm::InputTag>("tcMetCollectionTag"));
344 
345  PrimaryVerticesCollectionToken_ = consumes< std::vector<reco::Vertex> >(iConfig.getUntrackedParameter<edm::InputTag>("PrimaryVerticesCollection"));
346 
347  ebRecHitsToken_ = mayConsume<EcalRecHitCollection>(iConfig.getUntrackedParameter<edm::InputTag>("ebRecHits"));
348  eeRecHitsToken_ = mayConsume<EcalRecHitCollection>(iConfig.getUntrackedParameter<edm::InputTag>("eeRecHits"));
349  //--------------------------------------------------------------------------------------------------------------------
350 
351 
352  // Spike Cleaning
353  // --------------
354  //
355  useSpikeRejection_ = iConfig.getUntrackedParameter<Bool_t>("useSpikeRejection");
356 
357  if ( useSpikeRejection_ ) {
358  spikeCleaningSwissCrossCut_ = iConfig.getUntrackedParameter<Double_t>("spikeCleaningSwissCrossCut");
359  }
360  //--------------------------------------------------------------------------------------------------------------------
361 
362 
363  //
364  //-------------------------------------//
365  // SUMMARY PRINTOUT //
366  //-------------------------------------//
367  //
368 
369  std::cout << "ZeeCandidateFilter: Running Zee Filter..." << std::endl;
370 
371  if ( useTriggerInfo_ ) {
372  std::cout << "ZeeCandidateFilter: HLT Path " << hltpath_ << std::endl;
373  std::cout << "ZeeCandidateFilter: HLT Filter " << hltpathFilter_ << std::endl;
374 
375  if ( useExtraTrigger_ ) {
376  for (Int_t itrig=0; itrig < (Int_t)vHltpathExtra_.size(); ++itrig ) {
377 
378  std::cout << "ZeeCandidateFilter: OR " << vHltpathExtra_[itrig] << " with filter: " << vHltpathFilterExtra_[itrig] << std::endl;
379  }
380  }
381  }
382  else {
383  std::cout << "ZeeCandidateFilter: Trigger info will not be used here" << std::endl;
384  }
385 
386  std::cout << "ZeeCandidateFilter: ET > " << ETCut_ << std::endl;
387  std::cout << "ZeeCandidateFilter: MET > " << METCut_ << std::endl;
388 
389 
390  if ( useEcalDrivenElectrons_ ) {
391  std::cout << "ZeeCandidateFilter: Electron Candidate(s) is required to be ecal driven" << std::endl;
392  }
393 
394  if ( electronMatched2HLT_ && useTriggerInfo_ ) {
395  std::cout << "ZeeCandidateFilter: At least one electron is required to match an HLT object with DR < " << electronMatched2HLT_DR_ << std::endl;
396  }
397  else {
398  std::cout << "ZeeCandidateFilter: Electron Candidates NOT required to match HLT object " << std::endl;
399  }
400 
401  if ( useValidFirstPXBHit1_ ) {
402  std::cout << "ZeeCandidateFilter: Electron Candidate #1 required to have a valid hit in 1st PXB layer " << std::endl;
403  }
404 
405  if ( useValidFirstPXBHit2_ ) {
406  std::cout << "ZeeCandidateFilter: Electron Candidate #2 required to have a valid hit in 1st PXB layer " << std::endl;
407  }
408 
409  if ( calculateValidFirstPXBHit1_ ) {
410  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;
411  }
412 
413  if ( calculateValidFirstPXBHit2_ ) {
414  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;
415  }
416 
417  if ( useExpectedMissingHits1_ ) {
418  std::cout << "ZeeCandidateFilter: Electron Candidate #1 is required to have less than " << maxNumberOfExpectedMissingHits1_ << " expected hits missing " << std::endl;
419  }
420 
421  if ( useExpectedMissingHits2_ ) {
422  std::cout << "ZeeCandidateFilter: Electron Candidate #2 is required to have less than " << maxNumberOfExpectedMissingHits2_ << " expected hits missing " << std::endl;
423  }
424 
425  if ( calculateExpectedMissingHits1_ ) {
426  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;
427  }
428 
429  if ( calculateExpectedMissingHits2_ ) {
430  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;
431  }
432 
433  if ( useConversionRejection1_ ) {
434  std::cout << "ZeeCandidateFilter: Electron Candidate #1 is required to pass EGAMMA Conversion Rejection criteria" << std::endl;
435  }
436 
437  if ( useConversionRejection2_ ) {
438  std::cout << "ZeeCandidateFilter: Electron Candidate #2 is required to pass EGAMMA Conversion Rejection criteria" << std::endl;
439  }
440 
441  if ( calculateConversionRejection1_ ) {
442  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;
443  }
444 
445  if ( calculateConversionRejection2_ ) {
446  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;
447  }
448 
449  if ( dataMagneticFieldSetUp_ ) {
450  std::cout << "ZeeCandidateFilter: Data Configuration for Magnetic Field DCS tag " << dcsTag_ << std::endl;
451  }
452 
453  if ( useSpikeRejection_ ) {
454  std::cout << "ZeeCandidateFilter: Spike Cleaning will be done with the Swiss Cross Criterion cutting at " << spikeCleaningSwissCrossCut_ << std::endl;
455  }
456 
457  std::cout << "ZeeCandidateFilter: Fiducial Cut: " << std::endl;
458  std::cout << "ZeeCandidateFilter: BarrelMax: " << BarrelMaxEta_ << std::endl;
459  std::cout << "ZeeCandidateFilter: EndcapMin: " << EndCapMinEta_ << " EndcapMax: " << EndCapMaxEta_ << std::endl;
460 
461  //
462  //------------------------------------------//
463  // EXTRA INFO IN THE EVENT //
464  //------------------------------------------//
465  //
466  produces<pat::CompositeCandidateCollection>("selectedZeeCandidates").setBranchAlias("selectedZeeCandidates");
467 
468 }
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
ZeeCandidateFilter::triggerCollectionTag_
edm::InputTag triggerCollectionTag_
Definition: ZeeCandidateFilter.cc:163
ZeeCandidateFilter::vHltpathFilterExtra_
std::vector< edm::InputTag > vHltpathFilterExtra_
Definition: ZeeCandidateFilter.cc:174
ZeeCandidateFilter::triggerCollectionToken_
edm::EDGetTokenT< edm::TriggerResults > triggerCollectionToken_
Definition: ZeeCandidateFilter.cc:164
HLT_25ns14e33_v1_cff.InputTag
tuple InputTag
Definition: HLT_25ns14e33_v1_cff.py:45333
ZeeCandidateFilter::tracksToken_
edm::EDGetTokenT< reco::TrackCollection > tracksToken_
Definition: ZeeCandidateFilter.cc:156
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
ZeeCandidateFilter::pfMetCollectionToken_
edm::EDGetTokenT< pat::METCollection > pfMetCollectionToken_
Definition: ZeeCandidateFilter.cc:184
ZeeCandidateFilter::tcMetCollectionToken_
edm::EDGetTokenT< pat::METCollection > tcMetCollectionToken_
Definition: ZeeCandidateFilter.cc:185
ZeeCandidateFilter::dcsToken_
edm::EDGetTokenT< DcsStatusCollection > dcsToken_
Definition: ZeeCandidateFilter.cc:155
ZeeCandidateFilter::electronCollectionToken_
edm::EDGetTokenT< pat::ElectronCollection > electronCollectionToken_
Definition: ZeeCandidateFilter.cc:181
ZeeCandidateFilter::metCollectionToken_
edm::EDGetTokenT< pat::METCollection > metCollectionToken_
Definition: ZeeCandidateFilter.cc:183
ZeeCandidateFilter::electronCollectionTag_
edm::InputTag electronCollectionTag_
Definition: ZeeCandidateFilter.cc:180
ZeeCandidateFilter::spikeCleaningSwissCrossCut_
Double_t spikeCleaningSwissCrossCut_
Definition: ZeeCandidateFilter.cc:194
ZeeCandidateFilter::vHltpathExtra_
std::vector< std::string > vHltpathExtra_
Definition: ZeeCandidateFilter.cc:173
ZeeCandidateFilter::hltpathFilter_
edm::InputTag hltpathFilter_
Definition: ZeeCandidateFilter.cc:166
ZeeCandidateFilter::eeRecHitsToken_
edm::EDGetTokenT< EcalRecHitCollection > eeRecHitsToken_
Definition: ZeeCandidateFilter.cc:190
ZeeCandidateFilter::ebRecHitsToken_
edm::EDGetTokenT< EcalRecHitCollection > ebRecHitsToken_
Definition: ZeeCandidateFilter.cc:189
ZeeCandidateFilter::triggerEventToken_
edm::EDGetTokenT< trigger::TriggerEvent > triggerEventToken_
Definition: ZeeCandidateFilter.cc:165
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
ZeeCandidateFilter::PrimaryVerticesCollectionToken_
edm::EDGetTokenT< std::vector< reco::Vertex > > PrimaryVerticesCollectionToken_
Definition: ZeeCandidateFilter.cc:187
ZeeCandidateFilter::~ZeeCandidateFilter ( )

Definition at line 471 of file ZeeCandidateFilter.cc.

472 {
473  // do anything here that needs to be done at desctruction time
474  // (e.g. close files, deallocate resources etc.)
475 }

Member Function Documentation

void ZeeCandidateFilter::endJob ( void  )
overrideprivatevirtual

Reimplemented from edm::EDFilter.

Definition at line 1307 of file ZeeCandidateFilter.cc.

1307 {}
Bool_t ZeeCandidateFilter::filter ( edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
overrideprivatevirtual

Implements edm::EDFilter.

Definition at line 483 of file ZeeCandidateFilter.cc.

References Abs(), reco::CompositeCandidate::addDaughter(), reco::Candidate::begin(), calculateConversionRejection1_, calculateConversionRejection2_, calculateExpectedMissingHits1_, calculateExpectedMissingHits2_, calculateValidFirstPXBHit1_, calculateValidFirstPXBHit2_, counter, gather_cfg::cout, cond::rpcobimon::current, dataMagneticFieldSetUp_, ConversionInfo::dcot(), dcot1_, dcot2_, dcsToken_, reco::deltaR(), ConversionInfo::dist(), dist1_, dist2_, ebRecHitsToken_, electronCollectionTag_, electronCollectionToken_, electronMatched2HLT_, electronMatched2HLT_DR_, trigger::TriggerObject::et(), trigger::TriggerObject::eta(), ETCut_, edm::EventAuxiliary::event(), edm::Event::eventAuxiliary(), cmsPerfPublish::fail(), edm::EventSetup::get(), edm::Event::getByToken(), ConversionFinder::getConversionInfo(), hltObjectETCut_, WZElectronSkims53X_cff::HLTPath, hltpath_, hltpathFilter_, i, HLT_25ns14e33_v1_cff::InputTag, MagneticField::inTesla(), isInFiducial(), edm::EventBase::luminosityBlock(), HLT_25ns14e33_v1_cff::magneticField, maxNumberOfExpectedMissingHits1_, maxNumberOfExpectedMissingHits2_, objects.METAnalyzer::met, metCollectionToken_, METCut_, reco::HitPattern::MISSING_INNER_HITS, pfMetCollectionToken_, trigger::TriggerObject::phi(), position, PrimaryVerticesCollectionToken_, LaserDQM_cfg::process, edm::InputTag::process(), edm::Handle< T >::product(), edm::ESHandle< class >::product(), edm::Event::put(), HLT_25ns14e33_v3_cff::recHits, edm::Event::run(), edm::TriggerNames::size(), spikeCleaningSwissCrossCut_, AlCaHLTBitMon_QueryRunRegistry::string, EcalTools::swissCross(), tcMetCollectionToken_, tracksToken_, triggerCollectionTag_, triggerCollectionToken_, triggerEventToken_, edm::TriggerNames::triggerIndex(), edm::Event::triggerNames(), useConversionRejection1_, useConversionRejection2_, useEcalDrivenElectrons_, useExpectedMissingHits1_, useExpectedMissingHits2_, useExtraTrigger_, useHLTObjectETCut_, useSpikeRejection_, useTriggerInfo_, useValidFirstPXBHit1_, useValidFirstPXBHit2_, vHltpathExtra_, vHltpathFilterExtra_, and PV3DBase< T, PVType, FrameType >::z().

Referenced by Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::filter(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::setDataAccessor(), and Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::switchCenterView().

484 {
485  using namespace edm;
486  using namespace std;
487  using namespace pat;
488 
489 
490  std::cout << "FILTER-MSG: Begin Processing ... "
491  << "Run = " << iEvent.run() << " "
492  << "Lumi = " << (Int_t) iEvent.luminosityBlock() << " "
493  << "Event = " << iEvent.eventAuxiliary().event() << " "
494  << std::endl;
495 
496 
497  /*** TRIGGER REQUIREMENT - Event should pass the trigger, otherwise no zee candidate ***/
498 
499  edm::Handle<edm::TriggerResults> HLTResults;
500  iEvent.getByToken(triggerCollectionToken_, HLTResults);
501 
502  Int_t passTrigger = 0;
503 
504  if ( HLTResults.isValid() ) {
505 
506  const edm::TriggerNames & triggerNames = iEvent.triggerNames(*HLTResults);
507 
508  UInt_t trigger_size = HLTResults->size();
509  UInt_t trigger_position = triggerNames.triggerIndex(hltpath_);
510  UInt_t trigger_position_extra;
511 
512  if ( trigger_position < trigger_size ) {
513  passTrigger = (Int_t)HLTResults->accept(trigger_position);
514  }
515 
516  // Tested TriggerPath firing results printout
517  std::cout << "SK_HLT_INFO"
518  << " | " << "trigger_size = " << trigger_size
519  << " | " << "hltpath_ = " << hltpath_
520  << " | " << "trigger_position = " << trigger_position
521  << " | " << "passTrigger = " << passTrigger
522  << std::endl;
523 
524  if ( useExtraTrigger_ && passTrigger==0 ) {
525  for (Int_t itrig=0; itrig < (Int_t)vHltpathExtra_.size(); ++itrig ) {
526  trigger_position_extra = triggerNames.triggerIndex(vHltpathExtra_[itrig]);
527 
528  if ( trigger_position_extra < trigger_size ) {
529  passTrigger = (Int_t)HLTResults->accept(trigger_position_extra);
530  }
531 
532  // Tested TriggerPath firing results printout
533  std::cout << "SK_HLT_INFO"
534  << " | " << "vHltpathExtra_[" << itrig << "] = " << vHltpathExtra_[itrig]
535  << " | " << "trigger_position_extra = " << trigger_position_extra
536  << " | " << "passTrigger = " << passTrigger
537  << " | " << "vHltpathExtra_.size() = " << vHltpathExtra_.size()
538  << std::endl;
539 
540  if ( passTrigger > 0 ) { break ; }
541 
542  } // for Loop
543 
544  } // if ( useExtraTrigger_ && passTrigger==0 )
545 
546  }
547  else { std::cout << "TriggerResults are missing from this event.." << std::endl;
548  if ( useTriggerInfo_ ) {
549  return false; // RETURN if trigger is missing
550  }
551  }
552 
553  if ( passTrigger == 0 && useTriggerInfo_ ) { std::cout << "No HLT Path is firing in this event" << std::endl;
554  return false; // RETURN if event fails the trigger
555  }
556 
557 
558  edm::Handle<trigger::TriggerEvent> pHLT;
559  iEvent.getByToken(triggerEventToken_, pHLT);
560 
561  const Int_t nF(pHLT->sizeFilters());
562  const Int_t filterInd = pHLT->filterIndex(hltpathFilter_);
563 
564  std::vector<Int_t> filterIndExtra;
565 
566  if ( useExtraTrigger_ ) {
567  for (Int_t itrig =0; itrig < (Int_t)vHltpathFilterExtra_.size(); ++itrig ) { std::cout << "working on #" << itrig << std::endl; std::cout << " ---> " << vHltpathFilterExtra_[itrig] << std::endl;
568  filterIndExtra.push_back( pHLT->filterIndex(vHltpathFilterExtra_[itrig]) );
569  }
570  }
571 
572  Bool_t finalpathfound = false;
573 
574  if ( nF != filterInd ) {
575  finalpathfound = true;
576  }
577  else {
578  for (Int_t itrig=0; itrig < (Int_t)filterIndExtra.size(); ++itrig ) { std::cout << "working on #" << itrig << std::endl; std::cout << " ---> " << filterIndExtra[itrig] << std::endl;
579  if ( nF != filterIndExtra[itrig] ) {
580  finalpathfound = true;
581  break;
582  }
583  }
584  }
585 
586  if ( ! finalpathfound ) { std::cout << "No HLT Filter was not found in this event..." << std::endl;
587  if ( useTriggerInfo_ ) {
588  return false; // RETURN if event fails the trigger
589  }
590  }
591 
592  const trigger::TriggerObjectCollection& TOC(pHLT->getObjects());
593 
594  /*** ET CUT: At least one electron in the event with ET > ETCut_ ***/
595 
596  // Electron Collection
597  edm::Handle<pat::ElectronCollection> patElectron;
598  iEvent.getByToken(electronCollectionToken_, patElectron);
599 
600  if ( ! patElectron.isValid() ) { std::cout << "No electrons found in this event with tag " << electronCollectionTag_ << std::endl;
601  return false; // RETURN if no elecs in the event
602  }
603 
604  const pat::ElectronCollection *pElecs = patElectron.product();
605 
606 // // MET Collection -> relocated block bellow
607 // edm::Handle<pat::METCollection> patMET;
608 // iEvent.getByToken(metCollectionToken_, patMET);
609 //
610 // edm::Handle<pat::METCollection> patpfMET;
611 // iEvent.getByToken(pfMetCollectionToken_, patpfMET);
612 //
613 // edm::Handle<pat::METCollection> pattcMET;
614 // iEvent.getByToken(tcMetCollectionToken_, pattcMET);
615 
616  //
617  // Note: best to do Duplicate removal here, since the current
618  // implementation does not remove triplicates
619  // duplicate removal is on at PAT, but does it remove triplicates?
620  //
621 
622 // pat::ElectronCollection::const_iterator elec; // relocated bellow
623 
624  // check how many electrons there are in the event
625  const Int_t Nelecs = pElecs->size();
626 
627  if ( Nelecs <= 1 ) { std::cout << "No more than 1 electrons found in this event" << std::endl;
628  return false; // RETURN if less than 2 elecs in the event
629  }
630 
631  // Order your electrons: first the ones with the higher ET
632  Int_t counter = 0;
633  std::vector<Int_t> indices;
634  std::vector<Double_t> ETs;
635  pat::ElectronCollection myElectrons;
636 
637  for (pat::ElectronCollection::const_iterator elec = pElecs->begin(); elec != pElecs->end(); ++elec) { // the definition of the electron ET is wrt Gsf track eta
638  Double_t sc_et = elec->caloEnergy()/TMath::CosH(elec->gsfTrack()->eta());
639  indices.push_back(counter);
640  ETs.push_back(sc_et);
641  myElectrons.push_back(*elec);
642  ++counter;
643  }
644 
645  const Int_t event_elec_number = (Int_t)indices.size();
646 
647  if ( event_elec_number <= 1 ) { std::cout << "No more than 1 electrons in fiducial were found" << std::endl;
648  return false; // RETURN if no more than 1 electron in fiducial
649  }
650 
651  // Memory allocation (must be released every time we return back.
652  Int_t *sorted = new Int_t[event_elec_number];
653  Double_t *et = new Double_t[event_elec_number];
654 
655  for (Int_t i=0; i<event_elec_number; ++i ) {
656  et[i] = ETs[i];
657  }
658 
659  // array sorted now has the indices of the highest ET electrons
660  TMath::Sort(event_elec_number, et, sorted, true);
661  //
662  // if the 2 highest electrons in the event has ET < ETCut_ return
663  Int_t max_et_index1 = sorted[0];
664  Int_t max_et_index2 = sorted[1];
665 
666  if ( ( ETs[max_et_index1] < ETCut_ ) || ( ETs[max_et_index2] < ETCut_ ) ) {
667  delete [] sorted;
668  delete [] et;
669  return false; // RETURN: demand the highest ET electrons to have ET > ETcut
670  }
671 
672  // my electrons now:
673  pat::Electron maxETelec1 = myElectrons[max_et_index1];
674  pat::Electron maxETelec2 = myElectrons[max_et_index2];
675 
676  // demand that they are in fiducial:
677  if ( ! isInFiducial(maxETelec1.caloPosition().eta()) ) {
678  delete [] sorted;
679  delete [] et;
680  return false; // RETURN highest ET electron is not in fiducial
681  }
682 
683  if ( ! isInFiducial(maxETelec2.caloPosition().eta()) ) {
684  delete [] sorted;
685  delete [] et;
686  return false; // RETURN 2nd highest ET electron is not in fiducial
687  }
688 
689  // demand that they are ecal driven
690  if ( useEcalDrivenElectrons_ ) {
691  if ( ( ! maxETelec1.ecalDrivenSeed() ) || ( ! maxETelec2.ecalDrivenSeed() ) ) {
692  delete [] sorted;
693  delete [] et;
694  return false; // RETURN At least one high ET electron is not ecal driven
695  }
696  }
697 
698  // spike rejection;
699  if ( useSpikeRejection_ && maxETelec1.isEB() ) {
700 
701  edm::Handle<EcalRecHitCollection> recHits;
702 
703 // if ( maxETelec1.isEB() ) {
704 // iEvent.getByToken(ebRecHitsToken_, recHits);
705 // }
706 // else {
707 // iEvent.getByToken(eeRecHitsToken_, recHits);
708 // }
709 
710  iEvent.getByToken(ebRecHitsToken_, recHits);
711 
712  const EcalRecHitCollection *myRecHits = recHits.product();
713  const DetId seedId = maxETelec1.superCluster()->seed()->seed();
714 
715  Double_t swissCross = EcalTools::swissCross(seedId, *myRecHits,0.);
716 
717  if ( swissCross > spikeCleaningSwissCrossCut_ ) {
718  delete [] sorted;
719  delete [] et;
720  return false; // RETURN highest ET electron is a spike
721  }
722  }
723 
724  if ( useSpikeRejection_ && maxETelec2.isEB() ) {
725 
726  edm::Handle<EcalRecHitCollection> recHits;
727 
728 // if ( maxETelec2.isEB()) {
729 // iEvent.getByToken(ebRecHitsToken_, recHits);
730 // }
731 // else {
732 // iEvent.getByToken(eeRecHitsToken_, recHits);
733 // }
734 
735  iEvent.getByToken(ebRecHitsToken_, recHits);
736 
737  const EcalRecHitCollection *myRecHits = recHits.product();
738  const DetId seedId = maxETelec2.superCluster()->seed()->seed();
739 
740  Double_t swissCross = EcalTools::swissCross(seedId, *myRecHits,0.);
741 
742  if ( swissCross > spikeCleaningSwissCrossCut_ ) {
743  delete [] sorted;
744  delete [] et;
745  return false; // RETURN 2nd highest ET electron is a spike
746  }
747  }
748 
749  // add the primary vtx information in the electron:
750  edm::Handle< std::vector<reco::Vertex> > pVtx;
751  iEvent.getByToken(PrimaryVerticesCollectionToken_, pVtx);
752 
753  const std::vector<reco::Vertex> Vtx = *(pVtx.product());
754 
755  Double_t pv_x = -999999.;
756  Double_t pv_y = -999999.;
757  Double_t pv_z = -999999.;
758 
759  Double_t ele_tip_pv1 = -999999.;
760  Double_t ele_tip_pv2 = -999999.;
761 
762  if ( Vtx.size() >=1 ) {
763  pv_x = Vtx[0].position().x();
764  pv_y = Vtx[0].position().y();
765  pv_z = Vtx[0].position().z();
766  ele_tip_pv1 = (-1.0) * ( maxETelec1.gsfTrack()->dxy(Vtx[0].position()) ) ;
767  ele_tip_pv2 = (-1.0) * ( maxETelec2.gsfTrack()->dxy(Vtx[0].position()) ) ;
768  }
769 
770  maxETelec1.addUserFloat("pv_x", Float_t(pv_x));
771  maxETelec1.addUserFloat("pv_x", Float_t(pv_y));
772  maxETelec1.addUserFloat("pv_z", Float_t(pv_z));
773  maxETelec1.addUserFloat("ele_tip_pv", Float_t(ele_tip_pv1));
774 
775  maxETelec2.addUserFloat("pv_x", Float_t(pv_x));
776  maxETelec2.addUserFloat("pv_x", Float_t(pv_y));
777  maxETelec2.addUserFloat("pv_z", Float_t(pv_z));
778  maxETelec2.addUserFloat("ele_tip_pv", Float_t(ele_tip_pv2));
779 
780 // Double_t pv_x1 = -999999.;
781 // Double_t pv_y1 = -999999.;
782 // Double_t pv_z1 = -999999.;
783 // Double_t ele_tip_pv1 = -999999.;
784 //
785 // if ( Vtx.size() >=1 ) {
786 // pv_x1 = Vtx[0].position().x();
787 // pv_y1 = Vtx[0].position().y();
788 // pv_z1 = Vtx[0].position().z();
789 // ele_tip_pv1 = (-1.0) * ( maxETelec1.gsfTrack()->dxy(Vtx[0].position()) ) ;
790 // }
791 //
792 // maxETelec1.addUserFloat("pv_x", Float_t(pv_x1));
793 // maxETelec1.addUserFloat("pv_x", Float_t(pv_y1));
794 // maxETelec1.addUserFloat("pv_z", Float_t(pv_z1));
795 // maxETelec1.addUserFloat("ele_tip_pv", Float_t(ele_tip_pv1));
796 //
797 // edm::Handle< std::vector<reco::Vertex> > pVtx2;
798 // iEvent.getByToken(PrimaryVerticesCollectionToken_, pVtx2);
799 //
800 // const std::vector<reco::Vertex> Vtx2 = *(pVtx2.product());
801 //
802 // Double_t pv_x2 = -999999.;
803 // Double_t pv_y2 = -999999.;
804 // Double_t pv_z2 = -999999.;
805 // Double_t ele_tip_pv2 = -999999.;
806 //
807 // if ( Vtx2.size() >=1 ) {
808 // pv_x2 = Vtx2[0].position().x();
809 // pv_y2 = Vtx2[0].position().y();
810 // pv_z2 = Vtx2[0].position().z();
811 // ele_tip_pv2 = -maxETelec2.gsfTrack()->dxy(Vtx2[0].position());
812 // }
813 //
814 // maxETelec2.addUserFloat("pv_x", Float_t(pv_x1));
815 // maxETelec2.addUserFloat("pv_x", Float_t(pv_y1));
816 // maxETelec2.addUserFloat("pv_z", Float_t(pv_z1));
817 // maxETelec2.addUserFloat("ele_tip_pv", Float_t(ele_tip_pv2));
818 
819 
820  // Special pre-selection requirements (hit pattern and conversion rejection)
821 
822  if ( useValidFirstPXBHit1_ || calculateValidFirstPXBHit1_ ) {
823 
824  Bool_t fail = !maxETelec1.gsfTrack()->hitPattern().hasValidHitInFirstPixelBarrel();
825 
826  if ( useValidFirstPXBHit1_ && fail ) { std::cout << "Filter: there is no valid hit for electron #1 in 1st layer PXB" << std::endl;
827  delete [] sorted;
828  delete [] et;
829  return false;
830  }
831 
832  if ( calculateValidFirstPXBHit1_ ) {
833 
834  std::string vfpx("PassValidFirstPXBHit");
835 
836  if ( fail ) {
837  maxETelec1.addUserInt(vfpx,0);
838  }
839  else {
840  maxETelec1.addUserInt(vfpx,1);
841  }
842 
843  }
844 
845  }
846 
847  if ( useValidFirstPXBHit2_ || calculateValidFirstPXBHit2_ ) {
848 
849  Bool_t fail = !maxETelec2.gsfTrack()->hitPattern().hasValidHitInFirstPixelBarrel();
850 
851  if ( useValidFirstPXBHit2_ && fail ) { std::cout << "Filter: there is no valid hit for electron #1 in 1st layer PXB" << std::endl;
852  delete [] sorted;
853  delete [] et;
854  return false;
855  }
856 
857  if ( calculateValidFirstPXBHit2_ ) {
858 
859  std::string vfpx("PassValidFirstPXBHit");
860 
861  if ( fail ) {
862  maxETelec2.addUserInt(vfpx,0);
863  }
864  else {
865  maxETelec2.addUserInt(vfpx,1);
866  }
867 
868  }
869 
870  }
871 
872  if ( useExpectedMissingHits1_ || calculateExpectedMissingHits1_ ) {
873 
874  Int_t numberOfInnerHits = (Int_t)( maxETelec1.gsfTrack()->hitPattern().numberOfHits(reco::HitPattern::MISSING_INNER_HITS));
875 
876  if ( ( numberOfInnerHits > maxNumberOfExpectedMissingHits1_ ) && useExpectedMissingHits1_ ) {
877  delete [] sorted;
878  delete [] et;
879  return false;
880  }
881 
882  if ( calculateExpectedMissingHits1_ ) {
883  maxETelec1.addUserInt("NumberOfExpectedMissingHits",numberOfInnerHits);
884  }
885 
886  }
887 
888  if ( useExpectedMissingHits2_ || calculateExpectedMissingHits2_ ) {
889 
890  Int_t numberOfInnerHits = (Int_t)( maxETelec2.gsfTrack()->hitPattern().numberOfHits(reco::HitPattern::MISSING_INNER_HITS) );
891 
892  if ( ( numberOfInnerHits > maxNumberOfExpectedMissingHits2_ ) && useExpectedMissingHits2_ ) {
893  delete [] sorted;
894  delete [] et;
895  return false;
896  }
897 
898  if ( calculateExpectedMissingHits2_ ) {
899  maxETelec2.addUserInt("NumberOfExpectedMissingHits",numberOfInnerHits);
900  }
901  }
902 
903  if ( useConversionRejection1_ || calculateConversionRejection1_ ) {
904  // use of conversion rejection as it is implemented in egamma
905  // you have to get the general track collection to do that
906  // WARNING! you have to supply the correct B-field in Tesla
907  // the magnetic field
908 
909  Double_t bfield;
910 
911  if ( dataMagneticFieldSetUp_ ) {
912 
913  edm::Handle<DcsStatusCollection> dcsHandle;
914  iEvent.getByToken(dcsToken_, dcsHandle);
915  // scale factor = 3.801/18166.0 which are
916  // average values taken over a stable two
917  // week period
918  Double_t currentToBFieldScaleFactor = 2.09237036221512717e-04;
919  Double_t current = (*dcsHandle)[0].magnetCurrent();
920  bfield = current*currentToBFieldScaleFactor;
921 
922  } else {
923 
924  edm::ESHandle<MagneticField> magneticField;
925  iSetup.get<IdealMagneticFieldRecord>().get(magneticField);
926  const MagneticField *mField = magneticField.product();
927  bfield = mField->inTesla(GlobalPoint(0.0,0.0,0.0)).z();
928 
929  }
930 
931  edm::Handle<reco::TrackCollection> ctfTracks;
932 
933  if ( iEvent.getByToken(tracksToken_, ctfTracks) ) {
934 
935  ConversionFinder convFinder;
936  ConversionInfo convInfo = convFinder.getConversionInfo(maxETelec1, ctfTracks, bfield);
937 
938  Float_t dist = convInfo.dist();
939  Float_t dcot = convInfo.dcot();
940 
941  Bool_t isConv = ( ( TMath::Abs(dist) < dist1_ ) && ( TMath::Abs(dcot) < dcot1_ ) ) ;
942 
943  std::cout << "Filter: for electron #1 the conversion says " << isConv << std::endl;
944 
945  if ( isConv && useConversionRejection1_ ) {
946  delete [] sorted;
947  delete [] et;
948  return false;
949  }
950 
951  if ( calculateConversionRejection1_ ) {
952 
953  maxETelec1.addUserFloat("Dist", Float_t(dist));
954  maxETelec1.addUserFloat("Dcot", Float_t(dcot));
955 
956  if ( isConv ) {
957  maxETelec1.addUserInt("PassConversionRejection",0);
958  }
959  else {
960  maxETelec1.addUserInt("PassConversionRejection",1);
961  }
962 
963  }
964 
965  }
966  else {
967  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;
968  }
969 
970  }
971 
972  if ( useConversionRejection2_ || calculateConversionRejection2_ ) {
973  // use of conversion rejection as it is implemented in egamma
974  // you have to get the general track collection to do that
975  // WARNING! you have to supply the correct B-field in Tesla
976  // the magnetic field
977 
978  Double_t bfield;
979 
980  if ( dataMagneticFieldSetUp_ ) {
981 
982  edm::Handle<DcsStatusCollection> dcsHandle;
983  iEvent.getByToken(dcsToken_, dcsHandle);
984 
985  // scale factor = 3.801/18166.0 which are
986  // average values taken over a stable two
987  // week period
988 
989  Double_t currentToBFieldScaleFactor = 2.09237036221512717e-04;
990  Double_t current = (*dcsHandle)[0].magnetCurrent();
991  bfield = current*currentToBFieldScaleFactor;
992 
993  } else {
994 
995  edm::ESHandle<MagneticField> magneticField;
996  iSetup.get<IdealMagneticFieldRecord>().get(magneticField);
997  const MagneticField *mField = magneticField.product();
998  bfield = mField->inTesla(GlobalPoint(0.0,0.0,0.0)).z();
999 
1000  }
1001 
1002  edm::Handle<reco::TrackCollection> ctfTracks;
1003 
1004  if ( iEvent.getByToken(tracksToken_, ctfTracks) ) {
1005 
1006  ConversionFinder convFinder;
1007  ConversionInfo convInfo = convFinder.getConversionInfo(maxETelec2, ctfTracks, bfield);
1008 
1009  Float_t dist = convInfo.dist();
1010  Float_t dcot = convInfo.dcot();
1011 
1012  Bool_t isConv = ( ( TMath::Abs(dist) < dist2_ ) && ( TMath::Abs(dcot) < dcot2_ ) ) ;
1013 
1014  std::cout << "Filter: for electron #2 the conversion says " << isConv << std::endl;
1015 
1016  if ( isConv && useConversionRejection2_ ) {
1017  delete [] sorted;
1018  delete [] et;
1019  return false;
1020  }
1021 
1022  if ( calculateConversionRejection2_ ) {
1023 
1024  maxETelec2.addUserFloat("Dist", Float_t(dist));
1025  maxETelec2.addUserFloat("Dcot", Float_t(dcot));
1026 
1027  if ( isConv ) {
1028  maxETelec2.addUserInt("PassConversionRejection",0);
1029  }
1030  else {
1031  maxETelec2.addUserInt("PassConversionRejection",1);
1032  }
1033 
1034  }
1035 
1036  }
1037  else {
1038  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;
1039  }
1040 
1041  }
1042 
1043  std::cout << "HLT matching starts" << std::endl;
1044 
1045  if ( electronMatched2HLT_ && useTriggerInfo_ ) {
1046 
1047  Double_t matched_dr_distance1 = 999999.;
1048  Int_t trigger_int_probe1 = 0;
1049 
1050  Double_t matched_dr_distance2 = 999999.;
1051  Int_t trigger_int_probe2 = 0;
1052 
1053  if ( finalpathfound ) {
1054 
1055  if ( nF != filterInd ) {
1056 
1057  const trigger::Keys& KEYS(pHLT->filterKeys(filterInd));
1058  const Int_t nK(KEYS.size());
1059 
1060  std::cout << "Found trig objects #" << nK << std::endl;
1061 
1062  for ( Int_t iTrig = 0; iTrig < nK; ++iTrig ) {
1063 
1064  const trigger::TriggerObject& TO(TOC[KEYS[iTrig]]);
1065 
1066  if ( useHLTObjectETCut_ ) {
1067  if ( TO.et() < hltObjectETCut_ ) {
1068  continue;
1069  }
1070  }
1071 
1072  Double_t dr_ele_HLT1 = reco::deltaR(maxETelec1.superCluster()->eta(),maxETelec1.superCluster()->phi(),TO.eta(),TO.phi());
1073  Double_t dr_ele_HLT2 = reco::deltaR(maxETelec2.superCluster()->eta(),maxETelec2.superCluster()->phi(),TO.eta(),TO.phi());
1074 
1075  //std::cout << "-->found dr=" << dr_ele_HLT << std::endl;
1076 
1077  if ( TMath::Abs(dr_ele_HLT1) < matched_dr_distance1 ) {
1078  matched_dr_distance1 = dr_ele_HLT1;
1079  }
1080 
1081  if ( TMath::Abs(dr_ele_HLT2) < matched_dr_distance2 ) {
1082  matched_dr_distance2 = dr_ele_HLT2;
1083  }
1084 
1085  }
1086 
1087  }
1088 
1089  if ( useExtraTrigger_ ) {
1090 
1091  for (Int_t itrig=0; itrig < (Int_t) filterIndExtra.size(); ++itrig ) {
1092 
1093  if ( filterIndExtra[itrig] == nF ) {
1094  continue;
1095  }
1096 
1097  std::cout << "working on #" << itrig << std::endl; std::cout << " ---> " << filterIndExtra[itrig] << std::endl;
1098 
1099  const trigger::Keys& KEYS(pHLT->filterKeys(filterIndExtra[itrig]));
1100  const Int_t nK(KEYS.size());
1101 
1102  std::cout << "Found trig objects #" << nK << std::endl;
1103 
1104  for (Int_t iTrig = 0; iTrig <nK; ++iTrig ) {
1105 
1106  const trigger::TriggerObject& TO(TOC[KEYS[iTrig]]);
1107 
1108  Double_t dr_ele_HLT1 = reco::deltaR(maxETelec1.eta(),maxETelec1.phi(),TO.eta(),TO.phi());
1109  Double_t dr_ele_HLT2 = reco::deltaR(maxETelec2.eta(),maxETelec2.phi(),TO.eta(),TO.phi());
1110 
1111  //std::cout << "-->found dr=" << dr_ele_HLT << std::endl;
1112 
1113  if ( TMath::Abs(dr_ele_HLT1) < matched_dr_distance1 ) {
1114  matched_dr_distance1 = dr_ele_HLT1;
1115  }
1116 
1117  if ( TMath::Abs(dr_ele_HLT2) < matched_dr_distance2 ) {
1118  matched_dr_distance2 = dr_ele_HLT2;
1119  }
1120  }
1121  }
1122  }
1123 
1124  if ( matched_dr_distance1 < electronMatched2HLT_DR_ ) {
1125  ++trigger_int_probe1;
1126  }
1127 
1128  if ( matched_dr_distance2 < electronMatched2HLT_DR_ ) {
1129  ++trigger_int_probe2;
1130  }
1131 
1132  if ( ( trigger_int_probe1 == 0 ) && ( trigger_int_probe2 == 0 ) ) { std::cout << "No electron could be matched to an HLT object with " << std::endl;
1133 
1134  delete [] sorted;
1135  delete [] et;
1136 
1137  return false; // RETURN: electron is not matched to an HLT object
1138  }
1139 
1140  maxETelec1.addUserFloat("HLTMatchingDR", Float_t(matched_dr_distance1));
1141  maxETelec2.addUserFloat("HLTMatchingDR", Float_t(matched_dr_distance2));
1142 
1143  }
1144  else { //std::cout << "Electron filter not found - should not be like that... " << std::endl;
1145 
1146  delete [] sorted;
1147  delete [] et;
1148 
1149  return false; // RETURN: electron is not matched to an HLT object
1150  }
1151  }
1152 
1153  std::cout << "HLT matching has finished" << std::endl;
1154 
1155  // ___________________________________________________________________
1156  //
1157 
1158  // add information of whether the event passes the following sets of
1159  // triggers. Currently Hardwired, to be changed in the future
1160 
1161  if ( HLTResults.isValid() ) {
1162 
1163  const std::string process = triggerCollectionTag_.process();
1164  //
1165  std::string HLTPath[18];
1166  HLTPath[0 ] = "HLT_Photon10_L1R" ;
1167  HLTPath[1 ] = "HLT_Photon15_L1R" ;
1168  HLTPath[2 ] = "HLT_Photon20_L1R" ;
1169  HLTPath[3 ] = "HLT_Photon15_TrackIso_L1R" ;
1170  HLTPath[4 ] = "HLT_Photon15_LooseEcalIso_L1R" ;
1171  HLTPath[5 ] = "HLT_Photon30_L1R_8E29" ;
1172  HLTPath[6 ] = "HLT_Photon30_L1R_8E29" ;
1173  HLTPath[7 ] = "HLT_Ele10_LW_L1R" ;
1174  HLTPath[8 ] = "HLT_Ele15_LW_L1R" ;
1175  HLTPath[9 ] = "HLT_Ele20_LW_L1R" ;
1176  HLTPath[10] = "HLT_Ele10_LW_EleId_L1R" ;
1177  HLTPath[11] = "HLT_Ele15_SiStrip_L1R" ;
1178  HLTPath[12] = "HLT_IsoTrackHB_8E29" ;
1179  HLTPath[13] = "HLT_IsoTrackHE_8E29" ;
1180  HLTPath[14] = "HLT_DiJetAve15U_8E29" ;
1181  HLTPath[15] = "HLT_MET45" ;
1182  HLTPath[16] = "HLT_L1MET20" ;
1183  HLTPath[17] = "HLT_MET100" ;
1184  //
1185  edm::InputTag HLTFilterType[15];
1186  HLTFilterType[0 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt10HcalIsolFilter","",process) ; //HLT_Photon10_L1R
1187  HLTFilterType[1 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt15HcalIsolFilter" ,"",process) ; //HLT_Photon15_L1R
1188  HLTFilterType[2 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt20HcalIsolFilter" ,"",process) ; //HLT_Photon20_L1R
1189  HLTFilterType[3 ]= edm::InputTag("hltL1NonIsoSinglePhotonEt15HTITrackIsolFilter","",process) ; //HLT_Photon15_TrackIso_L1R
1190  HLTFilterType[4 ]= edm::InputTag("hltL1NonIsoSinglePhotonEt15LEIHcalIsolFilter","",process) ; //HLT_Photon15_LooseEcalIso_L1R
1191  HLTFilterType[5 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt15EtFilterESet308E29","",process) ; //HLT_Photon30_L1R_8E29
1192  HLTFilterType[6 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSinglePhotonEt15HcalIsolFilter","",process) ; //HLT_Photon30_L1R_8E29
1193  HLTFilterType[7 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronLWEt10PixelMatchFilter","",process) ;
1194  HLTFilterType[8 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronLWEt15PixelMatchFilter","",process) ;
1195  HLTFilterType[9 ]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronLWEt15EtFilterESet20","",process) ;
1196  HLTFilterType[10]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronLWEt10EleIdDphiFilter","",process) ;
1197  HLTFilterType[11]= edm::InputTag("hltL1NonIsoHLTNonIsoSingleElectronSiStripEt15PixelMatchFilter","",process) ;
1198  HLTFilterType[12]= edm::InputTag("hltIsolPixelTrackL3FilterHB8E29","",process) ;
1199  HLTFilterType[13]= edm::InputTag("hltIsolPixelTrackL2FilterHE8E29","",process) ;
1200  HLTFilterType[14]= edm::InputTag("hltL1sDiJetAve15U8E29","",process) ;
1201  //
1202  Int_t triggerDecision = 0;
1203  UInt_t trigger_size = HLTResults->size();
1204 
1205  for (Int_t i=0; i<18; ++i ) {
1206 
1207  const edm::TriggerNames & triggerNames = iEvent.triggerNames(*HLTResults);
1208  UInt_t trigger_position = triggerNames.triggerIndex(HLTPath[i]);
1209  Int_t passTrigger = 0;
1210 
1211  if ( trigger_position < trigger_size ) {
1212  passTrigger = (Int_t)HLTResults->accept(trigger_position);
1213  }
1214 
1215  if ( passTrigger > 0 ) {
1216  if ( i >= 15 ) {
1217  triggerDecision += (Int_t)(TMath::Power(2,i));
1218  }
1219  else {
1220  const Int_t myfilterInd = pHLT->filterIndex(HLTFilterType[i]);
1221  if ( myfilterInd != nF ) {
1222  triggerDecision += (Int_t)(TMath::Power(2,i));
1223  }
1224  }
1225  }
1226  }
1227 
1228  // add the info in the maxETelec1 and maxETelec2
1229  maxETelec1.addUserInt("triggerDecision",triggerDecision);
1230  maxETelec2.addUserInt("triggerDecision",triggerDecision);
1231  }
1232 
1233  // ___________________________________________________________________
1234  //
1235 
1236  // MET Collection
1237  edm::Handle<pat::METCollection> patMET;
1238  iEvent.getByToken(metCollectionToken_, patMET);
1239 
1240  edm::Handle<pat::METCollection> patpfMET;
1241  iEvent.getByToken(pfMetCollectionToken_, patpfMET);
1242 
1243  edm::Handle<pat::METCollection> pattcMET;
1244  iEvent.getByToken(tcMetCollectionToken_, pattcMET);
1245 
1246  const pat::METCollection *pMet = patMET.product();
1247  const pat::METCollection::const_iterator met = pMet->begin();
1248  const pat::MET theMET = *met;
1249  //
1250  const pat::METCollection *pPfMet = patpfMET.product();
1251  const pat::METCollection::const_iterator pfmet = pPfMet->begin();
1252  const pat::MET thePfMET = *pfmet;
1253  //
1254  const pat::METCollection *pTcMet = pattcMET.product();
1255  const pat::METCollection::const_iterator tcmet = pTcMet->begin();
1256  const pat::MET theTcMET = *tcmet;
1257 
1258  Double_t metEt = met->et();
1259  //Double_t metEta = met->eta();
1260  //Double_t metMt = met->mt();
1261  //Double_t metPhi = met->phi();
1262  //Double_t metSig = met->mEtSig();
1263  //std::cout<<"met properties: et=" << met->et() << ", eta: " << met->eta()
1264  // << std::endl;
1265  //
1266  if ( metEt < METCut_ ) { std::cout << "MET is " << metEt << std::endl;
1267 
1268  delete [] sorted;
1269  delete [] et;
1270 
1271  return false; // RETURN if MET is < Metcut
1272  }
1273 
1274 
1275  // if you have indeed reached this point then you have a zeeCandidate!!!
1276 
1277  pat::CompositeCandidate zeeCandidate;
1278 
1279  zeeCandidate.addDaughter(maxETelec1, "electron1");
1280  zeeCandidate.addDaughter(maxETelec2, "electron2");
1281 
1282  zeeCandidate.addDaughter(theMET, "met");
1283  zeeCandidate.addDaughter(thePfMET, "pfmet");
1284  zeeCandidate.addDaughter(theTcMET, "tcmet");
1285 
1286  auto_ptr<pat::CompositeCandidateCollection>selectedZeeCandidates(new pat::CompositeCandidateCollection);
1287 
1288  selectedZeeCandidates->push_back(zeeCandidate);
1289 
1290  iEvent.put(selectedZeeCandidates, "selectedZeeCandidates");
1291 
1292  // release your memory
1293  delete [] sorted;
1294  delete [] et;
1295 
1296  std::cout << "Run = " << iEvent.run() << " "
1297  << "Lumi = " << (Int_t)iEvent.luminosityBlock() << " "
1298  << "Event = " << iEvent.eventAuxiliary().event() << " "
1299  << "FILTER-MSG: Event Accepted for Z Candidate"
1300  << std::endl;
1301 
1302  return true;
1303 
1304 }
pat::CompositeCandidate
Analysis-level particle class.
Definition: CompositeCandidate.h:34
pat::MET
Analysis-level MET class.
Definition: MET.h:43
i
int i
Definition: DBlmapReader.cc:9
edm::Event::triggerNames
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:220
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:464
ZeeCandidateFilter::triggerCollectionTag_
edm::InputTag triggerCollectionTag_
Definition: ZeeCandidateFilter.cc:163
MagneticField::inTesla
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
ConversionFinder::getConversionInfo
ConversionInfo getConversionInfo(const reco::GsfElectronCore &, const edm::Handle< reco::TrackCollection > &ctftracks_h, const edm::Handle< reco::GsfTrackCollection > &gsftracks_h, const double bFieldAtOrigin, const double minFracSharedHits=0.45)
Definition: ConversionFinder.cc:34
pat::METCollection
std::vector< MET > METCollection
Definition: MET.h:32
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
ConversionInfo::dist
double dist() const
Definition: ConversionInfo.h:45
WZElectronSkims53X_cff.HLTPath
string HLTPath
Definition: WZElectronSkims53X_cff.py:3
edm::EventBase::luminosityBlock
edm::LuminosityBlockNumber_t luminosityBlock() const
Definition: EventBase.h:63
HLT_25ns14e33_v1_cff.magneticField
tuple magneticField
Definition: HLT_25ns14e33_v1_cff.py:314
HLT_25ns14e33_v3_cff.recHits
tuple recHits
Definition: HLT_25ns14e33_v3_cff.py:52857
edm::TriggerNames::size
Strings::size_type size() const
Definition: TriggerNames.cc:39
reco::deltaR
double deltaR(const T1 &t1, const T2 &t2)
Definition: deltaR.h:48
ZeeCandidateFilter::vHltpathFilterExtra_
std::vector< edm::InputTag > vHltpathFilterExtra_
Definition: ZeeCandidateFilter.cc:174
ZeeCandidateFilter::triggerCollectionToken_
edm::EDGetTokenT< edm::TriggerResults > triggerCollectionToken_
Definition: ZeeCandidateFilter.cc:164
HLT_25ns14e33_v1_cff.InputTag
tuple InputTag
Definition: HLT_25ns14e33_v1_cff.py:45333
ZeeCandidateFilter::tracksToken_
edm::EDGetTokenT< reco::TrackCollection > tracksToken_
Definition: ZeeCandidateFilter.cc:156
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
ZeeCandidateFilter::pfMetCollectionToken_
edm::EDGetTokenT< pat::METCollection > pfMetCollectionToken_
Definition: ZeeCandidateFilter.cc:184
trigger::TriggerObject
Single trigger physics object (e.g., an isolated muon)
Definition: TriggerObject.h:22
ZeeCandidateFilter::tcMetCollectionToken_
edm::EDGetTokenT< pat::METCollection > tcMetCollectionToken_
Definition: ZeeCandidateFilter.cc:185
ZeeCandidateFilter::dcsToken_
edm::EDGetTokenT< DcsStatusCollection > dcsToken_
Definition: ZeeCandidateFilter.cc:155
pat::ElectronCollection
std::vector< Electron > ElectronCollection
Definition: Electron.h:37
edm::TriggerNames::triggerIndex
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
edm::Event::put
OrphanHandle< PROD > put(std::auto_ptr< PROD > product)
Put a new product.
Definition: Event.h:120
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
Abs
T Abs(T a)
Definition: MathUtil.h:49
edm::Event::run
RunNumber_t run() const
Definition: Event.h:92
ZeeCandidateFilter::electronCollectionToken_
edm::EDGetTokenT< pat::ElectronCollection > electronCollectionToken_
Definition: ZeeCandidateFilter.cc:181
ZeeCandidateFilter::isInFiducial
Bool_t isInFiducial(Double_t eta)
Definition: ZeeCandidateFilter.cc:1309
ZeeCandidateFilter::metCollectionToken_
edm::EDGetTokenT< pat::METCollection > metCollectionToken_
Definition: ZeeCandidateFilter.cc:183
reco::CompositeCandidate::addDaughter
void addDaughter(const Candidate &, const std::string &s="")
add a clone of the passed candidate as daughter
Definition: CompositeCandidate.cc:117
ZeeCandidateFilter::electronCollectionTag_
edm::InputTag electronCollectionTag_
Definition: ZeeCandidateFilter.cc:180
ZeeCandidateFilter::spikeCleaningSwissCrossCut_
Double_t spikeCleaningSwissCrossCut_
Definition: ZeeCandidateFilter.cc:194
trigger::TriggerObjectCollection
std::vector< TriggerObject > TriggerObjectCollection
collection of trigger physics objects (e.g., all isolated muons)
Definition: TriggerObject.h:81
edm::Event::eventAuxiliary
EventAuxiliary const & eventAuxiliary() const
Definition: Event.h:76
DetId
Definition: DetId.h:18
pat::CompositeCandidateCollection
std::vector< CompositeCandidate > CompositeCandidateCollection
Definition: CompositeCandidate.h:23
edm::Handle::product
T const * product() const
Definition: Handle.h:81
trigger::Keys
std::vector< size_type > Keys
Definition: TriggerTypeDefs.h:20
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:56
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
ZeeCandidateFilter::vHltpathExtra_
std::vector< std::string > vHltpathExtra_
Definition: ZeeCandidateFilter.cc:173
pat::Electron
Analysis-level electron class.
Definition: Electron.h:52
EcalTools::swissCross
static float swissCross(const DetId &id, const EcalRecHitCollection &recHits, float recHitThreshold, bool avoidIeta85=true)
the good old 1-e4/e1. Ignore hits below recHitThreshold
Definition: EcalTools.cc:11
edm::InputTag::process
std::string const & process() const
Definition: InputTag.h:47
ZeeCandidateFilter::hltpathFilter_
edm::InputTag hltpathFilter_
Definition: ZeeCandidateFilter.cc:166
counter
static std::atomic< unsigned int > counter
Definition: SharedResourceNames.cc:15
position
static int position[264][3]
Definition: ReadPGInfo.cc:509
ZeeCandidateFilter::ebRecHitsToken_
edm::EDGetTokenT< EcalRecHitCollection > ebRecHitsToken_
Definition: ZeeCandidateFilter.cc:189
reco::Candidate::begin
const_iterator begin() const
first daughter const_iterator
Definition: Candidate.h:144
ZeeCandidateFilter::triggerEventToken_
edm::EDGetTokenT< trigger::TriggerEvent > triggerEventToken_
Definition: ZeeCandidateFilter.cc:165
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
ConversionInfo::dcot
double dcot() const
Definition: ConversionInfo.h:46
LaserDQM_cfg.process
tuple process
Definition: LaserDQM_cfg.py:3
ZeeCandidateFilter::PrimaryVerticesCollectionToken_
edm::EDGetTokenT< std::vector< reco::Vertex > > PrimaryVerticesCollectionToken_
Definition: ZeeCandidateFilter.cc:187
edm::EventAuxiliary::event
EventNumber_t event() const
Definition: EventAuxiliary.h:66
Bool_t ZeeCandidateFilter::isInFiducial ( Double_t  eta)
private

Definition at line 1309 of file ZeeCandidateFilter.cc.

References Abs(), BarrelMaxEta_, EndCapMaxEta_, and EndCapMinEta_.

Referenced by filter().

1310 {
1311  if ( TMath::Abs(eta) < BarrelMaxEta_ ) {
1312  return true;
1313  }
1314  else if ( ( TMath::Abs(eta) < EndCapMaxEta_ ) && ( TMath::Abs(eta) > EndCapMinEta_ ) ) {
1315  return true;
1316  }
1317 
1318  return false;
1319 
1320 }
Abs
T Abs(T a)
Definition: MathUtil.h:49

Member Data Documentation

Double_t ZeeCandidateFilter::BarrelMaxEta_
private

Definition at line 158 of file ZeeCandidateFilter.cc.

Referenced by isInFiducial(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::calculateConversionRejection1_
private

Definition at line 130 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::calculateConversionRejection2_
private

Definition at line 139 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::calculateExpectedMissingHits1_
private

Definition at line 132 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::calculateExpectedMissingHits2_
private

Definition at line 141 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::calculateValidFirstPXBHit1_
private

Definition at line 128 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::calculateValidFirstPXBHit2_
private

Definition at line 137 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::dataMagneticFieldSetUp_
private

Definition at line 152 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::dcot1_
private

Definition at line 146 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::dcot2_
private

Definition at line 150 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::InputTag ZeeCandidateFilter::dcsTag_
private

Definition at line 154 of file ZeeCandidateFilter.cc.

Referenced by ZeeCandidateFilter().

edm::EDGetTokenT<DcsStatusCollection> ZeeCandidateFilter::dcsToken_
private

Definition at line 155 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::dist1_
private

Definition at line 145 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::dist2_
private

Definition at line 149 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT<EcalRecHitCollection> ZeeCandidateFilter::ebRecHitsToken_
private

Definition at line 189 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT<EcalRecHitCollection> ZeeCandidateFilter::eeRecHitsToken_
private

Definition at line 190 of file ZeeCandidateFilter.cc.

Referenced by ZeeCandidateFilter().

edm::InputTag ZeeCandidateFilter::electronCollectionTag_
private

Definition at line 180 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT<pat::ElectronCollection> ZeeCandidateFilter::electronCollectionToken_
private

Definition at line 181 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::electronMatched2HLT_
private

Definition at line 177 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::electronMatched2HLT_DR_
private

Definition at line 178 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::EndCapMaxEta_
private

Definition at line 159 of file ZeeCandidateFilter.cc.

Referenced by isInFiducial(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::EndCapMinEta_
private

Definition at line 160 of file ZeeCandidateFilter.cc.

Referenced by isInFiducial(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::ETCut_
private

Definition at line 121 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::hltObjectETCut_
private

Definition at line 169 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

std::string ZeeCandidateFilter::hltpath_
private

Definition at line 162 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::InputTag ZeeCandidateFilter::hltpathFilter_
private

Definition at line 166 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Int_t ZeeCandidateFilter::maxNumberOfExpectedMissingHits1_
private

Definition at line 133 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Int_t ZeeCandidateFilter::maxNumberOfExpectedMissingHits2_
private

Definition at line 142 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT<pat::METCollection> ZeeCandidateFilter::metCollectionToken_
private

Definition at line 183 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::METCut_
private

Definition at line 122 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT<pat::METCollection> ZeeCandidateFilter::pfMetCollectionToken_
private

Definition at line 184 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT< std::vector<reco::Vertex> > ZeeCandidateFilter::PrimaryVerticesCollectionToken_
private

Definition at line 187 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Double_t ZeeCandidateFilter::spikeCleaningSwissCrossCut_
private

Definition at line 194 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT<pat::METCollection> ZeeCandidateFilter::tcMetCollectionToken_
private

Definition at line 185 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT<reco::TrackCollection> ZeeCandidateFilter::tracksToken_
private

Definition at line 156 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::InputTag ZeeCandidateFilter::triggerCollectionTag_
private

Definition at line 163 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT<edm::TriggerResults> ZeeCandidateFilter::triggerCollectionToken_
private

Definition at line 164 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

edm::EDGetTokenT<trigger::TriggerEvent> ZeeCandidateFilter::triggerEventToken_
private

Definition at line 165 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useConversionRejection1_
private

Definition at line 129 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useConversionRejection2_
private

Definition at line 138 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useEcalDrivenElectrons_
private

Definition at line 124 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useExpectedMissingHits1_
private

Definition at line 131 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useExpectedMissingHits2_
private

Definition at line 140 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useExtraTrigger_
private

Definition at line 171 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useHLTObjectETCut_
private

Definition at line 167 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useSpikeRejection_
private

Definition at line 192 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useTriggerInfo_
private

Definition at line 176 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useValidFirstPXBHit1_
private

Definition at line 127 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Bool_t ZeeCandidateFilter::useValidFirstPXBHit2_
private

Definition at line 136 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

std::vector<std::string> ZeeCandidateFilter::vHltpathExtra_
private

Definition at line 173 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

std::vector<edm::InputTag> ZeeCandidateFilter::vHltpathFilterExtra_
private

Definition at line 174 of file ZeeCandidateFilter.cc.

Referenced by filter(), and ZeeCandidateFilter().

Generated for CMSSW Reference Manual by doxygen 1.8.5