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);

  checkUros = ps.getUntrackedParameter<bool>("checkUros", false);

  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 FEDIDmax = FEDNumbering::MAXDTFEDID;
  int FEDIDmin = FEDNumbering::MINDTFEDID;
  if (checkUros) {
    FEDIDmin = FEDNumbering::MINDTUROSFEDID;
    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 + "_ROSStatus";
    if (checkUros)
      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_ROSSummary = nullptr;
    MonitorElement* FED_ROSSummary1 = nullptr;
    MonitorElement* FED_ROSSummary2 = nullptr;
    string fedSummaryName1 = "";
    string fedSummaryName2 = "";
    string sign = "-";
    if (checkUros) {
      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...
      }
    } else
      FED_ROSSummary = igetter.get(fedSummaryName);  //legacy case

    // 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");
    MonitorElement* hFEDFatal = igetter.get(fedIntegrityFolder + "FEDFatal");
    MonitorElement* hFEDNonFatal = igetter.get(fedIntegrityFolder + "FEDNonFatal");

    if (checkUros) {
      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
    } else {  //legacy case
      if (hFEDEntry && hFEDFatal && hFEDNonFatal) {
        if (FED_ROSSummary && FED_ROSStatus && FED_EvLength) {
          TH2F* histoFEDSummary = FED_ROSSummary->getTH2F();
          TH2F* histoROSStatus = FED_ROSStatus->getTH2F();
          TH1F* histoEvLength = FED_EvLength->getTH1F();
          // Check that the FED is in the ReadOut using the FEDIntegrity histos
          bool fedNotReadout =
              (hFEDEntry->getBinContent(dduId - 769) == 0 && hFEDFatal->getBinContent(dduId - 769) == 0 &&
               hFEDNonFatal->getBinContent(dduId - 769) == 0);

          int nFEDEvts = histoEvLength->Integral();
          for (int rosNumber = 1; rosNumber <= 12; ++rosNumber) {  // loop on the ROS
            int wheelNumber, sectorNumber;
            if (!readOutToGeometry(dduId, rosNumber, wheelNumber, sectorNumber)) {
              float nErrors = histoFEDSummary->Integral(1, 14, rosNumber, rosNumber);
              float nROBErrors = histoROSStatus->Integral(2, 8, rosNumber, rosNumber);
              nErrors += nROBErrors;
              float result = 0.;
              if (nFEDEvts != 0)
                result = max((float)0., ((float)nFEDEvts - nROBErrors) / (float)nFEDEvts);
              summaryHisto->setBinContent(sectorNumber, wheelNumber + 3, result);
              int tdcResult = -2;
              float nTDCErrors = histoFEDSummary->Integral(15, 15, rosNumber, rosNumber);
              if (nTDCErrors == 0) {  // no errors
                tdcResult = 0;
              } else {  // there are errors
                tdcResult = 2;
              }
              summaryTDCHisto->setBinContent(sectorNumber, wheelNumber + 3, tdcResult);
              // FIXME: different errors should have different weights
              float sectPerc = max((float)0., ((float)nFEDEvts - nErrors) / (float)nFEDEvts);
              glbSummaryHisto->setBinContent(sectorNumber, wheelNumber + 3, sectPerc);

              if (fedNotReadout) {
                // no data in this FED: it is off
                summaryHisto->setBinContent(sectorNumber, wheelNumber + 3, 0);
                summaryTDCHisto->setBinContent(sectorNumber, wheelNumber + 3, 1);
                glbSummaryHisto->setBinContent(sectorNumber, wheelNumber + 3, 0);
              }   //fedNotReadout
            }     //mapping
          }       //loop on ros
        } else {  // no data in this FED: it is off, no ROS suummary/status or evLength
          for (int rosNumber = 1; rosNumber <= 12; ++rosNumber) {
            int wheelNumber, sectorNumber;
            if (!readOutToGeometry(dduId, rosNumber, wheelNumber, sectorNumber)) {
              summaryHisto->setBinContent(sectorNumber, wheelNumber + 3, 0);
              summaryTDCHisto->setBinContent(sectorNumber, wheelNumber + 3, 1);
              glbSummaryHisto->setBinContent(sectorNumber, wheelNumber + 3, 0);
            }  //mapping
          }    //loop on ros
        }      // no data in this FED: it is off, no ROS suummary/status or evLength

      }  // no FED entry, fatal, nonfatal

    }  //legacy case

  }  //  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;
}

void DTDataIntegrityTest::bookHistos(DQMStore::IBooker& ibooker, string histoType, int dduId) {
  stringstream dduId_s;
  dduId_s << dduId;

  ibooker.setCurrentFolder("DT/00-DataIntegrity/FED" + dduId_s.str());
  string 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;
}