HiggsToWW2LeptonsSkim.cc

Go to the documentation of this file.

#include "HiggsAnalysis/Skimming/interface/HiggsToWW2LeptonsSkim.h"

#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"

// Muons:
#include <DataFormats/TrackReco/interface/Track.h>

// Electrons
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"

#include "DataFormats/Candidate/interface/Candidate.h"


#include <iostream>

#include "FWCore/MessageLogger/interface/MessageLogger.h"

using namespace edm;
using namespace std;
using namespace reco;

HiggsToWW2LeptonsSkim::HiggsToWW2LeptonsSkim(const edm::ParameterSet& iConfig) :
  nEvents_(0), nAccepted_(0)
{

  // Reconstructed objects
  theGLBMuonToken   = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("GlobalMuonCollectionLabel"));
  theGsfEToken      = consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("ElectronCollectionLabel"));

  singleTrackPtMin_ = iConfig.getParameter<double>("SingleTrackPtMin");
  diTrackPtMin_     = iConfig.getParameter<double>("DiTrackPtMin");
  etaMin_           = iConfig.getParameter<double>("etaMin");
  etaMax_           = iConfig.getParameter<double>("etaMax");
}


HiggsToWW2LeptonsSkim::~HiggsToWW2LeptonsSkim()
{
}

void HiggsToWW2LeptonsSkim::endJob()
{
  edm::LogVerbatim("HiggsToWW2LeptonsSkim")
        << "Events read " << nEvents_
            << " Events accepted " << nAccepted_
            << "\nEfficiency " << ((double)nAccepted_)/((double)nEvents_)
        << std::endl;
}


bool HiggsToWW2LeptonsSkim::filter(edm::Event& event, const edm::EventSetup& iSetup)
{

  nEvents_++;
  bool accepted = false;
  bool accepted1 = false;
  int nTrackOver2ndCut = 0;


  // Handle<CandidateCollection> tracks;

  using reco::TrackCollection;

  // Get the muon track collection from the event
  edm::Handle<reco::TrackCollection> muTracks;
  event.getByToken(theGLBMuonToken, muTracks);

  if ( muTracks.isValid() ) {

    reco::TrackCollection::const_iterator muons;

    // Loop over muon collections and count how many muons there are,
    // and how many are above threshold
    for ( muons = muTracks->begin(); muons != muTracks->end(); ++muons ) {
      if ( muons->eta() > etaMin_ && muons->eta() < etaMax_ ) {
        if ( muons->pt() > singleTrackPtMin_ ) accepted1 = true;
        if ( muons->pt() > diTrackPtMin_ ) nTrackOver2ndCut++;
      }
    }
  }

  // Now look at electrons:

  // Get the electron track collection from the event
  edm::Handle<reco::GsfElectronCollection> pTracks;

  event.getByToken(theGsfEToken,pTracks);

  if ( pTracks.isValid() ) {

    const reco::GsfElectronCollection* eTracks = pTracks.product();

    reco::GsfElectronCollection::const_iterator electrons;

    // Loop over electron collections and count how many muons there are,
    // and how many are above threshold
    for ( electrons = eTracks->begin(); electrons != eTracks->end(); ++electrons ) {
      if ( electrons->eta() > etaMin_ && electrons->eta() < etaMax_ ) {
        if ( electrons->pt() > singleTrackPtMin_ ) accepted1 = true;
        if ( electrons->pt() > diTrackPtMin_ ) nTrackOver2ndCut++;
      }
    }
  }


  if ( accepted1 && nTrackOver2ndCut >= 2 ) accepted = true;

  if ( accepted ) nAccepted_++;

  return accepted;

}