HLTDQMMuonSelector.cc

Go to the documentation of this file.

#include "FWCore/Utilities/interface/EDGetToken.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "CommonTools/Utils/interface/StringCutObjectSelector.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/MuonReco/interface/MuonSelectors.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"


class HLTDQMMuonSelector : public edm::stream::EDProducer<> {
public:
  explicit HLTDQMMuonSelector(const edm::ParameterSet& config);
  void produce(edm::Event&, edm::EventSetup const&)override;
  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
private:

  enum class MuonSelectionType {
    Tight,Medium,Loose,Soft,HighPt,None
  };
  
  static MuonSelectionType convertToEnum(const std::string& val);
  bool passMuonSel(const reco::Muon& muon,const reco::Vertex& vertex)const;
  

  edm::EDGetTokenT<reco::MuonCollection> muonToken_;
  edm::EDGetTokenT<reco::VertexCollection> vtxToken_;
  StringCutObjectSelector<reco::Muon,true> selection_;
  
  MuonSelectionType muonSelType_;
  
  
};


HLTDQMMuonSelector::HLTDQMMuonSelector(const edm::ParameterSet& config):
  muonToken_(consumes<reco::MuonCollection>(config.getParameter<edm::InputTag>("objs"))),
  vtxToken_(consumes<reco::VertexCollection>(config.getParameter<edm::InputTag>("vertices"))),
  selection_(config.getParameter<std::string>("selection")),
  muonSelType_(convertToEnum(config.getParameter<std::string>("muonSelectionType")))
{ 
  produces<edm::ValueMap<bool> >(); 
}

void HLTDQMMuonSelector::fillDescriptions(edm::ConfigurationDescriptions& descriptions)
{
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("objs", edm::InputTag("muons"));
  desc.add<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
  desc.add<std::string>("selection","et > 5");
  desc.add<std::string>("muonSelectionType","tight");
  descriptions.add("hltDQMMuonSelector", desc);
}


void HLTDQMMuonSelector::produce(edm::Event& event,const edm::EventSetup& setup)
{
  edm::Handle<reco::MuonCollection> muonHandle;
  event.getByToken(muonToken_,muonHandle);
  
  edm::Handle<reco::VertexCollection> vtxHandle;
  event.getByToken(vtxToken_,vtxHandle);
  
  if(!muonHandle.isValid()) return;
  
  std::vector<bool> selResults;
  for(auto& muon : *muonHandle){
    if(vtxHandle.isValid() && !vtxHandle->empty()){
      selResults.push_back(passMuonSel(muon,vtxHandle->front()) && selection_(muon));
    }else{
      selResults.push_back(false);
    }
  }
  auto valMap = std::make_unique<edm::ValueMap<bool> >();
  edm::ValueMap<bool>::Filler filler(*valMap);
  filler.insert(muonHandle, selResults.begin(), selResults.end());
  filler.fill();
  event.put(std::move(valMap));
}
           
HLTDQMMuonSelector::MuonSelectionType HLTDQMMuonSelector::convertToEnum(const std::string& val)
{
  const std::vector<std::pair<std::string,MuonSelectionType> > strsToEnums = {
    {"tight",MuonSelectionType::Tight},
    {"medium",MuonSelectionType::Medium},
    {"loose",MuonSelectionType::Loose},
    {"soft",MuonSelectionType::Soft},
    {"highpt",MuonSelectionType::HighPt},
    {"none",MuonSelectionType::None}
  };
  for(const auto& strEnumPair : strsToEnums){
    if(val==strEnumPair.first) return strEnumPair.second;
  }
  std::ostringstream validEnums;
  for(const auto& strEnumPair : strsToEnums) validEnums <<strEnumPair.first<<" ";
  throw cms::Exception("InvalidConfig") << "invalid muonSelectionType "<<val<<", allowed values are "<<validEnums.str();
}

bool HLTDQMMuonSelector::passMuonSel(const reco::Muon& muon,const reco::Vertex& vertex)const
{
  switch(muonSelType_){
  case MuonSelectionType::Tight:
    return muon::isTightMuon(muon,vertex);
  case MuonSelectionType::Medium:
    return muon::isMediumMuon(muon);
  case MuonSelectionType::Loose:
    return muon::isLooseMuon(muon);
  case MuonSelectionType::Soft:
    return muon::isSoftMuon(muon,vertex);
  case MuonSelectionType::HighPt:
    return muon::isHighPtMuon(muon,vertex);
  case MuonSelectionType::None:
    return true;
  default:
    edm::LogError("HLTDQMMuonSelector")<<" inconsistent code, an option has been added to MuonSelectionType without updating HLTDQMMuonSelector::passMuonSel";
    return false;
  }

}
  
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(HLTDQMMuonSelector);