DiDispStaMuonMonitor.cc

Go to the documentation of this file.

#include "DQMOffline/Trigger/plugins/DiDispStaMuonMonitor.h"

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

DiDispStaMuonMonitor::DiDispStaMuonMonitor(const edm::ParameterSet& iConfig)
    : folderName_(iConfig.getParameter<std::string>("FolderName")),
      muonToken_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("muons"))),
      muonPt_variable_binning_(
          iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double>>("muonPtBinning")),
      muonPt_binning_(getHistoPSet(
          iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonPtPSet"))),
      muonEta_binning_(getHistoPSet(
          iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonEtaPSet"))),
      muonPhi_binning_(getHistoPSet(
          iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonPhiPSet"))),
      muonDxy_binning_(getHistoPSet(
          iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonDxyPSet"))),
      ls_binning_(
          getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("lsPSet"))),
      num_genTriggerEventFlag_(new GenericTriggerEventFlag(
          iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"), consumesCollector(), *this)),
      den_genTriggerEventFlag_(new GenericTriggerEventFlag(
          iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"), consumesCollector(), *this)),
      muonSelectionGeneral_(
          iConfig.getParameter<edm::ParameterSet>("muonSelection").getParameter<std::string>("general")),
      muonSelectionPt_(iConfig.getParameter<edm::ParameterSet>("muonSelection").getParameter<std::string>("pt")),
      muonSelectionDxy_(iConfig.getParameter<edm::ParameterSet>("muonSelection").getParameter<std::string>("dxy")),
      nmuons_(iConfig.getParameter<unsigned int>("nmuons")) {
  muonPtME_.numerator = nullptr;
  muonPtME_.denominator = nullptr;
  muonPtNoDxyCutME_.numerator = nullptr;
  muonPtNoDxyCutME_.denominator = nullptr;
  muonPtME_variableBinning_.numerator = nullptr;
  muonPtME_variableBinning_.denominator = nullptr;
  muonPtVsLS_.numerator = nullptr;
  muonPtVsLS_.denominator = nullptr;
  muonEtaME_.numerator = nullptr;
  muonEtaME_.denominator = nullptr;
  muonPhiME_.numerator = nullptr;
  muonPhiME_.denominator = nullptr;
  muonDxyME_.numerator = nullptr;
  muonDxyME_.denominator = nullptr;

  subMuonPtME_.numerator = nullptr;
  subMuonPtME_.denominator = nullptr;
  subMuonPtME_variableBinning_.numerator = nullptr;
  subMuonPtME_variableBinning_.denominator = nullptr;
  subMuonEtaME_.numerator = nullptr;
  subMuonEtaME_.denominator = nullptr;
  subMuonPhiME_.numerator = nullptr;
  subMuonPhiME_.denominator = nullptr;
  subMuonDxyME_.numerator = nullptr;
  subMuonDxyME_.denominator = nullptr;
}

DiDispStaMuonMonitor::~DiDispStaMuonMonitor() = default;

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

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

void DiDispStaMuonMonitor::setTitle(DiDispStaMuonME& me,
                                    const std::string& titleX,
                                    const std::string& titleY,
                                    bool bookDen) {
  me.numerator->setAxisTitle(titleX, 1);
  me.numerator->setAxisTitle(titleY, 2);
  if (bookDen) {
    me.denominator->setAxisTitle(titleX, 1);
    me.denominator->setAxisTitle(titleY, 2);
  }
}

void DiDispStaMuonMonitor::bookME(DQMStore::IBooker& ibooker,
                                  DiDispStaMuonME& 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 DiDispStaMuonMonitor::bookME(DQMStore::IBooker& ibooker,
                                  DiDispStaMuonME& 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 DiDispStaMuonMonitor::bookME(DQMStore::IBooker& ibooker,
                                  DiDispStaMuonME& me,
                                  const std::string& histname,
                                  const std::string& histtitle,
                                  int nbinsX,
                                  double xmin,
                                  double xmax,
                                  double ymin,
                                  double ymax,
                                  bool bookDen) {
  me.numerator =
      ibooker.bookProfile(histname + "_numerator", histtitle + " (numerator)", nbinsX, xmin, xmax, ymin, ymax);
  if (bookDen)
    me.denominator =
        ibooker.bookProfile(histname + "_denominator", histtitle + " (denominator)", nbinsX, xmin, xmax, ymin, ymax);
}
void DiDispStaMuonMonitor::bookME(DQMStore::IBooker& ibooker,
                                  DiDispStaMuonME& 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 DiDispStaMuonMonitor::bookME(DQMStore::IBooker& ibooker,
                                  DiDispStaMuonME& 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 DiDispStaMuonMonitor::bookHistograms(DQMStore::IBooker& ibooker,
                                          edm::Run const& iRun,
                                          edm::EventSetup const& iSetup) {
  std::string histname, histtitle;
  bool bookDen;

  std::string currentFolder = folderName_;
  ibooker.setCurrentFolder(currentFolder);

  histname = "muonPt";
  histtitle = "muonPt";
  bookDen = true;
  bookME(ibooker, muonPtME_, histname, histtitle, muonPt_binning_.nbins, muonPt_binning_.xmin, muonPt_binning_.xmax);
  setTitle(muonPtME_, "DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]", bookDen);

  histname = "muonPtNoDxyCut";
  histtitle = "muonPtNoDxyCut";
  bookDen = true;
  bookME(ibooker,
         muonPtNoDxyCutME_,
         histname,
         histtitle,
         muonPt_binning_.nbins,
         muonPt_binning_.xmin,
         muonPt_binning_.xmax);
  setTitle(muonPtNoDxyCutME_, "DisplacedStandAlone Muon p_{T} [GeV] without Dxy cut", "Events / [GeV]", bookDen);

  histname = "muonPt_variable";
  histtitle = "muonPt";
  bookDen = true;
  bookME(ibooker, muonPtME_variableBinning_, histname, histtitle, muonPt_variable_binning_);
  setTitle(muonPtME_variableBinning_, "DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]", bookDen);

  histname = "muonPtVsLS";
  histtitle = "muonPt vs LS";
  bookDen = true;
  bookME(ibooker,
         muonPtVsLS_,
         histname,
         histtitle,
         ls_binning_.nbins,
         ls_binning_.xmin,
         ls_binning_.xmax,
         muonPt_binning_.xmin,
         muonPt_binning_.xmax,
         bookDen);
  setTitle(muonPtVsLS_, "LS", "DisplacedStandAlone Muon p_{T} [GeV]", bookDen);

  histname = "muonEta";
  histtitle = "muonEta";
  bookDen = true;
  bookME(
      ibooker, muonEtaME_, histname, histtitle, muonEta_binning_.nbins, muonEta_binning_.xmin, muonEta_binning_.xmax);
  setTitle(muonEtaME_, "DisplacedStandAlone Muon #eta", "Events", bookDen);

  histname = "muonPhi";
  histtitle = "muonPhi";
  bookDen = true;
  bookME(
      ibooker, muonPhiME_, histname, histtitle, muonPhi_binning_.nbins, muonPhi_binning_.xmin, muonPhi_binning_.xmax);
  setTitle(muonPhiME_, "DisplacedStandAlone Muon #phi", "Events", bookDen);

  histname = "muonDxy";
  histtitle = "muonDxy";
  bookDen = true;
  bookME(
      ibooker, muonDxyME_, histname, histtitle, muonDxy_binning_.nbins, muonDxy_binning_.xmin, muonDxy_binning_.xmax);
  setTitle(muonDxyME_, "DisplacedStandAlone Muon #dxy", "Events", bookDen);

  //-----------------------
  //                      |
  //-----------------------

  if (nmuons_ > 1) {
    histname = "subMuonPt";
    histtitle = "subMuonPt";
    bookDen = true;
    bookME(
        ibooker, subMuonPtME_, histname, histtitle, muonPt_binning_.nbins, muonPt_binning_.xmin, muonPt_binning_.xmax);
    setTitle(subMuonPtME_, "Subleading DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]", bookDen);

    histname = "subMuonPt_variable";
    histtitle = "subMuonPt";
    bookDen = true;
    bookME(ibooker, subMuonPtME_variableBinning_, histname, histtitle, muonPt_variable_binning_);
    setTitle(
        subMuonPtME_variableBinning_, "Subleading DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]", bookDen);

    histname = "subMuonEta";
    histtitle = "subMuonEta";
    bookDen = true;
    bookME(ibooker,
           subMuonEtaME_,
           histname,
           histtitle,
           muonEta_binning_.nbins,
           muonEta_binning_.xmin,
           muonEta_binning_.xmax);
    setTitle(subMuonEtaME_, "Subleading DisplacedStandAlone Muon #eta", "Events", bookDen);

    histname = "subMuonPhi";
    histtitle = "subMuonPhi";
    bookDen = true;
    bookME(ibooker,
           subMuonPhiME_,
           histname,
           histtitle,
           muonPhi_binning_.nbins,
           muonPhi_binning_.xmin,
           muonPhi_binning_.xmax);
    setTitle(subMuonPhiME_, "Subleading DisplacedStandAlone Muon #phi", "Events", bookDen);

    histname = "subMuonDxy";
    histtitle = "subMuonDxy";
    bookDen = true;
    bookME(ibooker,
           subMuonDxyME_,
           histname,
           histtitle,
           muonDxy_binning_.nbins,
           muonDxy_binning_.xmin,
           muonDxy_binning_.xmax);
    setTitle(subMuonDxyME_, "Subleading DisplacedStandAlone Muon #dxy", "Events", bookDen);
  }

  // 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);
}

void DiDispStaMuonMonitor::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;

  int ls = iEvent.id().luminosityBlock();

  edm::Handle<reco::TrackCollection> DSAHandle;
  iEvent.getByToken(muonToken_, DSAHandle);
  if ((unsigned int)(DSAHandle->size()) < nmuons_)
    return;
  std::vector<edm::Ptr<reco::Track>> dsaMuonPtrs_{};  // = DSAHandle->ptrs();
  for (size_t i(0); i != DSAHandle->size(); ++i) {
    dsaMuonPtrs_.emplace_back(DSAHandle, i);
  }
  std::vector<edm::Ptr<reco::Track>> muons{}, muonsCutOnPt{}, muonsCutOnDxy{}, muonsCutOnPtAndDxy{};

  // general selection
  auto selectGeneral_([this](edm::Ptr<reco::Track> const& m) -> bool { return muonSelectionGeneral_(*m); });
  std::copy_if(dsaMuonPtrs_.begin(), dsaMuonPtrs_.end(), back_inserter(muons), selectGeneral_);
  if ((unsigned int)(muons.size()) < nmuons_)
    return;

  // sort by pt
  auto ptSorter_ = [](edm::Ptr<reco::Track> const& lhs, edm::Ptr<reco::Track> const& rhs) -> bool {
    return lhs->pt() > rhs->pt();
  };
  std::sort(muons.begin(), muons.end(), ptSorter_);

  // cut on pt
  auto selectOnPt_([this](edm::Ptr<reco::Track> const& m) -> bool { return muonSelectionPt_(*m); });
  std::copy_if(muons.begin(), muons.end(), back_inserter(muonsCutOnPt), selectOnPt_);
  // cut on dxy
  auto selectOnDxy_([this](edm::Ptr<reco::Track> const& m) -> bool { return muonSelectionDxy_(*m); });
  std::copy_if(muons.begin(), muons.end(), back_inserter(muonsCutOnDxy), selectOnDxy_);
  // cut on pt and dxy
  auto selectOnPtAndDxy_(
      [this](edm::Ptr<reco::Track> const& m) -> bool { return muonSelectionPt_(*m) && muonSelectionDxy_(*m); });
  std::copy_if(muons.begin(), muons.end(), back_inserter(muonsCutOnPtAndDxy), selectOnPtAndDxy_);

  std::sort(muonsCutOnPt.begin(), muonsCutOnPt.end(), ptSorter_);
  std::sort(muonsCutOnDxy.begin(), muonsCutOnDxy.end(), ptSorter_);
  std::sort(muonsCutOnPtAndDxy.begin(), muonsCutOnPtAndDxy.end(), ptSorter_);

  // --------------------------------
  // filling histograms (denominator)
  // --------------------------------
  if (muonsCutOnDxy.size() >= nmuons_) {
    // pt has cut on dxy
    muonPtME_.denominator->Fill(muonsCutOnDxy[0]->pt());
    muonPtNoDxyCutME_.denominator->Fill(muons[0]->pt());
    muonPtME_variableBinning_.denominator->Fill(muonsCutOnDxy[0]->pt());
    muonPtVsLS_.denominator->Fill(ls, muonsCutOnDxy[0]->pt());
    if (nmuons_ > 1) {
      subMuonPtME_.denominator->Fill(muonsCutOnDxy[1]->pt());
      subMuonPtME_variableBinning_.denominator->Fill(muonsCutOnDxy[1]->pt());
    }
  }
  if (muonsCutOnPtAndDxy.size() >= nmuons_) {
    // eta, phi have cut on pt and dxy
    muonEtaME_.denominator->Fill(muonsCutOnPtAndDxy[0]->eta());
    muonPhiME_.denominator->Fill(muonsCutOnPtAndDxy[0]->phi());
    if (nmuons_ > 1) {
      subMuonEtaME_.denominator->Fill(muonsCutOnPtAndDxy[1]->eta());
      subMuonPhiME_.denominator->Fill(muonsCutOnPtAndDxy[1]->phi());
    }
  }
  if (muonsCutOnPt.size() >= nmuons_) {
    // dxy has cut on pt
    muonDxyME_.denominator->Fill(muonsCutOnPt[0]->dxy());
    if (nmuons_ > 1) {
      subMuonDxyME_.denominator->Fill(muonsCutOnPt[1]->dxy());
    }
  }

  // --------------------------------
  // filling histograms (numerator)
  // --------------------------------
  if (num_genTriggerEventFlag_->on() && !num_genTriggerEventFlag_->accept(iEvent, iSetup))
    return;

  if (muonsCutOnDxy.size() >= nmuons_) {
    // pt has cut on dxy
    muonPtME_.numerator->Fill(muonsCutOnDxy[0]->pt());
    muonPtNoDxyCutME_.numerator->Fill(muons[0]->pt());
    muonPtME_variableBinning_.numerator->Fill(muonsCutOnDxy[0]->pt());
    muonPtVsLS_.numerator->Fill(ls, muonsCutOnDxy[0]->pt());
    if (nmuons_ > 1) {
      subMuonPtME_.numerator->Fill(muonsCutOnDxy[1]->pt());
      subMuonPtME_variableBinning_.numerator->Fill(muonsCutOnDxy[1]->pt());
    }
  }
  if (muonsCutOnPtAndDxy.size() >= nmuons_) {
    // eta, phi have cut on pt and dxy
    muonEtaME_.numerator->Fill(muonsCutOnPtAndDxy[0]->eta());
    muonPhiME_.numerator->Fill(muonsCutOnPtAndDxy[0]->phi());
    if (nmuons_ > 1) {
      subMuonEtaME_.numerator->Fill(muonsCutOnPtAndDxy[1]->eta());
      subMuonPhiME_.numerator->Fill(muonsCutOnPtAndDxy[1]->phi());
    }
  }
  if (muonsCutOnPt.size() >= nmuons_) {
    // dxy has cut on pt
    muonDxyME_.numerator->Fill(muonsCutOnPt[0]->dxy());
    if (nmuons_ > 1) {
      subMuonDxyME_.numerator->Fill(muonsCutOnPt[1]->dxy());
    }
  }
}

void DiDispStaMuonMonitor::fillHistoPSetDescription(edm::ParameterSetDescription& pset) {
  pset.add<unsigned int>("nbins", 200);
  pset.add<double>("xmin", -0.5);
  pset.add<double>("xmax", 19999.5);
}

void DiDispStaMuonMonitor::fillHistoLSPSetDescription(edm::ParameterSetDescription& pset) {
  pset.add<unsigned int>("nbins", 2000);
}

void DiDispStaMuonMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<std::string>("FolderName", "HLT/EXO/DiDispStaMuon");

  desc.add<edm::InputTag>("muons", edm::InputTag("displacedStandAloneMuons"));
  desc.add<unsigned int>("nmuons", 2);

  edm::ParameterSetDescription muonSelection;
  muonSelection.add<std::string>("general", "pt > 0");
  muonSelection.add<std::string>("pt", "");
  muonSelection.add<std::string>("dxy", "pt > 0");
  desc.add<edm::ParameterSetDescription>("muonSelection", muonSelection);

  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<unsigned int>("verbosityLevel", 1);

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

  edm::ParameterSetDescription histoPSet;
  edm::ParameterSetDescription muonPtPSet;
  edm::ParameterSetDescription muonEtaPSet;
  edm::ParameterSetDescription muonPhiPSet;
  edm::ParameterSetDescription muonDxyPSet;
  edm::ParameterSetDescription lsPSet;
  fillHistoPSetDescription(muonPtPSet);
  fillHistoPSetDescription(muonEtaPSet);
  fillHistoPSetDescription(muonPhiPSet);
  fillHistoPSetDescription(muonDxyPSet);
  fillHistoPSetDescription(lsPSet);
  histoPSet.add<edm::ParameterSetDescription>("muonPtPSet", muonPtPSet);
  histoPSet.add<edm::ParameterSetDescription>("muonEtaPSet", muonEtaPSet);
  histoPSet.add<edm::ParameterSetDescription>("muonPhiPSet", muonPhiPSet);
  histoPSet.add<edm::ParameterSetDescription>("muonDxyPSet", muonDxyPSet);
  histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);
  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>>("muonPtBinning", bins);

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

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

// Define this as a plug-in
DEFINE_FWK_MODULE(DiDispStaMuonMonitor);