SiStripOfflineDQM.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    SiStripMonitorCluster
// Class:      SiStripOfflineDQM
//
//
// Original Author:  Samvel Khalatyan (ksamdev at gmail dot com)
//         Created:  Wed Oct  5 16:42:34 CET 2006
//
//

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Framework/interface/LuminosityBlock.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "CommonTools/UtilAlgos/interface/TFileService.h"

#include "DataFormats/FEDRawData/interface/FEDNumbering.h"

#include "DQMServices/Core/interface/DQMStore.h"

#include "DQM/SiStripCommon/interface/SiStripFolderOrganizer.h"
#include "DQM/SiStripMonitorClient/interface/SiStripActionExecutor.h"

#include "SiStripOfflineDQM.h"

//Run Info
#include "CondFormats/DataRecord/interface/RunSummaryRcd.h"
#include "CondFormats/RunInfo/interface/RunSummary.h"
#include "CondFormats/RunInfo/interface/RunInfo.h"

// Cabling
#include "CalibTracker/Records/interface/SiStripDetCablingRcd.h"
#include "CalibFormats/SiStripObjects/interface/SiStripDetCabling.h"

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <sstream>
#include <cmath>

SiStripOfflineDQM::SiStripOfflineDQM(edm::ParameterSet const& pSet)
  : configPar_{pSet},
    actionExecutor_{pSet},
    usedWithEDMtoMEConverter_{
      configPar_.getUntrackedParameter<bool>("UsedWithEDMtoMEConverter",
                                             false)},
    createSummary_{
      configPar_.getUntrackedParameter<bool>("CreateSummary", false)},
    createTkInfoFile_{
      configPar_.getUntrackedParameter<bool>("CreateTkInfoFile", false)},
    inputFileName_{
      configPar_.getUntrackedParameter<std::string>("InputFileName", "")},
    outputFileName_{
      configPar_.getUntrackedParameter<std::string>("OutputFileName", "")},
    globalStatusFilling_{
      configPar_.getUntrackedParameter<int>("GlobalStatusFilling", 1)},
    printFaultyModuleList_{
      configPar_.getUntrackedParameter<bool>("PrintFaultyModuleList", false)}
{
  if (createTkInfoFile_) {
    tkinfoTree_ = edm::Service<TFileService> {}
    ->make<TTree>("TkDetIdInfo", "");
  }
}

void
SiStripOfflineDQM::beginJob()
{
  // Essential: reads xml file to get the histogram names to create summary
  // Read the summary configuration file
  if (createSummary_) {
    if (!actionExecutor_.readConfiguration()) {
      edm::LogInfo("ReadConfigurationProblem")
        << "SiStripOfflineDQM:: Error to read configuration file!! Summary "
           "will not be produced!!!";
      createSummary_ = false;
    }
  }
  edm::LogInfo("BeginJobDone") << "SiStripOfflineDQM::beginJob done";
}

void
SiStripOfflineDQM::beginRun(edm::Run const& run, edm::EventSetup const& eSetup)
{
  edm::LogInfo ("BeginRun") <<"SiStripOfflineDQM:: Begining of Run";

  int nFEDs = 0;
  if(auto runInfoRec = eSetup.tryToGet<RunInfoRcd>()) {

    edm::ESHandle<RunInfo> sumFED;
    runInfoRec->get(sumFED);
    if (sumFED.isValid()) {
      constexpr int siStripFedIdMin{FEDNumbering::MINSiStripFEDID};
      constexpr int siStripFedIdMax{FEDNumbering::MAXSiStripFEDID};

      for (auto const fedID : sumFED->m_fed_in) {
        if (fedID >= siStripFedIdMin && fedID <= siStripFedIdMax) ++nFEDs;
      }
    }
  }
  auto& dqm_store = *edm::Service<DQMStore>{};
  trackerFEDsFound_ = (nFEDs > 0);
  if (!usedWithEDMtoMEConverter_) {
    if (!openInputFile(dqm_store)) createSummary_ = false;
  }
  if (globalStatusFilling_ > 0) {
    actionExecutor_.createStatus(dqm_store);
  }
}

void
SiStripOfflineDQM::analyze(edm::Event const&, edm::EventSetup const&)
{}

void
SiStripOfflineDQM::endLuminosityBlock(edm::LuminosityBlock const& lumiSeg,
                                      edm::EventSetup const& iSetup)
{
  edm::LogInfo( "EndLumiBlock") << "SiStripOfflineDQM::endLuminosityBlock";
  if (trackerFEDsFound_) {
    if (globalStatusFilling_ > 0) {
      auto& dqm_store = *edm::Service<DQMStore>{};
      actionExecutor_.fillStatusAtLumi(dqm_store);
    }
  }
}

void
SiStripOfflineDQM::endRun(edm::Run const& run, edm::EventSetup const& eSetup)
{
  edm::LogInfo( "EndOfRun") << "SiStripOfflineDQM::endRun";

  // Access Cabling
  edm::ESHandle< SiStripDetCabling > det_cabling;
  eSetup.get<SiStripDetCablingRcd>().get(det_cabling);

  auto& dqm_store = *edm::Service<DQMStore>{};
  if (globalStatusFilling_ > 0) {
    actionExecutor_.createStatus(dqm_store);
    if (!trackerFEDsFound_) {
      actionExecutor_.fillDummyStatus();
      return;
    }
    // Fill Global Status
    actionExecutor_.fillStatus(dqm_store, det_cabling, eSetup);
  }

  if (usedWithEDMtoMEConverter_) return;

  // create Summary Plots
  if (createSummary_) actionExecutor_.createSummaryOffline(dqm_store);

  // Create TrackerMap
  bool const create_tkmap =
    configPar_.getUntrackedParameter<bool>("CreateTkMap", false);
  if (create_tkmap) {
    auto const tkMapOptions =
      configPar_.getUntrackedParameter<std::vector<edm::ParameterSet>>(
        "TkMapOptions");
    if (actionExecutor_.readTkMapConfiguration(eSetup)) {
      std::vector<std::string> map_names;
      for (auto const& ps : tkMapOptions) {
        edm::ParameterSet tkMapPSet = ps;
        std::string map_type =
          ps.getUntrackedParameter<std::string>("mapName", "");
        map_names.push_back(map_type);
        tkMapPSet.augment(configPar_.getUntrackedParameter<edm::ParameterSet>(
          "TkmapParameters"));
        edm::LogInfo("TkMapParameters") << tkMapPSet;
        actionExecutor_.createOfflineTkMap(
          tkMapPSet, dqm_store, map_type, eSetup);
      }
      if (createTkInfoFile_) {
        actionExecutor_.createTkInfoFile(map_names, tkinfoTree_, dqm_store);
      }
    }
  }
}

void
SiStripOfflineDQM::endJob()
{
  edm::LogInfo( "EndOfJob") << "SiStripOfflineDQM::endJob";
  if (usedWithEDMtoMEConverter_) return;

  if (printFaultyModuleList_) {
    std::ostringstream str_val;
    auto& dqm_store = *edm::Service<DQMStore>{};
    actionExecutor_.printFaultyModuleList(dqm_store, str_val);
    std::cout << str_val.str() << std::endl;
  }
}

bool
SiStripOfflineDQM::openInputFile(DQMStore& dqm_store)
{
  if (inputFileName_.empty()) return false;
  edm::LogInfo("OpenFile") <<  "SiStripOfflineDQM::openInputFile: Accessing root File" << inputFileName_;
  dqm_store.open(inputFileName_, false);
  return true;
}

#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(SiStripOfflineDQM);