CSCDQM_Dispatcher.cc

Go to the documentation of this file.

/*
 * =====================================================================================
 *
 *       Filename:  CSCDQM_Dispatcher.cc
 *
 *    Description:  CSCDQM Dispatcher implementation
 *
 *        Version:  1.0
 *        Created:  12/01/2008 10:32:38 AM
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Valdas Rapsevicius (VR), valdas.rapsevicius@cern.ch
 *        Company:  CERN, CH
 *
 * =====================================================================================
 */
 
#include "CSCDQM_Dispatcher.h"
 
namespace cscdqm {
 
  Dispatcher::Dispatcher(Configuration* const p_config, MonitorObjectProvider* p_provider)
      : collection(p_config), processor(p_config), processorFract(p_config) {
    commonConstruct(p_config, p_provider);
  }
 
#ifdef DQMGLOBAL
 
  Dispatcher::Dispatcher(Configuration* const p_config,
                         MonitorObjectProvider* p_provider,
                         const edm::InputTag& itag,
                         edm::ConsumesCollector&& coco)
      : collection(p_config), processor(p_config, itag, coco), processorFract(p_config) {
    commonConstruct(p_config, p_provider);
  }
 
#endif
 
  void Dispatcher::commonConstruct(Configuration* const p_config, MonitorObjectProvider* p_provider) {
    config = p_config;
    provider = p_provider;
 
    config->fnGetCacheEMUHisto = std::bind(&Cache::getEMU, &cache, std::placeholders::_1, std::placeholders::_2);
    config->fnGetCacheFEDHisto =
        std::bind(&Cache::getFED, &cache, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
    config->fnGetCacheDDUHisto =
        std::bind(&Cache::getDDU, &cache, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
    config->fnGetCacheCSCHisto = std::bind(&Cache::getCSC,
                                           &cache,
                                           std::placeholders::_1,
                                           std::placeholders::_2,
                                           std::placeholders::_3,
                                           std::placeholders::_4,
                                           std::placeholders::_5);
    config->fnGetCacheParHisto = std::bind(&Cache::getPar, &cache, std::placeholders::_1, std::placeholders::_2);
    config->fnPutHisto = std::bind(&Cache::put, &cache, std::placeholders::_1, std::placeholders::_2);
    config->fnNextBookedCSC =
        std::bind(&Cache::nextBookedCSC, &cache, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
    config->fnIsBookedCSC = std::bind(&Cache::isBookedCSC, &cache, std::placeholders::_1, std::placeholders::_2);
    config->fnIsBookedDDU = std::bind(&Cache::isBookedDDU, &cache, std::placeholders::_1);
    config->fnIsBookedFED = std::bind(&Cache::isBookedFED, &cache, std::placeholders::_1);
 
    config->fnGetHisto = std::bind(&Dispatcher::getHisto, this, std::placeholders::_1, std::placeholders::_2);
 
    config->fnGetCSCDetId = std::bind(&MonitorObjectProvider::getCSCDetId,
                                      provider,
                                      std::placeholders::_1,
                                      std::placeholders::_2,
                                      std::placeholders::_3);
 
    config->fnBook = std::bind(&MonitorObjectProvider::bookMonitorObject, provider, std::placeholders::_1);
  }
 
  void Dispatcher::init() {
    collection.load();
    // collection.bookEMUHistos();
    // processor.init();
  }
 
  void Dispatcher::book() {
    collection.bookEMUHistos();
 
    /*** FOr multi-threading pre-book all FED, DDU, CSC histograms ***/
    if (config->getPREBOOK_ALL_HISTOS()) {
      for (HwId FEDId = 750; FEDId < 758; FEDId++) {
        if (!cache.isBookedFED(FEDId)) {
          collection.bookFEDHistos(FEDId);
        }
      }
 
      if (config->getPROCESS_DDU()) {
        for (HwId DDUId = 1; DDUId <= 36; DDUId++) {
          if (!cache.isBookedDDU(DDUId)) {
            collection.bookDDUHistos(DDUId);
          }
        }
      }
 
      if (config->getPROCESS_CSC()) {
        for (HwId CrateId = 1; CrateId <= 60; CrateId++) {
          for (HwId DMBId = 1; DMBId <= 10; DMBId++) {
            if (DMBId == 6)
              continue;  
            if (!cache.isBookedCSC(CrateId, DMBId)) {
              collection.bookCSCHistos(CrateId, DMBId);
            }
          }
        }
      }
 
      if (config->getPROCESS_EFF_PARAMETERS()) {
        std::vector<HistoId> parameters;
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION01_RING01);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION01_RING02);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION01_RING03);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION01);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION02_RING01);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION02_RING02);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION02);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION03_RING01);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION03_RING02);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION03);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION04_RING01);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION04_RING02);
        parameters.push_back(h::PAR_CSC_SIDEPLUS_STATION04);
        parameters.push_back(h::PAR_CSC_SIDEPLUS);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION01_RING01);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION01_RING02);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION01_RING03);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION01);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION02_RING01);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION02_RING02);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION02);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION03_RING01);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION03_RING02);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION03);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION04_RING01);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION04_RING02);
        parameters.push_back(h::PAR_CSC_SIDEMINUS_STATION04);
        parameters.push_back(h::PAR_CSC_SIDEMINUS);
        parameters.push_back(h::PAR_REPORT_SUMMARY);
 
        for (size_t i = 0; i < parameters.size(); i++) {
          ParHistoDef histoD(parameters[i]);
          auto histodef = HistoDef(parameters[i]);
          HistoBookRequest req(histodef, config->getFOLDER_PAR(), -1.0f);
          MonitorObject* me = provider->bookMonitorObject(req);
          cache.put(histoD, me);
        }
      }
    }
 
    processor.init();
  }
 
  unsigned int Dispatcher::maskHWElements(std::vector<std::string>& tokens) {
    return processorFract.maskHWElements(tokens);
  }
 
  const bool Dispatcher::getHisto(const HistoDef& histoD, MonitorObject*& me) {
    if (typeid(histoD) == FEDHistoDefT && !cache.isBookedFED(histoD.getFEDId())) {
      collection.bookFEDHistos(histoD.getFEDId());
      if (cache.get(histoD, me))
        return true;
    }
 
    if (typeid(histoD) == DDUHistoDefT && !cache.isBookedDDU(histoD.getDDUId())) {
      collection.bookDDUHistos(histoD.getDDUId());
      if (cache.get(histoD, me))
        return true;
    }
 
    if (typeid(histoD) == CSCHistoDefT) {
      if (!cache.isBookedCSC(histoD.getCrateId(), histoD.getDMBId())) {
        collection.bookCSCHistos(histoD.getCrateId(), histoD.getDMBId());
      }
      if (collection.isOnDemand(histoD.getHistoName())) {
        collection.bookCSCHistos(histoD.getId(), histoD.getCrateId(), histoD.getDMBId(), histoD.getAddId());
      }
      if (cache.get(histoD, me))
        return true;
    }
 
    if (typeid(histoD) == ParHistoDefT) {
      HistoBookRequest req(histoD, config->getFOLDER_PAR(), -1.0f);
      me = provider->bookMonitorObject(req);
      cache.put(histoD, me);
      return true;
    }
 
    cache.put(histoD, nullptr);
 
    return false;
  }
 
  void Dispatcher::updateFractionAndEfficiencyHistosAuto() {
    if (config->getFRAEFF_AUTO_UPDATE() && (config->getNEventsCSC() >= config->getFRAEFF_AUTO_UPDATE_START()) &&
        (config->getNEventsCSC() % config->getFRAEFF_AUTO_UPDATE_FREQ()) == 0) {
      updateFractionAndEfficiencyHistos();
    }
  }
 
  void Dispatcher::updateFractionAndEfficiencyHistos() {
    LockType lock(processorFract.mutex);
    if (config->getFRAEFF_SEPARATE_THREAD()) {
      std::function<void()> fnUpdate =
          std::bind(&EventProcessorMutex::updateFractionAndEfficiencyHistos, &processorFract);
#ifdef DQMMT
      threads.create_thread(std::ref(fnUpdate));
#else
      fnUpdate();
#endif
    } else {
      processorFract.updateFractionAndEfficiencyHistos();
    }
  }
 
  void Dispatcher::processStandby(HWStandbyType& standby) {
    LockType lock(processorFract.mutex);
    if (config->getFRAEFF_SEPARATE_THREAD()) {
      std::function<void(HWStandbyType&)> fnUpdate =
          std::bind(&EventProcessorMutex::processStandby, &processorFract, std::placeholders::_1);
#ifdef DQMMT
      threads.create_thread(std::ref(fnUpdate));
#else
      fnUpdate(standby);
#endif
    } else {
      processorFract.processStandby(standby);
    }
  }
 
#ifdef DQMLOCAL
 
  void Dispatcher::processEvent(const char* data,
                                const int32_t dataSize,
                                const uint32_t errorStat,
                                const int32_t nodeNumber) {
    config->eventProcessTimer(true);
    processor.processEvent(data, dataSize, errorStat, nodeNumber);
    config->eventProcessTimer(false);
    updateFractionAndEfficiencyHistosAuto();
  }
 
#endif
 
#ifdef DQMGLOBAL
 
  void Dispatcher::processEvent(const edm::Event& e, const edm::InputTag& inputTag, HWStandbyType& standby) {
    config->eventProcessTimer(true);
 
    // Consider standby information
    if (standby.process) {
      // Set in full standby once at the start. Afterwards - no!
      // i.e. if we ever in the run have gone off standby - this value is false
      config->setIN_FULL_STANDBY(config->getIN_FULL_STANDBY() && standby.fullStandby());
 
      //std::cout << "standby.MeP = " << standby.MeP << "\n";
      //std::cout << "standby.MeM = " << standby.MeM << "\n";
      //std::cout << "standby.fullStandby() = " << standby.fullStandby() << "\n";
      //std::cout << "config->getIN_FULL_STANDBY = " << config->getIN_FULL_STANDBY() << "\n";
 
      processStandby(standby);
 
      // We do not fill histograms in full standby!
      if (standby.fullStandby()) {
        return;
      }
    }
 
    processor.processEvent(e, inputTag);
 
    config->eventProcessTimer(false);
 
    updateFractionAndEfficiencyHistosAuto();
  }
 
#endif
 
}  // namespace cscdqm