---

LepSUSYSkim.cc

Go to the documentation of this file.

#include <iostream>
#include <string>
#include <list>
#include <cmath>
#include <cstdio>
#include <vector>
#include <memory>

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "DataFormats/Common/interface/Handle.h"    

#include "SUSYBSMAnalysis/CSA07Skims/interface/LepSUSYSkim.h"
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/JetReco/interface/CaloJet.h"
#include "DataFormats/METReco/interface/CaloMETCollection.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
#include "DataFormats/METReco/interface/CaloMET.h"

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

class PtSorter {
public:
  template <class T> bool operator() ( const T& a, const T& b ) {
    return ( a.pt() > b.pt() );
  }
};

LepSUSYSkim::LepSUSYSkim( const edm::ParameterSet& iConfig ) :
  nEvents_(0), nAccepted_(0)
{
  Muonsrc_       = iConfig.getParameter<InputTag>( "Muonsrc" );
  Elecsrc_       = iConfig.getParameter<InputTag>( "Elecsrc" );
  CaloJetsrc_    = iConfig.getParameter<InputTag>( "CaloJetsrc" );
  CaloMETsrc_    = iConfig.getParameter<InputTag>( "CaloMETsrc" );
  NminMuon_      = iConfig.getParameter<int>( "NminMuon");
  MuonPtmin_     = iConfig.getParameter<double>( "MuonPtmin");
  NminElec_      = iConfig.getParameter<int>( "NminElec");
  ElecPtmin_     = iConfig.getParameter<double>( "ElecPtmin");
  NminCaloJet_   = iConfig.getParameter<int>( "NminCaloJet");
  CaloJet1Ptmin_ = iConfig.getParameter<double>( "CaloJet1Ptmin");
  CaloJet2Ptmin_ = iConfig.getParameter<double>( "CaloJet2Ptmin");
  CaloMetmin_    = iConfig.getParameter<double>( "CaloMetmin"   );
  
}

/*------------------------------------------------------------------------*/

LepSUSYSkim::~LepSUSYSkim() 
{}

/*------------------------------------------------------------------------*/

bool LepSUSYSkim::filter( edm::Event& iEvent, 
                                const edm::EventSetup& iSetup )
{
  nEvents_++;

  
  // Get the muon collection
  Handle<MuonCollection> MuonHandle;
//  try {
    iEvent.getByLabel( Muonsrc_, MuonHandle );
//  }
//  catch ( cms::Exception& ex ) {
//    edm::LogError( "LepSUSYSkim" ) 
//      << "Unable to get Muon collection "
//      << Muonsrc_.label();
//    return false;
//  }
  MuonCollection TheMuons = *MuonHandle;
  std::stable_sort( TheMuons.begin(), TheMuons.end(), PtSorter() );

  // Get the electron collection
  Handle<GsfElectronCollection> ElecHandle;
//  try {
    iEvent.getByLabel( Elecsrc_, ElecHandle );
//  }
//  catch ( cms::Exception& ex ) {
//    edm::LogError( "LepSUSYSFOSElecSkim" ) 
//      << "Unable to get Elec collection "
//      << Elecsrc_.label();
//    return false;
//  }
  GsfElectronCollection TheElecs = *ElecHandle;
  std::stable_sort( TheElecs.begin(), TheElecs.end(), PtSorter() );


  // Get the caloJet collection
  Handle<CaloJetCollection> CaloJetsHandle;
//  try {
    iEvent.getByLabel( CaloJetsrc_, CaloJetsHandle );
//  } 
//  catch ( cms::Exception& ex ) {
//    edm::LogError( "LepSUSYSkim" ) 
//      << "Unable to get CaloJet collection "
//      << CaloJetsrc_.label();
//    return false;
//  }
  CaloJetCollection TheCaloJets = *CaloJetsHandle;
  std::stable_sort( TheCaloJets.begin(), TheCaloJets.end(), PtSorter() );

  // Get the caloMetCollection
  Handle<CaloMETCollection> METHandle;
//  try {
    iEvent.getByLabel( CaloMETsrc_, METHandle );
//  }
//  catch ( cms::Exception& ex ) {
//    edm::LogError( "HadSUSYQCDSkim" )
//      << "Unable to get CaloMET collection "
//      << CaloMETsrc_.label();
//    return false;
//  }
  if ( METHandle->empty() ) return false;


//  cout << "****************************************************" << endl;

  // Apply cuts on muons
  int nMuon = 0;
  for ( MuonCollection::const_iterator it = TheMuons.begin();
        it != TheMuons.end(); it++ ) {
//    cout << "muon pt = " << it->pt() << endl;
//    cout << "muon eta = " << it->eta() << endl;
    if ( (it->pt() > MuonPtmin_) && 
         (fabs(it->eta()) < 3.0) ) {
      nMuon++;
    }
  }
//  cout << "nMuon = " << nMuon << endl;
  if ( nMuon < NminMuon_ ) return false;
   
  // Apply cuts on electrons
  int nElec = 0;
  for ( GsfElectronCollection::const_iterator it = TheElecs.begin();
        it != TheElecs.end(); it++ ) {
//    cout << "elec pt = " << it->pt() << endl;
//    cout << "elec eta = " << it->eta() << endl;
    if ( (it->pt() > ElecPtmin_) && 
         (fabs(it->eta()) < 3.0) ) {
      nElec++;
    }
  }
//  cout << "nElec = " << nElec << endl;
  if ( nElec < NminElec_ ) return false;

//  cout << "-----------------------------------------------------" << endl;
  // Apply cuts on Jets
  int nJet = 0;
  for ( CaloJetCollection::const_iterator it = TheCaloJets.begin(); 
        it != TheCaloJets.end(); it++ ) {
//    cout << "jet pt = " << it->pt() << endl;
//    cout << "jet eta = " << it->eta() << endl;
    if (fabs(it->eta()) < 3.0) nJet++;
  }
//  cout << "nJet = " << nJet << endl;
  if ( nJet < NminCaloJet_ ) return false;
//  cout << "TheCaloJets[0].pt() = " << TheCaloJets[0].pt() << endl;
//  cout << "TheCaloJets[1].pt() = " << TheCaloJets[1].pt() << endl;
  if(NminCaloJet_ > 0)  {if ( TheCaloJets[0].pt() < CaloJet1Ptmin_ ) return false;}
  if(NminCaloJet_ > 1)  {if ( TheCaloJets[1].pt() < CaloJet2Ptmin_ ) return false;}

  
//  cout << "-----------------------------------------------------" << endl;
  

  //apply cuts on MET
  double MetValue = METHandle->begin()->pt();
//  cout << " met = " << MetValue << endl;
  if(MetValue < CaloMetmin_ ) return false;
 
  nAccepted_++;

  return true;
}

/*------------------------------------------------------------------------*/

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

---