ZtoEEEventSelector.cc

Go to the documentation of this file.

// Z->ee Filter
#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/HitPattern.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "TLorentzVector.h"
#include "RecoEgamma/ElectronIdentification/interface/CutBasedElectronID.h"
#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"

#include "FWCore/ServiceRegistry/interface/Service.h"
#include "CommonTools/UtilAlgos/interface/TFileService.h"
#include "TH1.h"
#include "DQM/TrackingMonitorSource/interface/ZtoEEEventSelector.h"

using namespace std;
using namespace edm;
  
ZtoEEEventSelector::ZtoEEEventSelector(const edm::ParameterSet& ps): 
  electronTag_(ps.getUntrackedParameter<edm::InputTag>("electronInputTag", edm::InputTag("gedGsfElectrons"))),
  bsTag_(ps.getUntrackedParameter<edm::InputTag>("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))),
  electronToken_(consumes<reco::GsfElectronCollection>(electronTag_)),
  bsToken_(consumes<reco::BeamSpot>(bsTag_)),
  maxEta_(ps.getUntrackedParameter<double>("maxEta", 2.4)),
  minPt_(ps.getUntrackedParameter<double>("minPt", 5)),
  maxDeltaPhiInEB_(ps.getUntrackedParameter<double>("maxDeltaPhiInEB", .15)),
  maxDeltaEtaInEB_(ps.getUntrackedParameter<double>("maxDeltaEtaInEB", .007)),
  maxHOEEB_(ps.getUntrackedParameter<double>("maxHOEEB", .12)),
  maxSigmaiEiEEB_(ps.getUntrackedParameter<double>("maxSigmaiEiEEB", .01)),
  maxDeltaPhiInEE_(ps.getUntrackedParameter<double>("maxDeltaPhiInEE", .1)),
  maxDeltaEtaInEE_(ps.getUntrackedParameter<double>("maxDeltaEtaInEE", .009)),
  maxHOEEE_(ps.getUntrackedParameter<double>("maxHOEEB_", .10)),
  maxSigmaiEiEEE_(ps.getUntrackedParameter<double>("maxSigmaiEiEEE", .03)),
  maxNormChi2_(ps.getUntrackedParameter<double>("maxNormChi2", 10)),
  maxD0_(ps.getUntrackedParameter<double>("maxD0", 0.02)),
  maxDz_(ps.getUntrackedParameter<double>("maxDz", 20.)),
  minPixelHits_(ps.getUntrackedParameter<uint32_t>("minPixelHits", 1)),
  minStripHits_(ps.getUntrackedParameter<uint32_t>("minStripHits", 8)),
  maxIso_(ps.getUntrackedParameter<double>("maxIso", 0.3)),
  minPtHighest_(ps.getUntrackedParameter<double>("minPtHighest", 24)),
  minInvMass_(ps.getUntrackedParameter<double>("minInvMass", 60)),
  maxInvMass_(ps.getUntrackedParameter<double>("maxInvMass", 120))
{
}

bool ZtoEEEventSelector::filter(edm::Event& iEvent, edm::EventSetup const& iSetup) {
  // Read Electron Collection
  edm::Handle<reco::GsfElectronCollection> electronColl;
  iEvent.getByToken(electronToken_, electronColl);
  
  edm::Handle<reco::BeamSpot> beamSpot;
  iEvent.getByToken(bsToken_, beamSpot);

  std::vector<TLorentzVector> list; 
  std::vector<int> chrgeList; 

  if (electronColl.isValid()) {
    for (auto const& ele: *electronColl) {
      if (!ele.ecalDriven()) continue;
      if (ele.pt() < minPt_) continue;
      // set a max Eta cut
      if (!(ele.isEB() || ele.isEE())) continue;
      
      double hOverE = ele.hadronicOverEm();
      double sigmaee = ele.sigmaIetaIeta();
      double deltaPhiIn = ele.deltaPhiSuperClusterTrackAtVtx();
      double deltaEtaIn = ele.deltaEtaSuperClusterTrackAtVtx();
      
      // separate cut for barrel and endcap
      if (ele.isEB()) {
    if (fabs(deltaPhiIn) >= maxDeltaPhiInEB_
        && fabs(deltaEtaIn) >= maxDeltaEtaInEB_
        && hOverE >= maxHOEEB_
        && sigmaee >= maxSigmaiEiEEB_) continue;
      }
      else if (ele.isEE()) {
    if (fabs(deltaPhiIn) >= maxDeltaPhiInEE_
        && fabs(deltaEtaIn) >= maxDeltaEtaInEE_
        && hOverE >= maxHOEEE_
        && sigmaee >= maxSigmaiEiEEE_) continue;
      }
      
      reco::GsfTrackRef trk = ele.gsfTrack();
      if (!trk.isNonnull() ) continue; // only electrons with tracks
      double chi2 = trk->chi2();
      double ndof = trk->ndof();
      double chbyndof = (ndof > 0) ? chi2/ndof : 0;
      if (chbyndof >= maxNormChi2_) continue;
      
      double trkd0 = trk->d0();
      if (beamSpot.isValid()) {
    trkd0 = -(trk->dxy(beamSpot->position()));
      }
      else { 
    edm::LogError("ZtoEEEventSelector") << "Error >> Failed to get BeamSpot for label: " 
                        << bsTag_;
      }
      if (std::fabs(trkd0) >= maxD0_) continue;
      
      const reco::HitPattern& hitp = trk->hitPattern(); 
      int nPixelHits = hitp.numberOfValidPixelHits();
      if (nPixelHits < minPixelHits_) continue;
      
      int nStripHits = hitp.numberOfValidStripHits();
      if (nStripHits < minStripHits_) continue;
      
      // PF Isolation
      reco::GsfElectron::PflowIsolationVariables pfIso = ele.pfIsolationVariables();
      float absiso = pfIso.sumChargedHadronPt + std::max(0.0, pfIso.sumNeutralHadronEt + pfIso.sumPhotonEt - 0.5 * pfIso.sumPUPt);
      float eiso = absiso/(ele.pt());
      if (eiso > maxIso_) continue;
      
      TLorentzVector lv;
      lv.SetPtEtaPhiE(ele.pt(), ele.eta(), ele.phi(), ele.energy());
      list.push_back(lv);
      chrgeList.push_back(ele.charge());
    }
  }
  else {
    edm::LogError("ZtoEEEventSelector") << "Error >> Failed to get ElectronCollection for label: " 
                    << electronTag_;
  }
    if (list.size() < 2) return false;
  if (chrgeList[0] + chrgeList[1] != 0) return false;

  if (list[0].Pt() < minPtHighest_) return false;  
  TLorentzVector zv = list[0] + list[1];
  if (zv.M() < minInvMass_ || zv.M() > maxInvMass_) return false;
  
  return true;
}
// Define this as a plug-in
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(ZtoEEEventSelector);