DTDataIntegrityTest.cc

Go to the documentation of this file.

/*
 * \file DTDataIntegrityTest.cc
 * 
 * \author S. Bolognesi - CERN
 *
 *  threadsafe version (//-) oct/nov 2014 - WATWanAbdullah ncpp-um-my
 *
 *
 */
 
#include <DQM/DTMonitorClient/src/DTDataIntegrityTest.h>
 
//Framework
#include "DataFormats/FEDRawData/interface/FEDNumbering.h"
#include "CondFormats/DTObjects/interface/DTReadOutMapping.h"
#include "CondFormats/DataRecord/interface/DTReadOutMappingRcd.h"
#include "DQMServices/Core/interface/DQMStore.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
#include <iostream>
#include <string>
 
using namespace std;
using namespace edm;
 
DTDataIntegrityTest::DTDataIntegrityTest(const ParameterSet& ps) : nevents(0) {
  LogTrace("DTDQM|DTRawToDigi|DTMonitorClient|DTDataIntegrityTest") << "[DTDataIntegrityTest]: Constructor";
 
  // prescale on the # of LS to update the test
  prescaleFactor = ps.getUntrackedParameter<int>("diagnosticPrescale", 1);
 
  bookingdone = false;
}
 
DTDataIntegrityTest::~DTDataIntegrityTest() {
  LogTrace("DTDQM|DTRawToDigi|DTMonitorClient|DTDataIntegrityTest")
      << "DataIntegrityTest: analyzed " << nupdates << " updates";
}
 
void DTDataIntegrityTest::dqmEndLuminosityBlock(DQMStore::IBooker& ibooker,
                                                DQMStore::IGetter& igetter,
                                                edm::LuminosityBlock const& lumiSeg,
                                                edm::EventSetup const& context) {
  if (!bookingdone) {
    //nSTAEvents = 0;
    nupdates = 0;
    run = 0;
 
    // book the summary histogram
 
    ibooker.setCurrentFolder("DT/00-DataIntegrity");
 
    summaryHisto = ibooker.book2D("DataIntegritySummary", "Summary Data Integrity", 12, 1, 13, 5, -2, 3);
    summaryHisto->setAxisTitle("Sector", 1);
    summaryHisto->setAxisTitle("Wheel", 2);
 
    ibooker.setCurrentFolder("DT/00-DataIntegrity");
 
    summaryTDCHisto = ibooker.book2D("DataIntegrityTDCSummary", "TDC Summary Data Integrity", 12, 1, 13, 5, -2, 3);
    summaryTDCHisto->setAxisTitle("Sector", 1);
    summaryTDCHisto->setAxisTitle("Wheel", 2);
 
    ibooker.setCurrentFolder("DT/00-DataIntegrity");
 
    glbSummaryHisto = ibooker.book2D("DataIntegrityGlbSummary", "Summary Data Integrity", 12, 1, 13, 5, -2, 3);
    glbSummaryHisto->setAxisTitle("Sector", 1);
    glbSummaryHisto->setAxisTitle("Wheel", 2);
 
    context.get<DTReadOutMappingRcd>().get(mapping);
  }  //booking
  bookingdone = true;
 
  // counts number of lumiSegs
  nLumiSegs = lumiSeg.id().luminosityBlock();
  string nLumiSegs_s = to_string(nLumiSegs);
 
  // prescale factor
  if (nLumiSegs % prescaleFactor != 0)
    return;
 
  LogTrace("DTDQM|DTRawToDigi|DTMonitorClient|DTDataIntegrityTest")
      << "[DTDataIntegrityTest]: End of LS " << nLumiSegs << ", performing client operations";
 
  // counts number of updats
  nupdates++;
 
  //Counter for x bin in the timing histos
  counter++;
 
  //Loop on FED id
  //Monitoring only real used FEDs
  int FEDIDmin = FEDNumbering::MINDTUROSFEDID;
  int FEDIDmax = FEDNumbering::MAXDTUROSFEDID;
 
  for (int dduId = FEDIDmin; dduId <= FEDIDmax; ++dduId) {
    LogTrace("DTDQM|DTRawToDigi|DTMonitorClient|DTDataIntegrityTest") << "[DTDataIntegrityTest]:FED Id: " << dduId;
 
    //Each nTimeBin onUpdate remove timing histos and book a new bunch of them
    string dduId_s = to_string(dduId);
 
    string histoType;
 
    //Check if the list of ROS is compatible with the channels enabled
    string rosStatusName = "DT/00-DataIntegrity/FED" + dduId_s + "/FED" + dduId_s + "_uROSStatus";
    MonitorElement* FED_ROSStatus = igetter.get(rosStatusName);
 
    // Get the error summary histo
    string fedSummaryName = "DT/00-DataIntegrity/FED" + dduId_s + "_ROSSummary";
    MonitorElement* FED_ROSSummary1 = nullptr;
    MonitorElement* FED_ROSSummary2 = nullptr;
    string fedSummaryName1 = "";
    string fedSummaryName2 = "";
    string sign = "-";
    if (dduId == FEDIDmin || dduId == FEDIDmax) {
      if (dduId == FEDIDmax)
        sign = "";
      fedSummaryName2 = "DT/00-DataIntegrity/ROSSummary_W" + sign + "2";
      fedSummaryName1 = "DT/00-DataIntegrity/ROSSummary_W" + sign + "1";
      FED_ROSSummary1 = igetter.get(fedSummaryName1);
      FED_ROSSummary2 = igetter.get(fedSummaryName2);
    } else {
      fedSummaryName = "DT/00-DataIntegrity/ROSSummary_W0";
      FED_ROSSummary1 = igetter.get(fedSummaryName);
      FED_ROSSummary2 = igetter.get(fedSummaryName);  //for wheel compatibility...
    }
 
    // Get the event length plot (used to count # of processed evts)
    string fedEvLenName = "DT/00-DataIntegrity/FED" + dduId_s + "/FED" + dduId_s + "_EventLength";
    MonitorElement* FED_EvLength = igetter.get(fedEvLenName);
 
    // Get the histos for FED integrity
    string fedIntegrityFolder = "DT/00-DataIntegrity/";
    MonitorElement* hFEDEntry = igetter.get(fedIntegrityFolder + "FEDEntries");
 
    if (hFEDEntry) {
      int offsetFED = 1368;
      // Check that the FED is in the ReadOut using the FEDIntegrity histos
      bool fedNotReadout = (hFEDEntry->getBinContent(dduId - offsetFED)) == 0;
      int wheel = dduId - offsetFED - 2;
      if (FED_ROSSummary1 && FED_ROSSummary2 && FED_ROSStatus && FED_EvLength && !fedNotReadout) {
        TH2F* histoFEDSummary1 = FED_ROSSummary1->getTH2F();
        TH2F* histoFEDSummary2 = FED_ROSSummary2->getTH2F();  // same for central FED...
        TH2F* histoROSStatus = FED_ROSStatus->getTH2F();
        TH1F* histoEvLength = FED_EvLength->getTH1F();
 
        int nFEDEvts = histoEvLength->Integral();
        //if(dduId==FEDIDmin || dduId==FEDIDmax) nFEDEvts = nFEDEvts/2.; // split in 2 for external FEDs
        if (!(nFEDEvts > 0))
          continue;
        int extraFEDevents1 = 0;
        int extraFEDevents2 = 0;
 
        for (int urosNumber = 1; urosNumber <= DOCESLOTS; ++urosNumber) {  // loop on the uROS
          string urosNumber_s = to_string(urosNumber);
          // Get the event length plot for this uROS (used to count # of processed evts)
          string fedUrosEvLenName = "DT/00-DataIntegrity/FED" + dduId_s + "/uROS" + urosNumber_s + "/FED" + dduId_s +
                                    "_uROS" + urosNumber_s + "_EventLength";
          MonitorElement* FED_uROS_EvLength = igetter.get(fedUrosEvLenName);
          TH1F* histoUrosEvLength = FED_uROS_EvLength->getTH1F();
          int nFEDEvtsUros = histoUrosEvLength->Integral();
 
          //station 4 sectors drievn by uROS 1 & 2
          if (urosNumber == 1) {
            extraFEDevents1 = nFEDEvtsUros;
            continue;
          }
          if (urosNumber == 2) {
            extraFEDevents2 = nFEDEvtsUros;
            continue;
          }
 
          if (nFEDEvtsUros > 0) {                                                      //this uROS is active
            nFEDEvtsUros = extraFEDevents1 + extraFEDevents2 + nFEDEvtsUros / 3.;      // split in 3 ROS
            float nGErrors = histoROSStatus->Integral(1, 12, urosNumber, urosNumber);  //Only Global Errors,
            //not possible to distinguish which ROS, so coumting them in the 3/12 ROSes
 
            int ros = getROS(urosNumber, 0);
            for (int iros = ros; iros < (ros + 3); ++iros) {
              // -1,0,+1 wheels
              float nROBErrors1 = histoFEDSummary1->Integral(1, 5, iros, iros);  //Errors and Not OK Flag
              float nErrors1 = nROBErrors1 + nGErrors;
              float result1 = 0.;
              if (nFEDEvtsUros != 0)
                result1 = max((float)0., ((float)nFEDEvtsUros - nROBErrors1) / (float)nFEDEvtsUros);
              summaryHisto->setBinContent(iros, wheel + 3, result1);
              double tdcResult1 = -2;
              float nTDCErrors1 = histoFEDSummary1->Integral(6, 6, iros, iros);  //Only TDC fatal considered
              if (nTDCErrors1 == 0) {                                            // no errors
                tdcResult1 = 0.5;
              } else {  // there are errors
                tdcResult1 = 2.5;
              }
              summaryTDCHisto->setBinContent(iros, wheel + 3, tdcResult1);
 
              // FIXME: different errors should have different weights
              float sectPerc1 = 0.;
              if (nFEDEvtsUros != 0)
                sectPerc1 = max((float)0., ((float)nFEDEvtsUros - nErrors1) / (float)nFEDEvtsUros);
              glbSummaryHisto->setBinContent(iros, wheel + 3, sectPerc1);
              if (dduId == (FEDIDmax - 1))
                continue;  //wheel 0 case
 
              // -2,+2 wheels
              float nROBErrors2 = histoFEDSummary2->Integral(1, 5, iros, iros);  //Errors and Not OK Flag
              float nErrors2 = nROBErrors2 + nGErrors;
              float result2 = 0.;
              if (nFEDEvtsUros != 0)
                result2 = max((float)0., ((float)nFEDEvtsUros - nROBErrors2) / (float)nFEDEvtsUros);
              summaryHisto->setBinContent(iros, wheel * 2 + 3, result2);
 
              double tdcResult2 = -2;
              float nTDCErrors2 = histoFEDSummary2->Integral(6, 6, iros, iros);  //Only TDC fatal considered
              if (nTDCErrors2 == 0) {                                            // no errors
                tdcResult2 = 0.5;
              } else {  // there are errors
                tdcResult2 = 2.5;
              }
              summaryTDCHisto->setBinContent(iros, wheel * 2 + 3, tdcResult2);
 
              // FIXME: different errors should have different weights
              float sectPerc2 = 0.;
              if (nFEDEvtsUros != 0)
                sectPerc2 = max((float)0., ((float)nFEDEvtsUros - nErrors2) / (float)nFEDEvtsUros);
              glbSummaryHisto->setBinContent(iros, wheel * 2 + 3, sectPerc2);
            }   //loop in three ros
          }     // this uROS is active
        }       //loop on uros
      } else {  // no data in this FED: it is off, no ROS suummary/status or evLength and fedNotReadout
        for (int i = 1; i <= DOCESLOTS; ++i) {
          summaryHisto->setBinContent(i, wheel + 3, 0.5);
          summaryTDCHisto->setBinContent(i, wheel + 3, 1.5);
          glbSummaryHisto->setBinContent(i, wheel + 3, 0.5);
          if (dduId == (FEDIDmax - 1))
            continue;  //wheel 0 case
          summaryHisto->setBinContent(i, wheel * 2 + 3, 0.5);
          summaryTDCHisto->setBinContent(i, wheel * 2 + 3, 1.5);
          glbSummaryHisto->setBinContent(i, wheel * 2 + 3, 0.5);
        }  //loop on uros
      }    // no data in this FED: it is off, no ROS suummary/status or evLength
 
    }  //FEDentry
 
  }  //  loop on dduIds
}
 
void DTDataIntegrityTest::dqmEndJob(DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter) {
  LogTrace("DTDQM|DTRawToDigi|DTMonitorClient|DTDataIntegrityTest") << "[DTDataIntegrityTest] endjob called!";
}
 
string DTDataIntegrityTest::getMEName(string histoType, int FEDId) {
  //Use the DDU name to find the ME
  stringstream dduID_s;
  dduID_s << FEDId;
 
  string folderName = "DT/00-DataIntegrity/FED" + dduID_s.str();
 
  string histoName = folderName + "/FED" + dduID_s.str() + "_" + histoType;
  return histoName;
}
 
int DTDataIntegrityTest::readOutToGeometry(int dduId, int ros, int& wheel, int& sector) {
  int dummy;
  return mapping->readOutToGeometry(dduId, ros, 2, 2, 2, wheel, dummy, sector, dummy, dummy, dummy);
}
 
int DTDataIntegrityTest::getROS(int uROS, int link) {
  int slot = 0;
  switch (uROS) {
    case 1: {
      slot = 5;
      break;
    }
    case 2: {
      slot = 11;
      break;
    }
    case 3: {
      slot = 1;
      break;
    }
    case 4: {
      slot = 7;
      break;
    }
    case 5: {
      slot = 2;
      break;
    }
    case 6: {
      slot = 8;
      break;
    }
    case 9: {
      slot = 9;
      break;
    }
    case 10: {
      slot = 3;
      break;
    }
    case 11: {
      slot = 10;
      break;
    }
    case 12: {
      slot = 4;
      break;
    }
  }
 
  if (slot % 6 == 5)
    return link + 1;
 
  int ros = (link / 24) + 3 * (slot % 6) - 2;
  return ros;
}