/data/git/CMSSW_5_3_11_patch5/src/DQM/CSCMonitorModule/src/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 "DQM/CSCMonitorModule/interface/CSCDQM_Dispatcher.h"

namespace cscdqm {

  Dispatcher::Dispatcher(Configuration* const p_config, MonitorObjectProvider* p_provider) : 
  collection(p_config), processor(p_config), processorFract(p_config) {

    config = p_config;
    provider = p_provider;

    config->fnGetCacheEMUHisto = boost::bind(&Cache::getEMU, &cache, _1, _2);
    config->fnGetCacheFEDHisto = boost::bind(&Cache::getFED, &cache, _1, _2, _3);
    config->fnGetCacheDDUHisto = boost::bind(&Cache::getDDU, &cache, _1, _2, _3);
    config->fnGetCacheCSCHisto = boost::bind(&Cache::getCSC, &cache, _1, _2, _3, _4, _5);
    config->fnGetCacheParHisto = boost::bind(&Cache::getPar, &cache, _1, _2);
    config->fnPutHisto = boost::bind(&Cache::put, &cache, _1, _2);
    config->fnNextBookedCSC = boost::bind(&Cache::nextBookedCSC, &cache, _1, _2, _3);
    config->fnIsBookedCSC = boost::bind(&Cache::isBookedCSC, &cache, _1, _2);
    config->fnIsBookedDDU = boost::bind(&Cache::isBookedDDU, &cache, _1);
    config->fnIsBookedFED = boost::bind(&Cache::isBookedFED, &cache, _1);

    config->fnGetHisto = boost::bind(&Dispatcher::getHisto, this, _1, _2);

    config->fnGetCSCDetId = boost::bind(&MonitorObjectProvider::getCSCDetId, provider, _1, _2, _3);

    config->fnBook = boost::bind(&MonitorObjectProvider::bookMonitorObject, provider, _1);

  }

  void Dispatcher::init() {
    collection.load();
    collection.bookEMUHistos();
    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, NULL);

    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()) { 
      boost::function<void ()> fnUpdate = boost::bind(&EventProcessorMutex::updateFractionAndEfficiencyHistos, &processorFract);
#ifdef DQMMT
      threads.create_thread(boost::ref(fnUpdate));
#else
      fnUpdate();
#endif 
    } else {
      processorFract.updateFractionAndEfficiencyHistos();
    }
  }

  void Dispatcher::processStandby(HWStandbyType& standby) {
    LockType lock(processorFract.mutex);
    if (config->getFRAEFF_SEPARATE_THREAD()) { 
      boost::function<void (HWStandbyType&)> fnUpdate = boost::bind(&EventProcessorMutex::processStandby, &processorFract, _1);
#ifdef DQMMT
      threads.create_thread(boost::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      

}