HLTMuonL1TRegionalFilter.cc

Go to the documentation of this file.

#include "HLTMuonL1TRegionalFilter.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/HLTReco/interface/TriggerFilterObjectWithRefs.h"
#include "DataFormats/HLTReco/interface/TriggerRefsCollections.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"

HLTMuonL1TRegionalFilter::HLTMuonL1TRegionalFilter(const edm::ParameterSet& iConfig): HLTFilter(iConfig),
  candTag_  (iConfig.getParameter<edm::InputTag>("CandTag") ),
  candToken_(consumes<l1t::MuonBxCollection>(candTag_)),
  previousCandTag_  (iConfig.getParameter<edm::InputTag>("PreviousCandTag") ),
  previousCandToken_(consumes<trigger::TriggerFilterObjectWithRefs>(previousCandTag_)),
  minN_( iConfig.getParameter<int>("MinN") ),
  centralBxOnly_( iConfig.getParameter<bool>("CentralBxOnly") )
{
  using namespace std;
  using namespace edm;

  // read in the eta-range dependent parameters
  const vector<ParameterSet> cuts = iConfig.getParameter<vector<ParameterSet> >("Cuts");
  size_t ranges = cuts.size();
  if(ranges==0){
    throw edm::Exception(errors::Configuration) << "Please provide at least one PSet in the Cuts VPSet!";
  }
  etaBoundaries_.reserve(ranges+1);
  minPts_.reserve(ranges);
  qualityBitMasks_.reserve(ranges);
  for(size_t i=0; i<ranges; i++){
    //set the eta range
    vector<double> etaRange = cuts[i].getParameter<vector<double> >("EtaRange");
    if(etaRange.size() != 2 || etaRange[0] >= etaRange[1]){
      throw edm::Exception(errors::Configuration) << "EtaRange must have two non-equal values in increasing order!";
    }
    if(i==0){
      etaBoundaries_.push_back( etaRange[0] );
    }else if(etaBoundaries_[i] != etaRange[0]){
      throw edm::Exception(errors::Configuration) << "EtaRanges must be disjoint without gaps and listed in increasing eta order!";
    }
    etaBoundaries_.push_back( etaRange[1] );

    //set the minPt
    minPts_.push_back( cuts[i].getParameter<double>("MinPt") );

    //set the quality bit masks
    qualityBitMasks_.push_back( 0 );
    vector<unsigned int> qualities = cuts[i].getParameter<vector<unsigned int> >("QualityBits");
    for(unsigned int qualitie : qualities){
//       if(7U < qualities[j]){ // qualities[j] >= 0, since qualities[j] is unsigned   //FIXME: this will be updated once we have info from L1
//         throw edm::Exception(errors::Configuration) << "QualityBits must be between 0 and 7 !";
//       }
      qualityBitMasks_[i] |= 1 << qualitie;
    }
  }

  // dump parameters for debugging
  if(edm::isDebugEnabled()){
    ostringstream ss;
    ss<<"Constructed with parameters:"<<endl;
    ss<<"    CandTag = "<<candTag_.encode()<<endl;
    ss<<"    PreviousCandTag = "<<previousCandTag_.encode()<<endl;
    ss<<"    EtaBoundaries = \t"<<etaBoundaries_[0];
    for(size_t i=1; i<etaBoundaries_.size(); i++){
      ss<<'\t'<<etaBoundaries_[i];
    }
    ss<<endl;
    ss<<"    MinPts =        \t    "<<minPts_[0];
    for(size_t i=1; i<minPts_.size(); i++){
      ss<<"\t    "<<minPts_[i];
    }
    ss<<endl;
    ss<<"    QualityBitMasks =  \t    "<<qualityBitMasks_[0];
    for(size_t i=1; i<qualityBitMasks_.size(); i++){
      ss<<"\t    "<<qualityBitMasks_[i];
    }
    ss<<endl;
    ss<<"    MinN = "<<minN_<<endl;
    ss<<"    saveTags= "<<saveTags();
    LogDebug("HLTMuonL1TRegionalFilter")<<ss.str();
  }
}

HLTMuonL1TRegionalFilter::~HLTMuonL1TRegionalFilter()= default;

void
HLTMuonL1TRegionalFilter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  makeHLTFilterDescription(desc);
  desc.add<edm::InputTag>("CandTag",edm::InputTag("hltGmtStage2Digis"));
  desc.add<edm::InputTag>("PreviousCandTag",edm::InputTag("hltL1sL1SingleMu20"));
  desc.add<int>("MinN",1);
  desc.add<bool>("CentralBxOnly", true);

  edm::ParameterSetDescription validator;
  std::vector<edm::ParameterSet> defaults(3);

  std::vector<double> etaRange;
  double minPt;
  std::vector<unsigned int> qualityBits;

  etaRange.clear();
  etaRange.push_back(-2.5);
  etaRange.push_back(+2.5);
  minPt=20.0;
  qualityBits.clear();
  qualityBits.push_back(6);
  qualityBits.push_back(7);
  validator.add<std::vector<double> >("EtaRange",etaRange);
  validator.add<double>("MinPt",minPt);
  validator.add<std::vector<unsigned int> >("QualityBits",qualityBits);


  etaRange.clear();
  etaRange.push_back(-2.5);
  etaRange.push_back(-1.6);
  minPt=20.0;
  qualityBits.clear();
  qualityBits.push_back(6);
  qualityBits.push_back(7);
  defaults[0].addParameter<std::vector<double> >("EtaRange",etaRange);
  defaults[0].addParameter<double>("MinPt",minPt);
  defaults[0].addParameter<std::vector<unsigned int> >("QualityBits",qualityBits);


  etaRange.clear();
  etaRange.push_back(-1.6);
  etaRange.push_back(+1.6);
  minPt=20.0;
  qualityBits.clear();
  qualityBits.push_back(7);
  defaults[1].addParameter<std::vector<double> >("EtaRange",etaRange);
  defaults[1].addParameter<double>("MinPt",minPt);
  defaults[1].addParameter<std::vector<unsigned int> >("QualityBits",qualityBits);


  etaRange.clear();
  etaRange.push_back(+1.6);
  etaRange.push_back(+2.5);
  minPt=20.0;
  qualityBits.clear();
  qualityBits.push_back(6);
  qualityBits.push_back(7);
  edm::ParameterSetDescription element2;
  defaults[2].addParameter<std::vector<double> >("EtaRange",etaRange);
  defaults[2].addParameter<double>("MinPt",minPt);
  defaults[2].addParameter<std::vector<unsigned int> >("QualityBits",qualityBits);

  desc.addVPSet("Cuts",validator,defaults);

  descriptions.add("hltMuonL1TRegionalFilter", desc);
}

bool HLTMuonL1TRegionalFilter::hltFilter(edm::Event& iEvent, const edm::EventSetup& iSetup, trigger::TriggerFilterObjectWithRefs & filterproduct) const {
  using namespace std;
  using namespace edm;
  using namespace trigger;
  using namespace l1t;

  // All HLT filters must create and fill an HLT filter object,
  // recording any reconstructed physics objects satisfying (or not)
  // this HLT filter, and place it in the Event.

  // get hold of all muons
  Handle<l1t::MuonBxCollection> allMuons;
  iEvent.getByToken(candToken_, allMuons);

  // get hold of muons that fired the previous level
  Handle<TriggerFilterObjectWithRefs> previousLevelCands;
  iEvent.getByToken(previousCandToken_, previousLevelCands);

  vector<MuonRef> prevMuons;
  previousLevelCands->getObjects(TriggerL1Mu, prevMuons);

  // look at all mucands,  check cuts and add to filter object
  int n = 0;


  for (int ibx = allMuons->getFirstBX(); ibx <= allMuons->getLastBX(); ++ibx) {
    if (centralBxOnly_ && (ibx != 0)) continue;
    for (auto it = allMuons->begin(ibx); it != allMuons->end(ibx); it++){

      MuonRef muon(allMuons, distance(allMuons->begin(allMuons->getFirstBX()),it) );

      // Only select muons that were selected in the previous level 
      if(find(prevMuons.begin(), prevMuons.end(), muon) == prevMuons.end()) continue;

      //check maxEta cut
      float eta   =  muon->eta();
      int region = -1;
      for(size_t r=0; r<etaBoundaries_.size()-1; r++){
        if(etaBoundaries_[r]<=eta && eta<=etaBoundaries_[r+1]){
          region = r;
          break;
        }
      }
      if(region == -1) continue;

      //check pT cut
      if(muon->pt() < minPts_[region]) continue;

      //check quality cut
      if(qualityBitMasks_[region]){
        int quality = (it->hwQual() == 0 ? 0 : (1 << it->hwQual()));
        if((quality & qualityBitMasks_[region]) == 0) continue;
      }

      //we have a good candidate
      n++;
      filterproduct.addObject(TriggerL1Mu,muon);
    }
  }


  if (saveTags()) filterproduct.addCollectionTag(candTag_);

  // filter decision
  const bool accept (n >= minN_);

  // dump event for debugging
  if(edm::isDebugEnabled()){

    LogTrace("HLTMuonL1TRegionalFilter")<< "\nHLTMuonL1TRegionalFilter -----------------------------------------------" << endl;
    LogTrace("HLTMuonL1TRegionalFilter")<< "L1mu#"   << '\t'
                                << "q*pt"    << '\t' << '\t'
                                << "eta"     << '\t' << "phi" << '\t'
                                << "quality" << '\t' << "isPrev\t " << endl;
    LogTrace("HLTMuonL1TRegionalFilter")<< "--------------------------------------------------------------------------" << endl;

    vector<MuonRef> firedMuons;
    filterproduct.getObjects(TriggerL1Mu, firedMuons);
    for(size_t i=0; i<firedMuons.size(); i++){
      l1t::MuonRef mu = firedMuons[i]; 
      bool isPrev = find(prevMuons.begin(), prevMuons.end(), mu) != prevMuons.end();
      LogTrace("HLTMuonL1TRegionalFilter")<< i                       << '\t' << setprecision(2) << scientific 
                                  << mu->charge()* mu->pt()  << '\t' << fixed 
                                  << mu->eta()               << '\t' << mu->phi() << '\t' 
                                  << mu->hwQual()            << '\t' << isPrev    << endl;
    }
    LogTrace("HLTMuonL1TRegionalFilter")<< "--------------------------------------------------------------------------" << endl;
    LogTrace("HLTMuonL1TRegionalFilter")<< "Decision of this filter is " << accept << ", number of muons passing = " << filterproduct.l1tmuonSize();

  }

  return accept;
}


// declare this class as a framework plugin
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(HLTMuonL1TRegionalFilter);