PixelVTXMonitor.cc

Go to the documentation of this file.

/*
 * \file PixelVTXMonitor.cc
 * \author S. Dutta
 * Last Update:
 *
 * Description: Pixel Vertex Monitoring for different HLT paths
 *
*/
#include "DQM/BeamMonitor/plugins/PixelVTXMonitor.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Framework/interface/LuminosityBlock.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Framework/interface/Event.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
#include "TPRegexp.h"

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

PixelVTXMonitor::PixelVTXMonitor(const edm::ParameterSet& ps) : parameters_(ps) {
  moduleName_ = parameters_.getParameter<std::string>("ModuleName");
  folderName_ = parameters_.getParameter<std::string>("FolderName");
  pixelClusterInputTagToken_ =
      consumes<SiPixelClusterCollectionNew>(parameters_.getParameter<edm::InputTag>("PixelClusterInputTag"));
  pixelVertexInputTagToken_ =
      consumes<reco::VertexCollection>(parameters_.getParameter<edm::InputTag>("PixelVertexInputTag"));
  hltInputTagToken_ = consumes<edm::TriggerResults>(parameters_.getParameter<edm::InputTag>("HLTInputTag"));
  pixelClusterInputTag_ = parameters_.getParameter<edm::InputTag>("PixelClusterInputTag");
  pixelVertexInputTag_ = parameters_.getParameter<edm::InputTag>("PixelVertexInputTag");
  hltInputTag_ = parameters_.getParameter<edm::InputTag>("HLTInputTag");
  minVtxDoF_ = parameters_.getParameter<double>("MinVtxDoF");
}

PixelVTXMonitor::~PixelVTXMonitor() {}

void PixelVTXMonitor::bookHistograms() {
  std::vector<std::string> hltPathsOfInterest =
      parameters_.getParameter<std::vector<std::string> >("HLTPathsOfInterest");
  if (hltPathsOfInterest.empty())
    return;

  const std::vector<std::string>& pathList = hltConfig_.triggerNames();
  std::vector<std::string> selectedPaths;
  for (std::vector<std::string>::const_iterator it = pathList.begin(); it != pathList.end(); ++it) {
    int nmatch = 0;
    for (std::vector<std::string>::const_iterator kt = hltPathsOfInterest.begin(); kt != hltPathsOfInterest.end();
         ++kt) {
      nmatch += TPRegexp(*kt).Match(*it);
    }
    if (!nmatch)
      continue;
    else
      selectedPaths.push_back(*it);
  }

  edm::ParameterSet ClusHistoPar = parameters_.getParameter<edm::ParameterSet>("TH1ClusPar");
  edm::ParameterSet VtxHistoPar = parameters_.getParameter<edm::ParameterSet>("TH1VtxPar");

  std::string currentFolder = moduleName_ + "/" + folderName_;
  dbe_->setCurrentFolder(currentFolder);

  PixelMEs local_MEs;
  for (std::vector<std::string>::iterator it = selectedPaths.begin(); it != selectedPaths.end(); it++) {
    std::string tag = (*it);
    std::map<std::string, PixelMEs>::iterator iPos = histoMap_.find(tag);
    if (iPos == histoMap_.end()) {
      std::string hname, htitle;

      hname = "nPxlClus_";
      hname += tag;
      htitle = "# of Pixel Clusters (";
      htitle += tag + ")";
      local_MEs.clusME = dbe_->book1D(hname,
                                      htitle,
                                      ClusHistoPar.getParameter<int32_t>("Xbins"),
                                      ClusHistoPar.getParameter<double>("Xmin"),
                                      ClusHistoPar.getParameter<double>("Xmax"));

      hname = "nPxlVtx_";
      hname += tag;
      htitle = "# of Pixel Vertices (";
      htitle += tag + ")";
      local_MEs.vtxME = dbe_->book1D(hname,
                                     htitle,
                                     VtxHistoPar.getParameter<int32_t>("Xbins"),
                                     VtxHistoPar.getParameter<double>("Xmin"),
                                     VtxHistoPar.getParameter<double>("Xmax"));

      histoMap_.insert(std::make_pair(tag, local_MEs));
    }
  }
}

void PixelVTXMonitor::beginJob() { dbe_ = edm::Service<DQMStore>().operator->(); }

void PixelVTXMonitor::beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
  bool changed = true;
  if (hltConfig_.init(iRun, iSetup, hltInputTag_.process(), changed)) {
    // if init returns TRUE, initialisation has succeeded!
    edm::LogInfo("PixelVTXMonitor") << "HLT config with process name " << hltInputTag_.process()
                                    << " successfully extracted";
  } else {
    // if init returns FALSE, initialisation has NOT succeeded, which indicates a problem
    // with the file and/or code and needs to be investigated!
    edm::LogError("PixelVTXMonotor") << "Error! HLT config extraction with process name " << hltInputTag_.process()
                                     << " failed";
    // In this case, all access methods will return empty values!
  }
  bookHistograms();
}
void PixelVTXMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) {
  if (histoMap_.empty())
    return;

  //Access Pixel Clusters
  edm::Handle<SiPixelClusterCollectionNew> siPixelClusters;
  iEvent.getByToken(pixelClusterInputTagToken_, siPixelClusters);

  if (!siPixelClusters.isValid()) {
    edm::LogError("PixelVTXMonotor") << "Could not find Cluster Collection " << pixelClusterInputTag_;
    return;
  }
  unsigned nClusters = siPixelClusters->size();

  //Access Pixel Verteces
  edm::Handle<reco::VertexCollection> pixelVertices;
  iEvent.getByToken(pixelVertexInputTagToken_, pixelVertices);
  if (!pixelVertices.isValid()) {
    edm::LogError("PixelVTXMonotor") << "Could not find Vertex Collection " << pixelVertexInputTag_;
    return;
  }

  int nVtx = 0;
  for (reco::VertexCollection::const_iterator ivtx = pixelVertices->begin(); ivtx != pixelVertices->end(); ++ivtx) {
    if (minVtxDoF_ == -1)
      nVtx++;
    else {
      if ((ivtx->isValid() == true) && (ivtx->isFake() == false) && (ivtx->ndof() >= minVtxDoF_) &&
          (ivtx->tracksSize() != 0))
        nVtx++;
    }
  }
  // Access Trigger Results
  edm::Handle<edm::TriggerResults> triggerResults;
  iEvent.getByToken(hltInputTagToken_, triggerResults);
  if (!triggerResults.isValid())
    return;

  for (std::map<std::string, PixelMEs>::iterator it = histoMap_.begin(); it != histoMap_.end(); ++it) {
    std::string path = it->first;
    MonitorElement* me_clus = it->second.clusME;
    MonitorElement* me_vtx = it->second.vtxME;
    unsigned int index = hltConfig_.triggerIndex(path);
    if (index < triggerResults->size() && triggerResults->accept(index)) {
      if (me_vtx)
        me_vtx->Fill(nVtx);
      if (me_clus)
        me_clus->Fill(nClusters);
    }
  }
}

void PixelVTXMonitor::endRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {}

void PixelVTXMonitor::endJob() {}
// Define this as a plug-in
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(PixelVTXMonitor);

// Local Variables:
// show-trailing-whitespace: t
// truncate-lines: t
// End: