CSCDQM_EventProcessor_processDDU.cc

Go to the documentation of this file.

/*
 * =====================================================================================
 *
 *       Filename:  EventProcessor.cc
 *
 *    Description:  EventProcessor Object
 *
 *        Version:  1.0
 *        Created:  10/03/2008 10:47:11 AM
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Valdas Rapsevicius (VR), Valdas.Rapsevicius@cern.ch
 *        Company:  CERN, CH
 *
 * =====================================================================================
 */

#include "DQM/CSCMonitorModule/interface/CSCDQM_EventProcessor.h"

namespace cscdqm {

  void EventProcessor::processDDU(const CSCDDUEventData& dduData, const CSCDCCExaminer& binChecker) {
    
    CSCDDUHeader dduHeader  = dduData.header();
    CSCDDUTrailer dduTrailer = dduData.trailer();
    if (!dduTrailer.check()) {
      return;
    }

    int dduID = dduHeader.source_id() & 0xFF;

    MonitorObject* mo = 0;

    if (getEMUHisto(h::EMU_ALL_DDUS_IN_READOUT, mo)) {
      mo->Fill(dduID);
    }

    std::string dduTag = DDUHistoDef::getPath(dduID);

    uint32_t dduEvtSize = dduData.sizeInWords()*2; 

    // if (dduEvtSize > 48) 
    { 

    int trl_word_count = 0;
    trl_word_count = dduTrailer.wordcount();

    if (getDDUHisto(h::DDU_BUFFER_SIZE, dduID, mo)) mo->Fill(dduEvtSize);

    if (getDDUHisto(h::DDU_WORD_COUNT, dduID, mo)) mo->Fill(trl_word_count );
  
    if (trl_word_count > 0) { 
      if (getEMUHisto(h::EMU_ALL_DDUS_EVENT_SIZE, mo)) {
        mo->Fill(dduID, log10((double)trl_word_count));
      }
    }

    if (getEMUHisto(h::EMU_ALL_DDUS_AVERAGE_EVENT_SIZE, mo)) {
      mo->Fill(dduID, trl_word_count);
    }

    }

    fCloseL1As = dduTrailer.reserved() & 0x1; // Get status if Close L1As bit
    BXN = dduHeader.bxnum();
    if (getEMUHisto(h::EMU_DDU_BXN, mo)) mo->Fill(BXN);
    if (getDDUHisto(h::DDU_BXN, dduID, mo)) mo->Fill(BXN);

    int L1ANumber_previous_event = L1ANumbers[dduID];
    L1ANumbers[dduID] = (int)(dduHeader.lvl1num());
    L1ANumber = L1ANumbers[dduID];
    int L1A_inc = L1ANumber - L1ANumber_previous_event;

    if ( L1A_inc < 0 ) L1A_inc = 0xFFFFFF + L1A_inc;

    // if (!fFirstEvent) {
    if (fNotFirstEvent[dduID]) {
      if (getDDUHisto(h::DDU_L1A_INCREMENT, dduID, mo)) mo->Fill(L1A_inc);
      if (getEMUHisto(h::EMU_ALL_DDUS_L1A_INCREMENT, mo)) {
        if      (L1A_inc > 100000){ L1A_inc = 19;}
        else if (L1A_inc > 30000) { L1A_inc = 18;}
        else if (L1A_inc > 10000) { L1A_inc = 17;}
        else if (L1A_inc > 3000)  { L1A_inc = 16;}
        else if (L1A_inc > 1000)  { L1A_inc = 15;}
        else if (L1A_inc > 300)   { L1A_inc = 14;}
        else if (L1A_inc > 100)   { L1A_inc = 13;}
        else if (L1A_inc > 30)    { L1A_inc = 12;}
        else if (L1A_inc > 10)    { L1A_inc = 11;}
        mo->Fill(dduID, L1A_inc);
      }
    }

    int dmb_dav_header      = 0;
    int dmb_dav_header_cnt  = 0;
  
    int ddu_connected_inputs= 0;
    int ddu_connected_inputs_cnt = 0;
  
    int csc_error_state     = 0;
    int csc_warning_state   = 0;
  
    int dmb_active_header   = 0;
  
    dmb_dav_header       = dduHeader.dmb_dav();
    dmb_active_header    = (int)(dduHeader.ncsc() & 0xF);
    csc_error_state      = dduTrailer.dmb_full()  & 0x7FFF; // Only 15 inputs for DDU
    csc_warning_state    = dduTrailer.dmb_warn()  & 0x7FFF; // Only 15 inputs for DDU
    ddu_connected_inputs = dduHeader.live_cscs();
  
    double freq = 0;
    for (int i = 0; i < 15; ++i) {
      if ((dmb_dav_header >> i) & 0x1) {
        dmb_dav_header_cnt++;      
        if (getDDUHisto(h::DDU_DMB_DAV_HEADER_OCCUPANCY_RATE, dduID, mo)) {
    mo->Fill(i + 1);
    freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
          if (getDDUHisto(h::DDU_DMB_DAV_HEADER_OCCUPANCY, dduID, mo)) 
            mo->SetBinContent(i+1,freq);
        }
        if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_WITH_DATA, mo)) {
          mo->Fill(dduID, i);
        }
      }
  
      if( (ddu_connected_inputs >> i) & 0x1 ){
        ddu_connected_inputs_cnt++;
        if (getDDUHisto(h::DDU_DMB_CONNECTED_INPUTS_RATE, dduID, mo)) {
    mo->Fill(i + 1);
    freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
    if (getDDUHisto(h::DDU_DMB_CONNECTED_INPUTS, dduID, mo))
            mo->SetBinContent(i + 1, freq);
        }
        if (getEMUHisto(h::EMU_ALL_DDUS_LIVE_INPUTS, mo)) {
          mo->Fill(dduID, i);
        }
      }
  
      if( (csc_error_state >> i) & 0x1 ){
        if (getDDUHisto(h::DDU_CSC_ERRORS_RATE, dduID, mo)) {
    mo->Fill(i + 1);
    freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
    if (getDDUHisto(h::DDU_CSC_ERRORS, dduID, mo)) 
            mo->SetBinContent(i + 1, freq);
        }
        if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_ERRORS, mo)) {
          mo->Fill(dduID, i + 2);
        }
      }
    
      if((csc_warning_state >> i) & 0x1 ){
        if (getDDUHisto(h::DDU_CSC_WARNINGS_RATE, dduID, mo)) {
    mo->Fill(i + 1);
    freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
    if (getDDUHisto(h::DDU_CSC_WARNINGS, dduID, mo)) mo->SetBinContent(i + 1, freq);
        }
        if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_WARNINGS, mo)) {
          mo->Fill(dduID, i + 2);
        }
      }
    }
  
    if (getEMUHisto(h::EMU_ALL_DDUS_AVERAGE_LIVE_INPUTS, mo)) {
      mo->Fill(dduID, ddu_connected_inputs_cnt);
    }
 
   // if (dduEvtSize > 48) 
   {   
    if (getEMUHisto(h::EMU_ALL_DDUS_AVERAGE_INPUTS_WITH_DATA, mo)) {
      mo->Fill(dduID, dmb_dav_header_cnt);
    }
   }
  
    if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_ERRORS, mo)) {
      if (csc_error_state > 0) {
        mo->Fill(dduID, 1); // Any Input
      } else {
        mo->Fill(dduID, 0); // No errors
      }
    }
  
    if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_WARNINGS, mo)) {
      if (csc_warning_state > 0) {
        mo->Fill(dduID, 1); // Any Input
      } else { 
        mo->Fill(dduID, 0); // No errors
      }
    }
  
    if (getDDUHisto(h::DDU_DMB_DAV_HEADER_OCCUPANCY, dduID, mo)) mo->SetEntries(config->getNEvents());
    if (getDDUHisto(h::DDU_DMB_CONNECTED_INPUTS, dduID, mo)) mo->SetEntries(config->getNEvents());
    if (getDDUHisto(h::DDU_CSC_ERRORS, dduID, mo)) mo->SetEntries(config->getNEvents());
    if (getDDUHisto(h::DDU_CSC_WARNINGS, dduID, mo)) mo->SetEntries(config->getNEvents());
    if (getDDUHisto(h::DDU_DMB_ACTIVE_HEADER_COUNT, dduID, mo)) mo->Fill(dmb_active_header);
    if (getDDUHisto(h::DDU_DMB_DAV_HEADER_COUNT_VS_DMB_ACTIVE_HEADER_COUNT, dduID, mo)) 
      mo->Fill(dmb_active_header, dmb_dav_header_cnt);
  
    uint32_t trl_errorstat = dduTrailer.errorstat();
    if (dmb_dav_header_cnt == 0) trl_errorstat &= ~0x20000000; // Ignore No Good DMB CRC bit of no DMB is present
    for (int i = 0; i < 32; i++) {
      if ((trl_errorstat >> i) & 0x1) {
        if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_RATE, dduID, mo)) { 
    mo->Fill(i);
    double freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
    if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_FREQUENCY, dduID, mo)) 
            mo->SetBinContent(i+1, freq);
        }
        if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_TABLE, dduID, mo)) 
          mo->Fill(0.,i);
      }
    }
    if (getEMUHisto(h::EMU_ALL_DDUS_TRAILER_ERRORS, mo)) {
      if (trl_errorstat) {
        mo->Fill(dduID, 1); // Any Error
        for (int i = 0; i < 32; i++) {  
    if ((trl_errorstat >> i) & 0x1) {
      mo->Fill(dduID, i + 2);
    }
        }
      } else {
        mo->Fill(dduID, 0); // No Errors
      }
    }
    
    if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_TABLE, dduID, mo)) mo->SetEntries(config->getNEvents());
    if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_FREQUENCY, dduID, mo)) mo->SetEntries(config->getNEvents());
  

    uint32_t nCSCs = 0;

    if (config->getPROCESS_CSC()) { 

      std::vector<CSCEventData> chamberDatas;
      chamberDatas.clear();
      chamberDatas = dduData.cscData();
  
      nCSCs = chamberDatas.size();

      for(uint32_t i = 0; i < nCSCs; i++) {
        processCSC(chamberDatas[i], dduID, binChecker);
      }

    }
  
    if (getDDUHisto(h::DDU_DMB_UNPACKED_VS_DAV, dduID, mo)) mo->Fill(dmb_active_header, nCSCs);
  
    // fFirstEvent = false;

    fNotFirstEvent[dduID] = true;
  
  }
  
}