text: #include "HLTriggerOffline/SUSYBSM/interface/SUSY_HLT_SingleLepton.h"
  
  #include <limits>
  #include <algorithm>
  
  #include "FWCore/MessageLogger/interface/MessageLogger.h"
  #include "FWCore/Framework/interface/Frameworkfwd.h"
  #include "FWCore/Framework/interface/MakerMacros.h"
  
  #include "FWCore/Common/interface/TriggerNames.h"
  
  #include "DataFormats/HLTReco/interface/TriggerObject.h"
  
  #include "DataFormats/Math/interface/deltaR.h"
  
  #include "DataFormats/EgammaCandidates/interface/ConversionFwd.h"
  #include "DataFormats/EgammaCandidates/interface/Conversion.h"
  #include "RecoEgamma/EgammaTools/interface/ConversionTools.h"
  
  namespace{
    bool Contains(const std::string &text,
  		const std::string &pattern){
      return text.find(pattern)!=std::string::npos;
    }
  
    void SetBinLabels(MonitorElement * const me){
      if(!me) return;
      me->setBinLabel(1, "No CSV Reqs.");
      me->setBinLabel(2, "N_{CSVL} >= 1");
      me->setBinLabel(3, "N_{CSVL} >= 2");
      me->setBinLabel(4, "N_{CSVL} >= 3");
      me->setBinLabel(5, "N_{CSVL} >= 4");
      me->setBinLabel(6, "N_{CSVM} >= 1");
      me->setBinLabel(7, "N_{CSVM} >= 2");
      me->setBinLabel(8, "N_{CSVM} >= 3");
      me->setBinLabel(9, "N_{CSVM} >= 4");
      me->setBinLabel(10, "N_{CSVT} >= 1");
      me->setBinLabel(11, "N_{CSVT} >= 2");
      me->setBinLabel(12, "N_{CSVT} >= 3");
      me->setBinLabel(13, "N_{CSVT} >= 4");
    }
  
    bool IsGood(const reco::GsfElectron &el, const reco::Vertex::Point &pv_position,
                const reco::BeamSpot::Point &bs_position,
                const edm::Handle<reco::ConversionCollection> &convs){
      const float dEtaIn = el.deltaEtaSuperClusterTrackAtVtx();
      const float dPhiIn = el.deltaPhiSuperClusterTrackAtVtx();
      const float sigmaietaieta = el.full5x5_sigmaIetaIeta();
      const float hOverE = el.hcalOverEcal();
      float d0 = 0.0, dz=0.0;
      try{
        d0=-(el.gsfTrack()->dxy(pv_position));
        dz = el.gsfTrack()->dz(pv_position);
      }catch(...){
        edm::LogError("SUSY_HLT_SingleLepton") << "Could not read electron.gsfTrack().\n";
        return false;
      }
      float ooemoop = 1e30;
      if(el.ecalEnergy()>0.0 && std::isfinite(el.ecalEnergy())){
        ooemoop = fabs(1.0/el.ecalEnergy() - el.eSuperClusterOverP()/el.ecalEnergy());
      }
      const auto &iso = el.pfIsolationVariables();
      const float absiso = iso.sumChargedHadronPt
        + std::max(0.0, iso.sumNeutralHadronEt + iso.sumPhotonEt -0.5 * iso.sumPUPt);
      const float relisowithdb = absiso/el.pt();
  
      bool pass_conversion = false;
      if(convs.isValid()){
        try{
          pass_conversion = !ConversionTools::hasMatchedConversion(el, *convs, bs_position);
        }catch(...){
          edm::LogError("SUSY_HLT_SingleLepton") << "Electron conversion matching failed.\n";
          return false;
        }
      }
  
      float etasc = 0.0;
      try{
        etasc = el.superCluster()->eta();
      }catch(...){
        edm::LogError("SUSY_HLT_SingleLepton") << "Could not read electron.superCluster().\n";
        return false;
      }
      if(fabs(etasc)>2.5){
        return false;
      }else if(fabs(etasc)>1.479){
        if(fabs(dEtaIn)>0.0106) return false;
        if(fabs(dPhiIn)>0.0359) return false;
        if(sigmaietaieta>0.0305) return false;
        if(hOverE>0.0835) return false;
        if(fabs(d0)>0.0163) return false;
        if(fabs(dz)>0.5999) return false;
        if(fabs(ooemoop)>0.1126) return false;
        if(relisowithdb>0.2075) return false;
        if(!pass_conversion) return false;
      }else{
        if(fabs(dEtaIn)>0.0091) return false;
        if(fabs(dPhiIn)>0.031) return false;
        if(sigmaietaieta>0.0106) return false;
        if(hOverE>0.0532) return false;
        if(fabs(d0)>0.0126) return false;
        if(fabs(dz)>0.0116) return false;
        if(fabs(ooemoop)>0.0609) return false;
        if(relisowithdb>0.1649) return false;
        if(!pass_conversion) return false;
      }
      return true;
    }
  
    bool IsGood(const reco::Muon &mu, const reco::Vertex::Point &pv_position){
      if(!mu.isGlobalMuon()) return false;
      if(!mu.isPFMuon()) return false;
      try{
        if(mu.globalTrack()->normalizedChi2()>=10.) return false;
        if(mu.globalTrack()->hitPattern().numberOfValidMuonHits()<=0) return false;
      }catch(...){
        edm::LogWarning("SUSY_HLT_SingleLepton") << "Could not read muon.globalTrack().\n";
        return false;
      }
      if(mu.numberOfMatchedStations()<=1) return false;
      try{
        if(fabs(mu.muonBestTrack()->dxy(pv_position))>=0.2) return false;
        if(fabs(mu.muonBestTrack()->dz(pv_position))>=0.5) return false;
      }catch(...){
        edm::LogWarning("SUSY_HLT_SingleLepton") << "Could not read muon.muonBestTrack().\n";
        return false;
      }
      try{
        if(mu.innerTrack()->hitPattern().numberOfValidPixelHits()<=0) return false;
        if(mu.innerTrack()->hitPattern().trackerLayersWithMeasurement()<=5) return false;
      }catch(...){
        edm::LogWarning("SUSY_HLT_SingleLepton") << "Could not read muon.innerTrack().\n";
        return false;
      }
      return true;
    }
  }
  
  SUSY_HLT_SingleLepton::SUSY_HLT_SingleLepton(const edm::ParameterSet &ps):
    theElectronTag_(ps.getParameter<edm::InputTag>("electronCollection")),
    theElectronCollection_(consumes<reco::GsfElectronCollection>(theElectronTag_)),
    theMuonTag_(ps.getParameter<edm::InputTag>("muonCollection")),
    theMuonCollection_(consumes<reco::MuonCollection>(theMuonTag_)),
    thePfMETTag_(ps.getParameter<edm::InputTag>("pfMetCollection")),
    thePfMETCollection_(consumes<reco::PFMETCollection>(thePfMETTag_)),
    thePfJetTag_(ps.getParameter<edm::InputTag>("pfJetCollection")),
    thePfJetCollection_(consumes<reco::PFJetCollection>(thePfJetTag_)),
    theJetTagTag_(ps.getParameter<edm::InputTag>("jetTagCollection")),
    theJetTagCollection_(consumes<reco::JetTagCollection>(theJetTagTag_)),
  
    theVertexCollectionTag_(ps.getParameter<edm::InputTag>("vertexCollection")),
    theVertexCollection_(consumes<reco::VertexCollection>(theVertexCollectionTag_)),
    theConversionCollectionTag_(ps.getParameter<edm::InputTag>("conversionCollection")),
    theConversionCollection_(consumes<reco::ConversionCollection>(theConversionCollectionTag_)),
    theBeamSpotTag_(ps.getParameter<edm::InputTag>("beamSpot")),
    theBeamSpot_(consumes<reco::BeamSpot>(theBeamSpotTag_)),
  
    theLeptonFilterTag_(ps.getParameter<edm::InputTag>("leptonFilter")),
    theHLTHTTag_(ps.getParameter<edm::InputTag>("hltHt")),
    theHLTHT_(consumes<reco::METCollection>(theHLTHTTag_)),
    theHLTMETTag_(ps.getParameter<edm::InputTag>("hltMet")),
    theHLTMET_(consumes<reco::METCollection>(theHLTMETTag_)),
    theHLTJetCollectionTag_(ps.getParameter<edm::InputTag>("hltJets")),
    theHLTJetCollection_(consumes<reco::CaloJetCollection>(theHLTJetCollectionTag_)),
    theHLTJetTagCollectionTag_(ps.getParameter<edm::InputTag>("hltJetTags")),
    theHLTJetTagCollection_(consumes<reco::JetTagCollection>(theHLTJetTagCollectionTag_)),
  
    theTriggerResultsTag_(ps.getParameter<edm::InputTag>("triggerResults")),
    theTriggerResults_(consumes<edm::TriggerResults>(theTriggerResultsTag_)),
    theTrigSummaryTag_(ps.getParameter<edm::InputTag>("trigSummary")),
    theTrigSummary_(consumes<trigger::TriggerEvent>(theTrigSummaryTag_)),
  
    fHltConfig_(),
  
    HLTProcess_(ps.getParameter<std::string>("hltProcess")),
  
    triggerPath_(ps.getParameter<std::string>("triggerPath")),
    triggerPathAuxiliary_(ps.getParameter<std::string>("triggerPathAuxiliary")),
    triggerPathLeptonAuxiliary_(ps.getParameter<std::string>("triggerPathLeptonAuxiliary")),
  
    csvlCut_(ps.getUntrackedParameter<double>("csvlCut")),
    csvmCut_(ps.getUntrackedParameter<double>("csvmCut")),
    csvtCut_(ps.getUntrackedParameter<double>("csvtCut")),
  
    jetPtCut_(ps.getUntrackedParameter<double>("jetPtCut")),
    jetEtaCut_(ps.getUntrackedParameter<double>("jetEtaCut")),
    metCut_(ps.getUntrackedParameter<double>("metCut")),
    htCut_(ps.getUntrackedParameter<double>("htCut")),
  
    lep_pt_threshold_(ps.getUntrackedParameter<double>("leptonPtThreshold")),
    ht_threshold_(ps.getUntrackedParameter<double>("htThreshold")),
    met_threshold_(ps.getUntrackedParameter<double>("metThreshold")),
    csv_threshold_(ps.getUntrackedParameter<double>("csvThreshold")),
  
    h_triggerLepPt_(nullptr),
    h_triggerLepEta_(nullptr),
    h_triggerLepPhi_(nullptr),
    h_HT_(nullptr),
    h_MET_(nullptr),
    h_maxCSV_(nullptr),
    h_leptonTurnOn_num_(nullptr),
    h_leptonTurnOn_den_(nullptr),
    h_pfHTTurnOn_num_(nullptr),
    h_pfHTTurnOn_den_(nullptr),
    h_pfMetTurnOn_num_(nullptr),
    h_pfMetTurnOn_den_(nullptr),
    h_CSVTurnOn_num_(nullptr),
    h_CSVTurnOn_den_(nullptr),
    h_btagTurnOn_num_(nullptr),
    h_btagTurnOn_den_(nullptr){
    edm::LogInfo("SUSY_HLT_SingleLepton")
      << "Constructor SUSY_HLT_SingleLepton::SUSY_HLT_SingleLepton\n";
    }
  
  SUSY_HLT_SingleLepton::~SUSY_HLT_SingleLepton(){
    edm::LogInfo("SUSY_HLT_SingleLepton")
      << "Destructor SUSY_HLT_SingleLepton::~SUSY_HLT_SingleLepton\n";
  }
  
  void SUSY_HLT_SingleLepton::dqmBeginRun(const edm::Run &run, const edm::EventSetup &e){
    bool changed;
  
    if(!fHltConfig_.init(run, e, HLTProcess_, changed)){
      edm::LogError("SUSY_HLT_SingleLepton")
        << "Initialization of HLTConfigProvider failed!!\n";
      return;
    }
  
    bool pathFound = false;
    for(const auto &trig_name: fHltConfig_.triggerNames()){
      if(Contains(trig_name, triggerPath_)) pathFound = true;
    }
  
    if(!pathFound){
      LogDebug("SUSY_HLT_SingleLepton") << "Path not found: " << triggerPath_ << '\n';
      return;
    }
  
    edm::LogInfo("SUSY_HLT_SingleLepton") << "SUSY_HLT_SingleLepton::beginRun\n";
  }
  
  void SUSY_HLT_SingleLepton::bookHistograms(DQMStore::IBooker &ibooker,
                                             const edm::Run &, const edm::EventSetup &){
    edm::LogInfo("SUSY_HLT_SingleLepton") << "SUSY_HLT_SingleLepton::bookHistograms\n";
    //book at beginRun
    ibooker.cd();
    ibooker.setCurrentFolder("HLT/SUSYBSM/" + triggerPath_);
  
    bool is_mu = false;
    bool is_ele = false;
    if(theElectronTag_.label().empty() && !theMuonTag_.label().empty()){
      is_mu=true;
    }else if(!theElectronTag_.label().empty() && theMuonTag_.label().empty()){
      is_ele=true;
    }
    std::string lepton="lepton", Lepton="Lepton";
    if(is_mu && !is_ele){
      lepton="muon";
      Lepton="Muon";
    }else if(is_ele && !is_mu){
      lepton="electron";
      Lepton="Electron";
    }
  
    //online quantities
    h_triggerLepPt_ = ibooker.book1D("triggerLepPt",
                                     (";"+Lepton+" p_{T} [GeV];").c_str(),
                                     20, 0.0, 500.0);
    h_triggerLepEta_ = ibooker.book1D("triggerLepEta",
                                      (";"+Lepton+" #eta;").c_str(),
                                      20, -3.0, 3.0);
    h_triggerLepPhi_ = ibooker.book1D("triggerLepPhi",
                                      (";"+Lepton+" #phi;").c_str(),
                                      20, -3.5, 3.5);
  
    if(!theHLTHTTag_.label().empty()){
      h_HT_ = ibooker.book1D("HT",
                             ";HLT HT [GeV];",
                             40, 0.0, 1000.0);
    }
  
    if(!theHLTMETTag_.label().empty()){
      h_MET_ = ibooker.book1D("MET",
                              ";HLT MET [GeV];",
                              40, 0.0, 1000.0);
    }
  
    if(!theHLTJetCollectionTag_.label().empty() && !theHLTJetTagCollectionTag_.label().empty()){
      h_maxCSV_ = ibooker.book1D("maxCSV",
                                 ";Max HLT CSV;",
                                 20, 0.0, 1.0);
    }
  
    //num and den hists to be divided in harvesting step to make turn on curves
    h_leptonTurnOn_num_ = ibooker.book1D("leptonTurnOn_num",
                                         ("Numerator;Offline "+lepton+" p_{T} [GeV];").c_str(),
                                         30, 0.0, 150);
    h_leptonTurnOn_den_ = ibooker.book1D("leptonTurnOn_den",
                                         ("Denominator;Offline "+lepton+" p_{T} [GeV];").c_str(),
                                         30, 0.0, 150.0);
    h_pfHTTurnOn_num_ = ibooker.book1D("pfHTTurnOn_num",
                                       "Numerator;Offline H_{T} [GeV];",
                                       30, 0.0, 1500.0 );
    h_pfHTTurnOn_den_ = ibooker.book1D("pfHTTurnOn_den",
                                       "Denominator;Offline H_{T} [GeV];",
                                       30, 0.0, 1500.0 );
  
    if(!theHLTMETTag_.label().empty()){
      h_pfMetTurnOn_num_ = ibooker.book1D("pfMetTurnOn_num",
                                          "Numerator;Offline MET [GeV];",
                                          20, 0.0, 500.0 );
      h_pfMetTurnOn_den_ = ibooker.book1D("pfMetTurnOn_den",
                                          "Denominator;Offline MET [GeV];",
                                          20, 0.0, 500.0 );
    }
  
    if(!theHLTJetCollectionTag_.label().empty() && !theHLTJetTagCollectionTag_.label().empty()){
      h_CSVTurnOn_num_ = ibooker.book1D("CSVTurnOn_num",
                                        "Numerator;Offline Max CSV Discriminant;",
                                        20, 0.0, 1.0);
      h_CSVTurnOn_den_ = ibooker.book1D("CSVTurnOn_den",
                                        "Denominator;Offline Max CSV Discriminant;",
                                        20, 0.0, 1.0);
  
      h_btagTurnOn_num_ = ibooker.book1D("btagTurnOn_num",
                                         "Numerator;Offline CSV Requirement;",
                                         13, -0.5, 12.5);
      h_btagTurnOn_den_ = ibooker.book1D("btagTurnOn_den",
                                         "Denominator;Offline CSV Requirements;",
                                         13, -0.5, 12.5);
  
      SetBinLabels(h_btagTurnOn_num_);
      SetBinLabels(h_btagTurnOn_den_);
    }
    ibooker.cd();
  }
  
  
  void SUSY_HLT_SingleLepton::analyze(const edm::Event &e, const edm::EventSetup &eSetup){
    edm::LogInfo("SUSY_HLT_SingleLepton") << "SUSY_HLT_SingleLepton::analyze\n";
  
  
    //HLT HT
    edm::Handle<reco::METCollection> HLTHT;
    if(!theHLTHTTag_.label().empty()){
      e.getByToken(theHLTHT_, HLTHT);
      if( !HLTHT.isValid() ){
        edm::LogInfo("SUSY_HLT_SingleLepton")
          << "Invalid METCollection: " << theHLTHTTag_.label() << '\n';
      }
    }
  
    //HLT MET
    edm::Handle<reco::METCollection> HLTMET;
    if(!theHLTMETTag_.label().empty()){
      e.getByToken(theHLTMET_, HLTMET);
      if( !HLTMET.isValid() ){
        edm::LogInfo("SUSY_HLT_SingleLepton")
          << "Invalid METCollection: " << theHLTMETTag_.label() << '\n';
      }
    }
  
    //HLT Jets
    edm::Handle<reco::CaloJetCollection> HLTJetCollection;
    if(!theHLTJetCollectionTag_.label().empty()){
      e.getByToken(theHLTJetCollection_, HLTJetCollection);
      if( !HLTJetCollection.isValid() ){
        edm::LogInfo("SUSY_HLT_SingleLepton")
          << "Invalid CaloJetCollection: " << theHLTJetCollectionTag_.label() << '\n';
      }
    }
  
    //HLT Jet Tags
    edm::Handle<reco::JetTagCollection> HLTJetTagCollection;
    if(!theHLTJetTagCollectionTag_.label().empty()){
      e.getByToken(theHLTJetTagCollection_, HLTJetTagCollection);
      if( !HLTJetTagCollection.isValid() ){
        edm::LogInfo("SUSY_HLT_SingleLepton")
          << "Invalid JetTagCollection: " << theHLTJetTagCollectionTag_.label() << '\n';
      }
    }
  
    //Vertex
    edm::Handle<reco::VertexCollection> VertexCollection;
    if(!theVertexCollectionTag_.label().empty()){
      e.getByToken(theVertexCollection_, VertexCollection);
      if( !VertexCollection.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid VertexCollection: " << theVertexCollectionTag_.label() << '\n';
      }
    }
  
    //Conversions
    edm::Handle<reco::ConversionCollection> ConversionCollection;
    if(!theConversionCollectionTag_.label().empty()){
      e.getByToken(theConversionCollection_, ConversionCollection);
      if( !ConversionCollection.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid ConversionCollection: " << theConversionCollectionTag_.label() << '\n';
      }
    }
  
    //Beam Spot
    edm::Handle<reco::BeamSpot> BeamSpot;
    if(!theBeamSpotTag_.label().empty()){
      e.getByToken(theBeamSpot_, BeamSpot);
      if( !BeamSpot.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid BeamSpot: " << theBeamSpotTag_.label() << '\n';
      }
    }
  
    //MET
    edm::Handle<reco::PFMETCollection> pfMETCollection;
    if(!thePfMETTag_.label().empty()){
      e.getByToken(thePfMETCollection_, pfMETCollection);
      if( !pfMETCollection.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid PFMETCollection: " << thePfMETTag_.label() << '\n';
      }
    }
  
    //Jets
    edm::Handle<reco::PFJetCollection> pfJetCollection;
    if(!thePfJetTag_.label().empty()){
      e.getByToken (thePfJetCollection_,pfJetCollection);
      if( !pfJetCollection.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid PFJetCollection: " << thePfJetTag_.label() << '\n';
      }
    }
  
    //b-tags
    edm::Handle<reco::JetTagCollection> jetTagCollection;
    if(!theJetTagTag_.label().empty()){
      e.getByToken(theJetTagCollection_, jetTagCollection);
      if( !jetTagCollection.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid JetTagCollection: " << theJetTagTag_.label() << '\n';
      }
    }
  
    //Electron
    edm::Handle<reco::GsfElectronCollection> ElectronCollection;
    if(!theElectronTag_.label().empty()){
      e.getByToken (theElectronCollection_, ElectronCollection);
      if( !ElectronCollection.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid GsfElectronCollection: " << theElectronTag_.label() << '\n';
      }
    }
  
    //Muon
    edm::Handle<reco::MuonCollection> MuonCollection;
    if(!theMuonTag_.label().empty()){
      e.getByToken (theMuonCollection_, MuonCollection);
      if( !MuonCollection.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid MuonCollection: " << theMuonTag_.label() << '\n';
      }
    }
  
    //Trigger
    edm::Handle<edm::TriggerResults> hltresults;
    if(!theTriggerResultsTag_.label().empty()){
      e.getByToken(theTriggerResults_, hltresults);
      if( !hltresults.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid TriggerResults: " << theTriggerResultsTag_.label() << '\n';
      }
    }
    edm::Handle<trigger::TriggerEvent> triggerSummary;
    if(!theTrigSummaryTag_.label().empty()){
      e.getByToken(theTrigSummary_, triggerSummary);
      if( !triggerSummary.isValid() ){
        edm::LogWarning("SUSY_HLT_SingleLepton")
          << "Invalid TriggerEvent: " << theTrigSummaryTag_.label() << '\n';
      }
    }
  
    //Get online leptons
    std::vector<float> ptLepton, etaLepton, phiLepton;
    if(triggerSummary.isValid()){
      //Leptons
      size_t filterIndex = triggerSummary->filterIndex(theLeptonFilterTag_);
      trigger::TriggerObjectCollection triggerObjects = triggerSummary->getObjects();
      if( !(filterIndex >= triggerSummary->sizeFilters()) ){
        size_t ilep = 0, num_keys = triggerSummary->filterKeys(filterIndex).size();
        ptLepton.resize(num_keys);
        etaLepton.resize(num_keys);
        phiLepton.resize(num_keys);
        for(const auto &key: triggerSummary->filterKeys(filterIndex)){
          const trigger::TriggerObject &foundObject = triggerObjects[key];
  
          if(h_triggerLepPt_) h_triggerLepPt_->Fill(foundObject.pt());
          if(h_triggerLepEta_) h_triggerLepEta_->Fill(foundObject.eta());
          if(h_triggerLepPhi_) h_triggerLepPhi_->Fill(foundObject.phi());
  
          ptLepton.at(ilep)=foundObject.pt();
          etaLepton.at(ilep)=foundObject.eta();
          phiLepton.at(ilep)=foundObject.phi();
  	++ilep;
        }
      }
    }
  
    //Get online ht and met
    const float hlt_ht = ((HLTHT.isValid() && !HLTHT->empty())?HLTHT->front().sumEt():-1.0);
    if(h_HT_) h_HT_->Fill(hlt_ht);
    const float hlt_met = ((HLTMET.isValid() && !HLTMET->empty())?HLTMET->front().pt():-1.0);
    if(h_MET_) h_MET_->Fill(hlt_met);
  
    //Get online csv and fill plot
    float hlt_csv = -1.0;
    if(HLTJetCollection.isValid() && HLTJetTagCollection.isValid()){
      for(const auto &jet: *HLTJetTagCollection){
        if(jet.second>hlt_csv) hlt_csv = jet.second;
      }
    }
    if(h_maxCSV_) h_maxCSV_->Fill(hlt_csv);
  
    //Test whether main and auxilliary triggers fired
    bool hasFired = false;
    bool hasFiredAuxiliary = false;
    bool hasFiredLeptonAuxiliary = false;
    if(hltresults.isValid()){
      const edm::TriggerNames &trigNames = e.triggerNames(*hltresults);
      for( unsigned int hltIndex = 0; hltIndex < trigNames.size(); ++hltIndex ){
        if(hltresults->wasrun(hltIndex) && hltresults->accept(hltIndex)){
          const std::string& name = trigNames.triggerName(hltIndex);
          if(Contains(name, triggerPath_)) hasFired=true;
          if(Contains(name, triggerPathAuxiliary_)) hasFiredAuxiliary=true;
  	if(Contains(name, triggerPathLeptonAuxiliary_)) hasFiredLeptonAuxiliary=true;
        }
      }
    }
  
    //Get offline HT
    double pfHT = -1.0;
    if(pfJetCollection.isValid()){
      pfHT=0.0;
      for(const auto &pfjet: *pfJetCollection){
        if(pfjet.pt() < jetPtCut_) continue;
        if(fabs(pfjet.eta()) > jetEtaCut_) continue;
        pfHT += pfjet.pt();
      }
    }
  
    //Get offline MET
    double pfMET = -1.0;
    if(pfMETCollection.isValid() && !pfMETCollection->empty()){
      pfMET = pfMETCollection->front().et();
    }
  
    //Get offline b-tagging info
    float maxCSV = -1.0;
    unsigned num_csvl = 0;
    unsigned num_csvm = 0;
    unsigned num_csvt = 0;
    if(jetTagCollection.isValid()){
      for(const auto &jet: *jetTagCollection){
        const float CSV = jet.second;
        if(jet.first->pt()>jetPtCut_){
          if(CSV>maxCSV){
            maxCSV=CSV;
          }
          if(CSV>csvlCut_){
            ++num_csvl;
            if(CSV>csvmCut_){
              ++num_csvm;
              if(CSV>csvtCut_){
                ++num_csvt;
              }
            }
          }
        }
      }
    }
    if(h_maxCSV_) h_maxCSV_->Fill(maxCSV);
  
    //Fill lepton pt efficiency plot
    double lep_max_pt = -1.0;
    if(VertexCollection.isValid() && !VertexCollection->empty()){//for quality checks
      //Try to find a reco electron
      if(ElectronCollection.isValid()
         && ConversionCollection.isValid()
         && BeamSpot.isValid()){
        for(const auto &electron: *ElectronCollection){
          if(IsGood(electron, VertexCollection->front().position(),
                    BeamSpot->position(), ConversionCollection)){
            if(electron.pt()>lep_max_pt) lep_max_pt=electron.pt();
          }
        }
      }
  
      //Try to find a reco muon
      if(MuonCollection.isValid()){
        for(const auto &muon: *MuonCollection){
          if(IsGood(muon, VertexCollection->front().position())){
            if(muon.pt()>lep_max_pt){
              lep_max_pt=muon.pt();
            }
          }
        }
      }
    }
  
    const bool lep_plateau = lep_max_pt>lep_pt_threshold_ || lep_pt_threshold_<0.0;
    const bool ht_plateau = pfHT>ht_threshold_ || ht_threshold_<0.0;
    const bool met_plateau = pfMET>met_threshold_ || met_threshold_<0.0;
    const bool csv_plateau = maxCSV>csv_threshold_ || csv_threshold_<0.0;
  
    //Fill lepton turn-on histograms
    if(hasFiredLeptonAuxiliary || triggerPathLeptonAuxiliary_.empty() || !e.isRealData()){
      //Fill histograms using highest pt reco lepton
      if(ht_plateau && met_plateau && csv_plateau
         && (pfMET>metCut_ || metCut_<0.0)
         && (pfHT>htCut_ || htCut_<0.0)){
        if(h_leptonTurnOn_den_) h_leptonTurnOn_den_->Fill(lep_max_pt);
        if(h_leptonTurnOn_num_ && hasFired) h_leptonTurnOn_num_->Fill(lep_max_pt);
      }
    }
  
    //Fill remaining turn-on histograms
    if(hasFiredAuxiliary || triggerPathAuxiliary_.empty() || !e.isRealData()){
      //Fill HT efficiency plot
      if(lep_plateau && met_plateau && csv_plateau){
        if(h_pfHTTurnOn_den_) h_pfHTTurnOn_den_->Fill(pfHT);
        if(h_pfHTTurnOn_num_ && hasFired) h_pfHTTurnOn_num_->Fill(pfHT);
      }
  
      //Fill MET efficiency plot
      if(lep_plateau && ht_plateau && csv_plateau){
        if(h_pfMetTurnOn_den_) h_pfMetTurnOn_den_->Fill(pfMET);
        if(h_pfMetTurnOn_num_ && hasFired) h_pfMetTurnOn_num_->Fill(pfMET);
      }
  
      //Fill CSV efficiency plot
      if(lep_plateau && ht_plateau && met_plateau){
        if(h_CSVTurnOn_den_) h_CSVTurnOn_den_->Fill(maxCSV);
        if(h_CSVTurnOn_num_ && hasFired) h_CSVTurnOn_num_->Fill(maxCSV);
  
        if(h_btagTurnOn_den_){
          switch(num_csvl){
          default: h_btagTurnOn_den_->Fill(4);
          case 3 : h_btagTurnOn_den_->Fill(3);
          case 2 : h_btagTurnOn_den_->Fill(2);
          case 1 : h_btagTurnOn_den_->Fill(1);
          case 0 : h_btagTurnOn_den_->Fill(0);
          }
          switch(num_csvm){
          default: h_btagTurnOn_den_->Fill(8);
          case 3 : h_btagTurnOn_den_->Fill(7);
          case 2 : h_btagTurnOn_den_->Fill(6);
          case 1 : h_btagTurnOn_den_->Fill(5);
          case 0 : break;//Don't double count in the no tag bin
          }
          switch(num_csvt){
          default: h_btagTurnOn_den_->Fill(12);
          case 3 : h_btagTurnOn_den_->Fill(11);
          case 2 : h_btagTurnOn_den_->Fill(10);
          case 1 : h_btagTurnOn_den_->Fill(9);
          case 0 : break;//Don't double count in the no tag bin
          }
        }
        if(h_btagTurnOn_num_ && hasFired){
          switch(num_csvl){
          default: h_btagTurnOn_num_->Fill(4);
          case 3 : h_btagTurnOn_num_->Fill(3);
          case 2 : h_btagTurnOn_num_->Fill(2);
          case 1 : h_btagTurnOn_num_->Fill(1);
          case 0 : h_btagTurnOn_num_->Fill(0);
          }
          switch(num_csvm){
          default: h_btagTurnOn_num_->Fill(8);
          case 3 : h_btagTurnOn_num_->Fill(7);
          case 2 : h_btagTurnOn_num_->Fill(6);
          case 1 : h_btagTurnOn_num_->Fill(5);
          case 0 : break;//Don't double count in the no tag bin
          }
          switch(num_csvt){
          default: h_btagTurnOn_num_->Fill(12);
          case 3 : h_btagTurnOn_num_->Fill(11);
          case 2 : h_btagTurnOn_num_->Fill(10);
          case 1 : h_btagTurnOn_num_->Fill(9);
          case 0 : break;//Don't double count in the no tag bin
          }
        }
      }
    }
  }
  
  
  void SUSY_HLT_SingleLepton::endRun(const edm::Run &run, const edm::EventSetup &eSetup){
    edm::LogInfo("SUSY_HLT_SingleLepton") << "SUSY_HLT_SingleLepton::endRun\n";
  }
  
  //define this as a plug-in
  DEFINE_FWK_MODULE(SUSY_HLT_SingleLepton);
  