MuonMonitor.cc

Go to the documentation of this file.

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h"
#include "DQM/TrackingMonitor/interface/GetLumi.h"
#include "DQMOffline/Trigger/plugins/MuonMonitor.h"

//Author Bhawna Gomber

// -----------------------------
//  constructors and destructor
// -----------------------------

MuonMonitor::MuonMonitor( const edm::ParameterSet& iConfig ) :
  folderName_             ( iConfig.getParameter<std::string>("FolderName") )
  , metToken_             ( consumes<reco::PFMETCollection>      (iConfig.getParameter<edm::InputTag>("met")       ) )
  , muonToken_             ( mayConsume<reco::MuonCollection>      (iConfig.getParameter<edm::InputTag>("muons")      ) )
  , vtxToken_             ( mayConsume<reco::VertexCollection>      (iConfig.getParameter<edm::InputTag>("vertices")      ) )
  , eleToken_             ( mayConsume<edm::View<reco::GsfElectron> >      (iConfig.getParameter<edm::InputTag>("electrons")      ) )
  , muon_variable_binning_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muonBinning") )
  , muoneta_variable_binning_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muonetaBinning") )
  , muon_binning_          ( getHistoPSet   (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>   ("muonPSet")    ) )
  , ls_binning_           ( getHistoPSet (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>   ("lsPSet")     ) )
  , muPt_variable_binning_2D_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muPtBinning2D") )
  , elePt_variable_binning_2D_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("elePtBinning2D") )
  , muEta_variable_binning_2D_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muEtaBinning2D") )
  , eleEta_variable_binning_2D_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("eleEtaBinning2D") )
  , num_genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"), consumesCollector(), *this))
  , den_genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"), consumesCollector(), *this))
  , metSelection_ ( iConfig.getParameter<std::string>("metSelection") )
  , muonSelection_ ( iConfig.getParameter<std::string>("muonSelection") )
  , eleSelection_ ( iConfig.getParameter<std::string>("eleSelection") )
  , nmuons_      ( iConfig.getParameter<unsigned int>("nmuons" )      )
  , nelectrons_      ( iConfig.getParameter<unsigned int>("nelectrons" )      )
{

  muonME_.numerator   = nullptr;
  muonME_.denominator = nullptr;
  muonME_variableBinning_.numerator   = nullptr;
  muonME_variableBinning_.denominator = nullptr;
  muonVsLS_.numerator   = nullptr;
  muonVsLS_.denominator = nullptr;
  muonEtaME_.numerator   = nullptr;
  muonEtaME_.denominator = nullptr;
  muonEtaME_variableBinning_.numerator   = nullptr;
  muonEtaME_variableBinning_.denominator = nullptr;
  muonPhiME_.numerator   = nullptr;
  muonPhiME_.denominator = nullptr;
  muonEtaPhiME_.numerator   = nullptr;
  muonEtaPhiME_.denominator = nullptr;
  muondxy_.denominator = nullptr;
  muondxy_.numerator = nullptr;
  muondz_.denominator = nullptr;
  muondz_.numerator = nullptr;
  eleME_variableBinning_.numerator   = nullptr;
  eleME_variableBinning_.denominator = nullptr;
  eleEtaME_.numerator   = nullptr;
  eleEtaME_.denominator = nullptr;
  elePt_muPt_.numerator = nullptr;
  elePt_muPt_.denominator = nullptr;
  eleEta_muEta_.numerator = nullptr;
  eleEta_muEta_.denominator = nullptr;

}

MuonMonitor::~MuonMonitor() = default;

MEbinning MuonMonitor::getHistoPSet(edm::ParameterSet const& pset)
{
  return MEbinning{
    pset.getParameter<unsigned>("nbins"),
    pset.getParameter<double>("xmin"),
    pset.getParameter<double>("xmax"),
  };
}

MEbinning MuonMonitor::getHistoLSPSet(edm::ParameterSet const& pset)
{
  return MEbinning{
    pset.getParameter<unsigned>("nbins"),
    0.,
    double(pset.getParameter<int32_t>("nbins"))
  };
}

void MuonMonitor::setTitle(MuonME& me, const std::string& titleX, const std::string& titleY)
{
  me.numerator->setAxisTitle(titleX, 1);
  me.numerator->setAxisTitle(titleY, 2);
  me.denominator->setAxisTitle(titleX, 1);
  me.denominator->setAxisTitle(titleY, 2);
}

void MuonMonitor::bookME(DQMStore::IBooker &ibooker, MuonME& me, const std::string& histname, const std::string& histtitle, int nbins, double min, double max)
{
  me.numerator   = ibooker.book1D(histname+"_numerator",   histtitle+" (numerator)",   nbins, min, max);
  me.denominator = ibooker.book1D(histname+"_denominator", histtitle+" (denominator)", nbins, min, max);
}

void MuonMonitor::bookME(DQMStore::IBooker &ibooker, MuonME& me, const std::string& histname, const std::string& histtitle, const std::vector<double>& binning)
{
  int nbins = binning.size()-1;
  std::vector<float> fbinning(binning.begin(), binning.end());
  float* arr = &fbinning[0];
  me.numerator   = ibooker.book1D(histname+"_numerator",   histtitle+" (numerator)",   nbins, arr);
  me.denominator = ibooker.book1D(histname+"_denominator", histtitle+" (denominator)", nbins, arr);
}

void MuonMonitor::bookME(DQMStore::IBooker &ibooker, MuonME& me, const std::string& histname, const std::string& histtitle, int nbinsX, double xmin, double xmax, double ymin, double ymax)
{
  me.numerator   = ibooker.bookProfile(histname+"_numerator",   histtitle+" (numerator)",   nbinsX, xmin, xmax, ymin, ymax);
  me.denominator = ibooker.bookProfile(histname+"_denominator", histtitle+" (denominator)", nbinsX, xmin, xmax, ymin, ymax);
}

void MuonMonitor::bookME(DQMStore::IBooker &ibooker, MuonME& me, const std::string& histname, const std::string& histtitle, int nbinsX, double xmin, double xmax, int nbinsY, double ymin, double ymax)
{
  me.numerator   = ibooker.book2D(histname+"_numerator",   histtitle+" (numerator)",   nbinsX, xmin, xmax, nbinsY, ymin, ymax);
  me.denominator = ibooker.book2D(histname+"_denominator", histtitle+" (denominator)", nbinsX, xmin, xmax, nbinsY, ymin, ymax);
}

void MuonMonitor::bookME(DQMStore::IBooker &ibooker, MuonME& me, const std::string& histname, const std::string& histtitle, const std::vector<double>& binningX, const std::vector<double>& binningY)
{
  int nbinsX = binningX.size()-1;
  std::vector<float> fbinningX(binningX.begin(), binningX.end());
  float* arrX = &fbinningX[0];
  int nbinsY = binningY.size()-1;
  std::vector<float> fbinningY(binningY.begin(), binningY.end());
  float* arrY = &fbinningY[0];

  me.numerator   = ibooker.book2D(histname+"_numerator",   histtitle+" (numerator)",   nbinsX, arrX, nbinsY, arrY);
  me.denominator = ibooker.book2D(histname+"_denominator", histtitle+" (denominator)", nbinsX, arrX, nbinsY, arrY);
}

void MuonMonitor::bookHistograms(DQMStore::IBooker     & ibooker,
                 edm::Run const        & iRun,
                 edm::EventSetup const & iSetup)
{
  std::string histname, histtitle;

  ibooker.setCurrentFolder(folderName_);

  histname = "muon_pt"; histtitle = "muon PT";
  bookME(ibooker, muonME_, histname, histtitle, muon_binning_.nbins, muon_binning_.xmin, muon_binning_.xmax);
  setTitle(muonME_,"Muon pT [GeV]","events / [GeV]");

  histname = "muon_pt_variable"; histtitle = "muon PT";
  bookME(ibooker, muonME_variableBinning_, histname, histtitle, muon_variable_binning_);
  setTitle(muonME_variableBinning_,"Muon pT [GeV]","events / [GeV]");

  histname = "muonVsLS"; histtitle = "muon pt vs LS";
  bookME(ibooker, muonVsLS_, histname, histtitle, ls_binning_.nbins, ls_binning_.xmin, ls_binning_.xmax, muon_binning_.xmin, muon_binning_.xmax);
  setTitle(muonVsLS_,"LS","Muon pT [GeV]");

  histname = "muon_phi"; histtitle = "Muon phi";
  bookME(ibooker, muonPhiME_, histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
  setTitle(muonPhiME_,"Muon #phi","events / 0.1 rad");


  histname = "muon_eta"; histtitle = "Muon eta";
  bookME(ibooker, muonEtaME_, histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
  setTitle(muonEtaME_,"Muon #eta","events");


  histname = "muon_eta_variablebinning"; histtitle = "Muon eta";
  bookME(ibooker, muonEtaME_variableBinning_, histname, histtitle, muoneta_variable_binning_);
  setTitle(muonEtaME_variableBinning_,"Muon #eta","events");

  histname = "muon_dxy"; histtitle = "Muon dxy";
  bookME(ibooker, muondxy_, histname, histtitle, dxy_binning_.nbins, dxy_binning_.xmin, dxy_binning_.xmax);
  setTitle(muondxy_,"Muon #dxy","events");

  histname = "muon_dz"; histtitle = "Muon dz";
  bookME(ibooker, muondz_, histname, histtitle, dxy_binning_.nbins, dxy_binning_.xmin, dxy_binning_.xmax);
  setTitle(muondz_,"Muon #dz","events");


  histname = "muon_etaphi"; histtitle = "Muon eta-phi";
  bookME(ibooker, muonEtaPhiME_, histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
  setTitle(muonEtaPhiME_,"#eta","#phi");

  histname = "electron_pt_variable"; histtitle = "electron PT";
  bookME(ibooker, eleME_variableBinning_, histname, histtitle, muon_variable_binning_);
  setTitle(eleME_variableBinning_,"Electron pT [GeV]","events / [GeV]");

  histname = "electron_eta"; histtitle = "electron eta";
  bookME(ibooker, eleEtaME_, histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
  setTitle(eleEtaME_,"Electron #eta","events");

  histname = "elePt_muPt"; histtitle = "electron pt vs muon pt";
  bookME(ibooker, elePt_muPt_, histname, histtitle, elePt_variable_binning_2D_, muPt_variable_binning_2D_);
  setTitle(elePt_muPt_,"electron pt [GeV]","muon pt [GeV]");

  histname = "eleEta_muEta"; histtitle = "electron #eta vs muon #eta";
  bookME(ibooker, eleEta_muEta_, histname, histtitle, eleEta_variable_binning_2D_, muEta_variable_binning_2D_);
  setTitle(eleEta_muEta_,"electron #eta","muon #eta");





  // Initialize the GenericTriggerEventFlag
  if ( num_genTriggerEventFlag_ && num_genTriggerEventFlag_->on() ) num_genTriggerEventFlag_->initRun( iRun, iSetup );
  if ( den_genTriggerEventFlag_ && den_genTriggerEventFlag_->on() ) den_genTriggerEventFlag_->initRun( iRun, iSetup );

}

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "Geometry/Records/interface/TrackerTopologyRcd.h"
void MuonMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup)  {

  // Filter out events if Trigger Filtering is requested
  if (den_genTriggerEventFlag_->on() && ! den_genTriggerEventFlag_->accept( iEvent, iSetup) ) return;

  edm::Handle<reco::PFMETCollection> metHandle;
  iEvent.getByToken( metToken_, metHandle );
  reco::PFMET pfmet = metHandle->front();
  if ( ! metSelection_( pfmet ) ) return;

  edm::Handle<reco::VertexCollection> vtxHandle;
  iEvent.getByToken(vtxToken_, vtxHandle);

  math::XYZPoint pv(0, 0, 0);
  for (reco::Vertex const & v: *vtxHandle) {
    if (not v.isFake()) {
      pv.SetXYZ(v.x(), v.y(), v.z());
      break;
    }
  }

  edm::Handle<reco::MuonCollection> muonHandle;
  iEvent.getByToken( muonToken_, muonHandle );
  std::vector<reco::Muon> muons;
  if ( muonHandle->size() < nmuons_ ) return;
  for ( auto const & p : *muonHandle ) {
    if ( muonSelection_( p ) ) muons.push_back(p);
  }
  if ( muons.size() < nmuons_ ) return;

  edm::Handle<edm::View<reco::GsfElectron> > eleHandle;
  iEvent.getByToken( eleToken_, eleHandle );
  std::vector<reco::GsfElectron> electrons;
  if ( eleHandle->size() < nelectrons_ ) return;
  for ( auto const & e : *eleHandle ) {
    if ( eleSelection_( e )) electrons.push_back(e);
  }
  if ( electrons.size() < nelectrons_ ) return;

  // filling histograms (denominator)
  int ls = iEvent.id().luminosityBlock();
  if(!muons.empty())

  {
    muonME_.denominator -> Fill(muons[0].pt());
    muonME_variableBinning_.denominator -> Fill(muons[0].pt());
    muonPhiME_.denominator->Fill(muons[0].phi());
    muonEtaME_.denominator->Fill(muons[0].eta());
    muonVsLS_.denominator -> Fill(ls, muons[0].pt());
    muonEtaPhiME_.denominator -> Fill(muons[0].eta(), muons[0].phi());
    muondxy_.denominator -> Fill(muons[0].muonBestTrack()->dxy(pv));
    muondz_.denominator -> Fill(muons[0].muonBestTrack()->dz(pv));
    if(!electrons.empty())
    {
      eleME_variableBinning_.denominator -> Fill(electrons[0].pt());
      eleEtaME_.denominator->Fill(electrons[0].eta());
      eleEta_muEta_.denominator->Fill(electrons[0].eta(), muons[0].eta());
      elePt_muPt_.denominator->Fill(electrons[0].pt(), muons[0].pt());
    }

  }

  // applying selection for numerator
  if (num_genTriggerEventFlag_->on() && ! num_genTriggerEventFlag_->accept( iEvent, iSetup) ) return;

  // filling histograms (num_genTriggerEventFlag_)
  if(!muons.empty())
  {
    muonME_.numerator -> Fill(muons[0].pt());
    muonME_variableBinning_.numerator -> Fill(muons[0].pt());
    muonPhiME_.numerator->Fill(muons[0].phi());
    muonEtaME_.numerator->Fill(muons[0].eta());
    muonVsLS_.numerator -> Fill(ls, muons[0].pt());
    muonEtaPhiME_.numerator -> Fill(muons[0].eta(), muons[0].phi());
    muondxy_.numerator -> Fill(muons[0].muonBestTrack()->dxy(pv));
    muondz_.numerator -> Fill(muons[0].muonBestTrack()->dz(pv));
    if(!electrons.empty())
    {
      eleME_variableBinning_.numerator -> Fill(electrons[0].pt());
      eleEtaME_.numerator->Fill(electrons[0].eta());
      eleEta_muEta_.numerator->Fill(electrons[0].eta(), muons[0].eta());
      elePt_muPt_.numerator->Fill(electrons[0].pt(), muons[0].pt());
    }

  }

}

void MuonMonitor::fillHistoPSetDescription(edm::ParameterSetDescription & pset)
{
  pset.add<unsigned int>   ( "nbins");
  pset.add<double>         ( "xmin" );
  pset.add<double>         ( "xmax" );
}

void MuonMonitor::fillHistoLSPSetDescription(edm::ParameterSetDescription & pset)
{
  pset.add<unsigned int>   ( "nbins", 2500 );
  pset.add<double>         ( "xmin",     0.);
  pset.add<double>         ( "xmax",  2500.);
}

void MuonMonitor::fillDescriptions(edm::ConfigurationDescriptions & descriptions)
{
  edm::ParameterSetDescription desc;
  desc.add<std::string>  ( "FolderName", "HLT/Muon" );
  desc.add<edm::InputTag>( "met",      edm::InputTag("pfMet") );
  desc.add<edm::InputTag>( "muons", edm::InputTag("muons") );
  desc.add<edm::InputTag>( "vertices", edm::InputTag("offlinePrimaryVertices") );
  desc.add<edm::InputTag>( "electrons", edm::InputTag("gedGsfElectrons") );
  desc.add<std::string>("metSelection", "pt > 0");
  desc.add<std::string>("muonSelection", "pt > 6 && eta<2.4 ");
  desc.add<std::string>("eleSelection", "pt > 0");
  //desc.add<std::string>("muonSelection", "pt > 145");
  desc.add<unsigned int>("nmuons",     0);
  desc.add<unsigned int>("nelectrons",     0);

  edm::ParameterSetDescription genericTriggerEventPSet;
  genericTriggerEventPSet.add<bool>("andOr");
  genericTriggerEventPSet.add<edm::InputTag>("dcsInputTag", edm::InputTag("scalersRawToDigi") );
  genericTriggerEventPSet.add<std::vector<int> >("dcsPartitions",{});
  genericTriggerEventPSet.add<bool>("andOrDcs", false);
  genericTriggerEventPSet.add<bool>("errorReplyDcs", true);
  genericTriggerEventPSet.add<std::string>("dbLabel","");
  genericTriggerEventPSet.add<bool>("andOrHlt", true);
  genericTriggerEventPSet.add<edm::InputTag>("hltInputTag", edm::InputTag("TriggerResults::HLT") );
  genericTriggerEventPSet.add<std::vector<std::string> >("hltPaths",{});
  genericTriggerEventPSet.add<std::string>("hltDBKey","");
  genericTriggerEventPSet.add<bool>("errorReplyHlt", false);
  genericTriggerEventPSet.add<bool>("errorReplyL1", false);
  genericTriggerEventPSet.add<unsigned int>("verbosityLevel", 1);
  genericTriggerEventPSet.add<bool>("andOrL1", false);
  genericTriggerEventPSet.add<bool>("l1BeforeMask", false);
  genericTriggerEventPSet.add<std::vector<std::string> >("l1Algorithms",{});

  desc.add<edm::ParameterSetDescription>("numGenericTriggerEventPSet", genericTriggerEventPSet);
  desc.add<edm::ParameterSetDescription>("denGenericTriggerEventPSet", genericTriggerEventPSet);

  edm::ParameterSetDescription histoPSet;
  edm::ParameterSetDescription metPSet;
  fillHistoPSetDescription(metPSet);
  histoPSet.add<edm::ParameterSetDescription>("muonPSet", metPSet);
  std::vector<double> bins = {0., 20., 40., 60., 80., 90., 100., 110., 120., 130., 140., 150., 160., 170., 180., 190., 200., 220., 240., 260., 280., 300., 350., 400., 450., 1000.};
  histoPSet.add<std::vector<double> >("muonBinning", bins);

  std::vector<double> etabins = {-3.,-2.5,-2.,-1.5,-1.,-.5, 0.,.5, 1., 1.5, 2., 2.5, 3.};
  histoPSet.add<std::vector<double> >("muonetaBinning", etabins);

  std::vector<double> bins_2D = {0., 40., 80., 100., 120., 140., 160., 180., 200., 240., 280., 350., 450., 1000.};
  std::vector<double> eta_bins_2D = {-3.,-2.,-1., 0., 1., 2., 3.};
  std::vector<double> phi_bins_2D = {-3.1415,-2.5132,-1.8849,-1.2566,-0.6283, 0, 0.6283, 1.2566, 1.8849, 2.5132, 3.1415};
  histoPSet.add<std::vector<double> >("elePtBinning2D", bins_2D);
  histoPSet.add<std::vector<double> >("muPtBinning2D", bins_2D);
  histoPSet.add<std::vector<double> >("eleEtaBinning2D", eta_bins_2D);
  histoPSet.add<std::vector<double> >("muEtaBinning2D", eta_bins_2D);

  edm::ParameterSetDescription lsPSet;
  fillHistoLSPSetDescription(lsPSet);
  histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);

  desc.add<edm::ParameterSetDescription>("histoPSet", histoPSet);

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

// Define this as a plug-in
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(MuonMonitor);