PrescalerFHN.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    HCALNoiseAlCaReco
// Class:      HCALNoiseAlCaReco
// 
//
// Original Author:  Kenneth Case Rossato
//         Created:  Wed Mar 25 13:05:10 CET 2008
//
//
// modified to PrecalerFHN by Grigory Safronov 27/03/09

// system include files
#include <memory>

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDFilter.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"

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

#include "FWCore/Utilities/interface/InputTag.h"

#include "FWCore/Common/interface/TriggerNames.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/Provenance/interface/ParameterSetID.h"

#include <string>

//
// class declaration
//

using namespace edm;

class PrescalerFHN : public edm::EDFilter {
   public:
      explicit PrescalerFHN(const edm::ParameterSet&);
      ~PrescalerFHN() override;

   private:
      void beginJob() override ;
      bool filter(edm::Event&, const edm::EventSetup&) override;
      void endJob() override ;
      // ----------member data ---------------------------

  void init(const edm::TriggerResults &,
            const edm::TriggerNames & triggerNames);

  edm::ParameterSetID triggerNamesID_;

  edm::EDGetTokenT<TriggerResults> tok_trigger;

  std::map<std::string, unsigned int> prescales;
  std::map<std::string, unsigned int> prescale_counter;

  std::map<std::string, unsigned int> trigger_indices;
};

//
// constants, enums and typedefs
//

//
// static data member definitions
//

//
// constructors and destructor
//
PrescalerFHN::PrescalerFHN(const edm::ParameterSet& iConfig)
{
  tok_trigger = consumes<TriggerResults>(iConfig.getParameter<edm::InputTag>("TriggerResultsTag"));
   //now do what ever initialization is needed
  std::vector<edm::ParameterSet> prescales_in(iConfig.getParameter<std::vector<edm::ParameterSet> >("Prescales"));

  for (std::vector<edm::ParameterSet>::const_iterator cit = prescales_in.begin();
       cit != prescales_in.end(); cit++) {

    std::string name(cit->getParameter<std::string>("HLTName"));
    unsigned int factor(cit->getParameter<unsigned int>("PrescaleFactor"));

    // does some exception get thrown if parameters aren't available? should test...

    prescales[name] = factor;
    prescale_counter[name] = 0;
  }
  
}


PrescalerFHN::~PrescalerFHN()
{
 
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)

}


//
// member functions
//

void PrescalerFHN::init(const edm::TriggerResults &result,
                        const edm::TriggerNames & triggerNames)
{
  trigger_indices.clear();

  for (std::map<std::string, unsigned int>::const_iterator cit = prescales.begin();
       cit != prescales.end(); cit++) {

    trigger_indices[cit->first] = triggerNames.triggerIndex(cit->first);
    
    if (trigger_indices[cit->first] >= result.size()) {
      // trigger path not found
      LogDebug("") << "requested HLT path does not exist: " << cit->first;
      trigger_indices.erase(cit->first);
    }
    
  }
}

// ------------ method called on each new Event  ------------
bool
PrescalerFHN::filter(edm::Event& iEvent, const edm::EventSetup& iSetup)
{
   using namespace edm;

   /* Goal for this skim:
      Prescaling MET HLT paths
      Option to turn off HSCP filter
      - Doing that by treating it as an HLT with prescale 1
   */

   // Trying to mirror HLTrigger/HLTfilters/src/HLTHighLevel.cc where possible

   Handle<TriggerResults> trh;
   iEvent.getByToken(tok_trigger, trh);

   if (trh.isValid()) {
     LogDebug("") << "TriggerResults found, number of HLT paths: " << trh->size();
   } else {
     LogDebug("") << "TriggerResults product not found - returning result=false!";
     return false;
   }

   const edm::TriggerNames & triggerNames = iEvent.triggerNames(*trh);
   if (triggerNamesID_ != triggerNames.parameterSetID()) {
     triggerNamesID_ = triggerNames.parameterSetID();
     init(*trh, triggerNames);
   }

   // Trigger indices are ready at this point
   // - Begin checking for HLT bits

   bool accept_event = false;
   for (std::map<std::string, unsigned int>::const_iterator cit = trigger_indices.begin();
    cit != trigger_indices.end(); cit++) {
     if (trh->accept(cit->second)) {
       prescale_counter[cit->first]++;
       if (prescale_counter[cit->first] >= prescales[cit->first]) {
     accept_event = true;
     prescale_counter[cit->first] = 0;
       }
     }
   }

   return accept_event;
}

// ------------ method called once each job just before starting event loop  ------------
void 
PrescalerFHN::beginJob()
{
}

// ------------ method called once each job just after ending the event loop  ------------
void 
PrescalerFHN::endJob() {
}

//define this as a plug-in
DEFINE_FWK_MODULE(PrescalerFHN);