EcalDQMonitorClient.cc

Go to the documentation of this file.

#include "DQM/EcalMonitorClient/interface/EcalDQMonitorClient.h"

#include "DQM/EcalCommon/interface/EcalDQMCommonUtils.h"

#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/EventSetupRecordKey.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"

#include "FWCore/ServiceRegistry/interface/Service.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "CondFormats/EcalObjects/interface/EcalDQMChannelStatus.h"
#include "CondFormats/EcalObjects/interface/EcalDQMTowerStatus.h"
#include "CondFormats/DataRecord/interface/EcalDQMChannelStatusRcd.h"
#include "CondFormats/DataRecord/interface/EcalDQMTowerStatusRcd.h"

#include <ctime>
#include <fstream>

EcalDQMonitorClient::EcalDQMonitorClient(edm::ParameterSet const& _ps)
    : DQMEDHarvester(), ecaldqm::EcalDQMonitor(_ps), iEvt_(0), statusManager_() {
  executeOnWorkers_(
      [this](ecaldqm::DQWorker* worker) {
        ecaldqm::DQWorkerClient* client(dynamic_cast<ecaldqm::DQWorkerClient*>(worker));
        if (!client)
          throw cms::Exception("InvalidConfiguration") << "Non-client DQWorker " << worker->getName() << " passed";
        client->setStatusManager(this->statusManager_);
      },
      "initialization");

  if (_ps.existsAs<edm::FileInPath>("PNMaskFile", false)) {
    std::ifstream maskFile(_ps.getUntrackedParameter<edm::FileInPath>("PNMaskFile").fullPath());
    if (maskFile.is_open())
      statusManager_.readFromStream(maskFile);
  }
}

EcalDQMonitorClient::~EcalDQMonitorClient() {}

/*static*/
void EcalDQMonitorClient::fillDescriptions(edm::ConfigurationDescriptions& _descs) {
  edm::ParameterSetDescription desc;
  ecaldqm::EcalDQMonitor::fillDescriptions(desc);

  edm::ParameterSetDescription clientParameters;
  ecaldqm::DQWorkerClient::fillDescriptions(clientParameters);
  edm::ParameterSetDescription allWorkers;
  allWorkers.addNode(
      edm::ParameterWildcard<edm::ParameterSetDescription>("*", edm::RequireZeroOrMore, false, clientParameters));
  desc.addUntracked("workerParameters", allWorkers);

  desc.addOptionalUntracked<edm::FileInPath>("PNMaskFile");

  _descs.addDefault(desc);
}

void EcalDQMonitorClient::beginRun(edm::Run const& _run, edm::EventSetup const& _es) {
  ecaldqmGetSetupObjects(_es);

  if (_es.find(edm::eventsetup::EventSetupRecordKey::makeKey<EcalDQMChannelStatusRcd>()) &&
      _es.find(edm::eventsetup::EventSetupRecordKey::makeKey<EcalDQMTowerStatusRcd>())) {
    edm::ESHandle<EcalDQMChannelStatus> cStHndl;
    _es.get<EcalDQMChannelStatusRcd>().get(cStHndl);

    edm::ESHandle<EcalDQMTowerStatus> tStHndl;
    _es.get<EcalDQMTowerStatusRcd>().get(tStHndl);

    statusManager_.readFromObj(*cStHndl, *tStHndl);
  }

  ecaldqmBeginRun(_run, _es);
}

void EcalDQMonitorClient::endRun(edm::Run const& _run, edm::EventSetup const& _es) { ecaldqmEndRun(_run, _es); }

void EcalDQMonitorClient::dqmEndLuminosityBlock(DQMStore::IBooker& _ibooker,
                                                DQMStore::IGetter& _igetter,
                                                edm::LuminosityBlock const& _lumi,
                                                edm::EventSetup const& _es) {
  executeOnWorkers_(
      [&_ibooker](ecaldqm::DQWorker* worker) {
        ecaldqm::DQWorkerClient* client(static_cast<ecaldqm::DQWorkerClient*>(worker));
        if (!client->onlineMode() && !client->runsOn(ecaldqm::DQWorkerClient::kLumi))
          return;
        client->bookMEs(_ibooker);
      },
      "bookMEs",
      "Booking MEs");

  ecaldqmEndLuminosityBlock(_lumi, _es);

  runWorkers(_igetter, ecaldqm::DQWorkerClient::kLumi);

  executeOnWorkers_(
      [](ecaldqm::DQWorker* worker) {
        ecaldqm::DQWorkerClient* client(static_cast<ecaldqm::DQWorkerClient*>(worker));
        client->resetPerLumi();
      },
      "dqmEndLuminosityBlock",
      "Reset per-lumi MEs");
}

void EcalDQMonitorClient::dqmEndJob(DQMStore::IBooker& _ibooker, DQMStore::IGetter& _igetter) {
  executeOnWorkers_(
      [&_ibooker](ecaldqm::DQWorker* worker) {
        worker->bookMEs(_ibooker);  // worker returns if already booked
      },
      "bookMEs",
      "Booking MEs");

  runWorkers(_igetter, ecaldqm::DQWorkerClient::kJob);

  executeOnWorkers_([](ecaldqm::DQWorker* worker) { worker->releaseMEs(); }, "releaseMEs", "releasing histograms");
}

void EcalDQMonitorClient::runWorkers(DQMStore::IGetter& _igetter, ecaldqm::DQWorkerClient::ProcessType _type) {
  if (verbosity_ > 0)
    edm::LogInfo("EcalDQM") << moduleName_ << ": Starting worker modules..";

  executeOnWorkers_(
      [&_igetter, &_type](ecaldqm::DQWorker* worker) {
        ecaldqm::DQWorkerClient* client(static_cast<ecaldqm::DQWorkerClient*>(worker));
        if (!client->onlineMode() && !client->runsOn(_type))
          return;
        client->releaseSource();
        client->resetMEs();
        if (!client->retrieveSource(_igetter, _type))
          return;
        if (client->onlineMode())
          client->setTime(time(nullptr));
        client->producePlots(_type);
      },
      "retrieveAndRun",
      "producing plots");

  if (verbosity_ > 0)
    edm::LogInfo("EcalDQM") << " done." << std::endl;
}

DEFINE_FWK_MODULE(EcalDQMonitorClient);