RPCDqmClient.cc

Go to the documentation of this file.

// Package:    RPCDqmClient
// Original Author:  Anna Cimmino
 
#include "DQM/RPCMonitorClient/interface/RPCDqmClient.h"
#include "DQM/RPCMonitorDigi/interface/RPCBookFolderStructure.h"
#include "DQM/RPCMonitorDigi/interface/utils.h"
//include client headers
#include "DQM/RPCMonitorClient/interface/RPCDeadChannelTest.h"
#include "DQM/RPCMonitorClient/interface/RPCMultiplicityTest.h"
#include "DQM/RPCMonitorClient/interface/RPCClusterSizeTest.h"
#include "DQM/RPCMonitorClient/interface/RPCOccupancyTest.h"
#include "DQM/RPCMonitorClient/interface/RPCNoisyStripTest.h"
//Geometry
#include "Geometry/RPCGeometry/interface/RPCGeometry.h"
#include "Geometry/RPCGeometry/interface/RPCGeomServ.h"
#include "Geometry/Records/interface/MuonGeometryRecord.h"
//Framework
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <FWCore/Framework/interface/ESHandle.h>
 
RPCDqmClient::RPCDqmClient(const edm::ParameterSet& parameters_) {
  edm::LogVerbatim("rpcdqmclient") << "[RPCDqmClient]: Constructor";
 
  offlineDQM_ = parameters_.getUntrackedParameter<bool>("OfflineDQM", true);
  useRollInfo_ = parameters_.getUntrackedParameter<bool>("UseRollInfo", false);
  //check enabling
  enableDQMClients_ = parameters_.getUntrackedParameter<bool>("EnableRPCDqmClient", true);
  minimumEvents_ = parameters_.getUntrackedParameter<int>("MinimumRPCEvents", 10000);
 
  std::string subsystemFolder = parameters_.getUntrackedParameter<std::string>("RPCFolder", "RPC");
  std::string recHitTypeFolder = parameters_.getUntrackedParameter<std::string>("RecHitTypeFolder", "AllHits");
  std::string summaryFolder = parameters_.getUntrackedParameter<std::string>("SummaryFolder", "SummaryHistograms");
 
  prefixDir_ = subsystemFolder + "/" + recHitTypeFolder;
  globalFolder_ = subsystemFolder + "/" + recHitTypeFolder + "/" + summaryFolder;
 
  //get prescale factor
  prescaleGlobalFactor_ = parameters_.getUntrackedParameter<int>("DiagnosticGlobalPrescale", 5);
 
  //make default client list
  clientList_.push_back("RPCMultiplicityTest");
  clientList_.push_back("RPCDeadChannelTest");
  clientList_.push_back("RPCClusterSizeTest");
  clientList_ = parameters_.getUntrackedParameter<std::vector<std::string> >("RPCDqmClientList", clientList_);
 
  //get all the possible RPC DQM clients
  this->makeClientMap(parameters_);
 
  //clear counters
  lumiCounter_ = 0;
}
 
RPCDqmClient::~RPCDqmClient() {}
 
void RPCDqmClient::beginJob() {
  if (!enableDQMClients_) {
    return;
  };
  edm::LogVerbatim("rpcdqmclient") << "[RPCDqmClient]: Begin Job";
 
  //Do whatever the begin jobs of all client modules do
  for (std::vector<RPCClient*>::iterator it = clientModules_.begin(); it != clientModules_.end(); it++) {
    (*it)->beginJob(globalFolder_);
  }
}
 
void RPCDqmClient::dqmEndLuminosityBlock(DQMStore::IBooker& ibooker,
                                         DQMStore::IGetter& igetter,
                                         edm::LuminosityBlock const& lumiSeg,
                                         edm::EventSetup const& c) {
  if (!enableDQMClients_) {
    return;
  }
  edm::LogVerbatim("rpcdqmclient") << "[RPCDqmClient]: End DQM LB";
 
  if (myDetIds_.empty()) {
    //Get RPCdetId...
 
    this->getRPCdetId(c);
 
    //...book summary histograms
    for (std::vector<RPCClient*>::iterator it = clientModules_.begin(); it != clientModules_.end(); it++) {
      (*it)->myBooker(ibooker);
    }
  }
 
  if (!offlineDQM_) {  //Do this only for the online
 
    if (lumiCounter_ == 0) {  //only for the first lumi section do this...
      // ...get chamber based histograms and pass them to the client modules
      this->getMonitorElements(igetter);
    }
 
    //Do not perform client oparations every lumi block
    lumiCounter_++;
    if (lumiCounter_ % prescaleGlobalFactor_ != 0) {
      return;
    }
 
    //Check if there's enough statistics
    float rpcevents = minimumEvents_;
    if (RPCEvents_) {
      rpcevents = RPCEvents_->getBinContent(1);
    }
    if (rpcevents < minimumEvents_) {
      return;
    }
 
    edm::LogVerbatim("rpcdqmclient") << "[RPCDqmClient]: Client operations";
    for (std::vector<RPCClient*>::iterator it = clientModules_.begin(); it != clientModules_.end(); it++) {
      (*it)->clientOperation();
    }
  }  //end of online operations
}
 
void RPCDqmClient::dqmEndJob(DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter) {
  if (!enableDQMClients_) {
    return;
  }
 
  edm::LogVerbatim("rpcdqmclient") << "[RPCDqmClient]: End DQM Job";
 
  if (offlineDQM_) {  // ...get chamber based histograms and pass them to the client modules
    this->getMonitorElements(igetter);
  }
 
  float rpcevents = minimumEvents_;
  if (RPCEvents_) {
    rpcevents = RPCEvents_->getBinContent(1);
  }
  if (rpcevents < minimumEvents_) {
    return;
  }
 
  edm::LogVerbatim("rpcdqmclient") << "[RPCDqmClient]: Client operations";
  for (std::vector<RPCClient*>::iterator it = clientModules_.begin(); it != clientModules_.end(); it++) {
    (*it)->clientOperation();
  }
}
 
void RPCDqmClient::getMonitorElements(DQMStore::IGetter& igetter) {
  std::vector<MonitorElement*> myMeVect;
  std::vector<RPCDetId> myDetIds;
 
  //dbe_->setCurrentFolder(prefixDir_);
  RPCBookFolderStructure* folderStr = new RPCBookFolderStructure();
  MonitorElement* myMe = nullptr;
  std::string rollName = "";
 
  //loop on all geometry and get all histos
  for (auto& detId : myDetIds_) {
    //Get name
    RPCGeomServ RPCname(detId);
    rollName = useRollInfo_ ? RPCname.name() : RPCname.chambername();
 
    //loop on clients
    for (unsigned int cl = 0, nCL = clientModules_.size(); cl < nCL; ++cl) {
      myMe =
          igetter.get(prefixDir_ + "/" + folderStr->folderStructure(detId) + "/" + clientHisto_[cl] + "_" + rollName);
      if (!myMe) {
        continue;
      }
 
      //       dbe_->tag(myMe, clientTag_[cl]);
      myMeVect.push_back(myMe);
      myDetIds.push_back(detId);
 
    }  //end loop on clients
  }    //end loop on all geometry and get all histos
 
  RPCEvents_ = igetter.get(prefixDir_ + "/RPCEvents");
  for (unsigned int cl = 0; cl < clientModules_.size(); ++cl) {
    clientModules_[cl]->getMonitorElements(myMeVect, myDetIds, clientHisto_[cl]);
  }
 
  delete folderStr;
}
 
void RPCDqmClient::getRPCdetId(const edm::EventSetup& eventSetup) {
  myDetIds_.clear();
 
  edm::ESHandle<RPCGeometry> rpcGeo;
  eventSetup.get<MuonGeometryRecord>().get(rpcGeo);
 
  for (auto& det : rpcGeo->dets()) {
    const RPCChamber* ch = dynamic_cast<const RPCChamber*>(det);
    if (!ch)
      continue;
 
    //Loop on rolls in given chamber
    for (auto& r : ch->rolls()) {
      RPCDetId detId = r->id();
      myDetIds_.push_back(detId);
    }
  }
}
 
void RPCDqmClient::makeClientMap(const edm::ParameterSet& parameters_) {
  for (unsigned int i = 0; i < clientList_.size(); i++) {
    if (clientList_[i] == "RPCMultiplicityTest") {
      clientHisto_.push_back("Multiplicity");
      // clientTag_.push_back(rpcdqm::MULTIPLICITY);
      clientModules_.push_back(new RPCMultiplicityTest(parameters_));
    } else if (clientList_[i] == "RPCDeadChannelTest") {
      clientHisto_.push_back("Occupancy");
      clientModules_.push_back(new RPCDeadChannelTest(parameters_));
      // clientTag_.push_back(rpcdqm::OCCUPANCY);
    } else if (clientList_[i] == "RPCClusterSizeTest") {
      clientHisto_.push_back("ClusterSize");
      clientModules_.push_back(new RPCClusterSizeTest(parameters_));
      // clientTag_.push_back(rpcdqm::CLUSTERSIZE);
    } else if (clientList_[i] == "RPCOccupancyTest") {
      clientHisto_.push_back("Occupancy");
      clientModules_.push_back(new RPCOccupancyTest(parameters_));
      // clientTag_.push_back(rpcdqm::OCCUPANCY);
    } else if (clientList_[i] == "RPCNoisyStripTest") {
      clientHisto_.push_back("Occupancy");
      clientModules_.push_back(new RPCNoisyStripTest(parameters_));
      //clientTag_.push_back(rpcdqm::OCCUPANCY);
    }
  }
 
  return;
}