DTDataIntegrityTask.cc

Go to the documentation of this file.

/*
 * \file DTDataIntegrityTask.cc
 *
 * \author M. Zanetti (INFN Padova), S. Bolognesi (INFN Torino), G. Cerminara (INFN Torino)
 *
 */

#include "DQM/DTMonitorModule/interface/DTDataIntegrityTask.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/DTDigi/interface/DTControlData.h"
#include "DataFormats/DTDigi/interface/DTDDUWords.h"
#include "DQMServices/Core/interface/DQMStore.h"
#include "DQMServices/Core/interface/MonitorElement.h"
#include <DQM/DTMonitorModule/interface/DTTimeEvolutionHisto.h>
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "DataFormats/FEDRawData/interface/FEDNumbering.h"
#include "FWCore/Utilities/interface/Exception.h"

#include <cmath>
#include <fstream>
#include <map>
#include <string>
#include <vector>

using namespace std;
using namespace edm;

DTDataIntegrityTask::DTDataIntegrityTask(const edm::ParameterSet& ps) : nevents(0) {

  LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
  << "[DTDataIntegrityTask]: Constructor" <<endl;

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

  if (checkUros) {
    fedToken = consumes<DTuROSFEDDataCollection>(ps.getParameter<InputTag>("dtFEDlabel")); 
    FEDIDmin = FEDNumbering::MINDTUROSFEDID;
    FEDIDmax = FEDNumbering::MAXDTUROSFEDID;
    }
  else { dduToken = consumes<DTDDUCollection>(ps.getParameter<InputTag>("dtDDULabel"));
         ros25Token = consumes<DTROS25Collection>(ps.getParameter<InputTag>("dtROS25Label")); 
     FEDIDmin = FEDNumbering::MINDTFEDID;
     FEDIDmax = FEDNumbering::MAXDTFEDID;
    }

  neventsFED = 0;
  neventsuROS = 0;


//   If you want info VS time histos
//   doTimeHisto =  ps.getUntrackedParameter<bool>("doTimeHisto", false);
//   Plot quantities about SC
  getSCInfo = ps.getUntrackedParameter<bool>("getSCInfo", false);

  fedIntegrityFolder    = ps.getUntrackedParameter<string>("fedIntegrityFolder","DT/FEDIntegrity");

  string processingMode = ps.getUntrackedParameter<string>("processingMode","Online");

  // processing mode flag to select plots to be produced and basedirs CB vedi se farlo meglio...
  if (processingMode == "Online") {
    mode = 0;
  } else if(processingMode == "SM") {
    mode = 1;
  } else if (processingMode == "Offline") {
    mode = 2;
  } else if (processingMode == "HLT") {
    mode = 3;
  } else {
    throw cms::Exception("MissingParameter")
      << "[DTDataIntegrityTask]: processingMode :" << processingMode
      << " invalid! Must be Online, SM, Offline or HLT !" << endl;
  }

}


DTDataIntegrityTask::~DTDataIntegrityTask() {
  LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    <<"[DTDataIntegrityTask]: Destructor. Analyzed "<< neventsFED <<" events"<<endl;
  LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << "[DTDataIntegrityTask]: postEndJob called!" <<endl;
}

/*
  Folder Structure (ROS Legacy):
  - One folder for each DDU, named FEDn
  - Inside each DDU folder the DDU histos and the ROSn folder
  - Inside each ROS folder the ROS histos and the ROBn folder
  - Inside each ROB folder one occupancy plot and the TimeBoxes
  with the chosen granularity (simply change the histo name)
 
  uROS (starting 2018):
  - 3 uROS Summary plots: Wheel-1/-2 (FED1369), Wheel0 (FED1370), Wheel+1/+2 (FED1371)
  - One folder for each FED
  - Inside each FED folder the uROSStatus histos, FED histos
  - One folder for each wheel and the corresponding ROSn folders
  - Inside each ROS folder the TDC and ROS errors histos, 24 Links/plot
*/

void DTDataIntegrityTask::bookHistograms(DQMStore::IBooker & ibooker, edm::Run const & iRun, edm::EventSetup const & iSetup) {

  LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask") << "[DTDataIntegrityTask]: postBeginJob" <<endl;

  LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask") << "[DTDataIntegrityTask] Get DQMStore service" << endl;

  // Loop over the DT FEDs

  LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " FEDS: " << FEDIDmin  << " to " <<  FEDIDmax << " in the RO" << endl;

  // book FED integrity histos
  bookHistos(ibooker, FEDIDmin, FEDIDmax);

  if (checkUros){ //uROS starting on 2018
  // static booking of the histograms

  if(mode == 0 || mode ==2){
  for(int fed = FEDIDmin; fed <= FEDIDmax; ++fed) { // loop over the FEDs in the readout

    bookHistos(ibooker, string("FED"), fed);

    bookHistos(ibooker, string("CRATE"), fed);

    for(int uRos = 1; uRos <= NuROS; ++uRos) {// loop over all ROS
      bookHistosuROS(ibooker,fed,uRos);
    }
   }

    for (int wheel=-2;wheel<3;++wheel){
    for(int ros = 1; ros <= NuROS; ++ros) {// loop over all ROS
      bookHistosROS(ibooker,wheel,ros);
    }
   }

  } //Not in HLT or SM mode
  } //uROS
 
  else{ //Legacy ROS

  if(mode == 0 || mode ==2){
  // static booking of the histograms

  for(int fed = FEDIDmin; fed <= FEDIDmax; ++fed) { // loop over the FEDs in the readout
    DTROChainCoding code;
    code.setDDU(fed);
    bookHistos(ibooker, string("ROS_S"), code);

    bookHistos(ibooker, string("DDU"), code);

    for(int ros = 1; ros <= NuROS; ++ros) {// loop over all ROS
      code.setROS(ros);
      bookHistosROS25(ibooker, code);
    }
   }
  } //Not in HLT or SM mode
  } //Legacy ROS
}

void DTDataIntegrityTask::bookHistos(DQMStore::IBooker & ibooker, const int fedMin, const int fedMax) {

  ibooker.setCurrentFolder("DT/EventInfo/Counters");
  nEventMonitor = ibooker.bookFloat("nProcessedEventsDataIntegrity");

  // Standard FED integrity histos
  ibooker.setCurrentFolder(topFolder(true));

  int nFED = (fedMax - fedMin)+1;

  hFEDEntry = ibooker.book1D("FEDEntries","# entries per DT FED",nFED,fedMin,fedMax+1);
  
  if(checkUros){
  string histoType = "ROSSummary";
  for (int wheel=-2;wheel<3;++wheel){
    string wheel_s = to_string(wheel);
    string histoName = "ROSSummary_W"+wheel_s;
    string fed_s = to_string(FEDIDmin+1); //3 FEDs from 2018 onwards
    if(wheel<0) fed_s = to_string(FEDIDmin);
    else if(wheel>0) fed_s = to_string(FEDIDmax);
    string histoTitle = "Summary Wheel" + wheel_s + " (FED " + fed_s + ")";

    ((summaryHistos[histoType])[wheel]) = ibooker.book2D(histoName,histoTitle,11,0,11,12,1,13);
    MonitorElement *histo = ((summaryHistos[histoType])[wheel]);
    histo ->setBinLabel(1,"Error 1",1);
    histo ->setBinLabel(2,"Error 2",1);
    histo ->setBinLabel(3,"Error 3",1);
    histo ->setBinLabel(4,"Error 4",1);
    histo ->setBinLabel(5,"Not OKflag",1);
    // TDC error bins
    histo ->setBinLabel(6,"TDC Fatal",1);
    histo ->setBinLabel(7,"TDC RO FIFO ov.",1);
    histo ->setBinLabel(8,"TDC L1 buf. ov.",1);
    histo ->setBinLabel(9,"TDC L1A FIFO ov.",1);
    histo ->setBinLabel(10,"TDC hit err.",1);
    histo ->setBinLabel(11,"TDC hit rej.",1);

    histo ->setBinLabel(1,"ROS1",2);
    histo ->setBinLabel(2,"ROS2",2);
    histo ->setBinLabel(3,"ROS3",2);
    histo ->setBinLabel(4,"ROS4",2);
    histo ->setBinLabel(5,"ROS5",2);
    histo ->setBinLabel(6,"ROS6",2);
    histo ->setBinLabel(7,"ROS7",2);
    histo ->setBinLabel(8,"ROS8",2);
    histo ->setBinLabel(9,"ROS9",2);
    histo ->setBinLabel(10,"ROS10",2);
    histo ->setBinLabel(11,"ROS11",2);
    histo ->setBinLabel(12,"ROS12",2);
   }
  }

  else{ //if(!checkUros){
  hFEDFatal = ibooker.book1D("FEDFatal","# fatal errors DT FED",nFED,fedMin,fedMax+1);
  hFEDNonFatal = ibooker.book1D("FEDNonFatal","# NON fatal errors DT FED",nFED,fedMin,fedMax+1);

  if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

  ibooker.setCurrentFolder(topFolder(false));
  hTTSSummary = ibooker.book2D("TTSSummary","Summary Status TTS",nFED,fedMin,fedMax+1,9,1,10);
  hTTSSummary->setAxisTitle("FED",1);
  hTTSSummary->setBinLabel(1,"ROS PAF",2);
  hTTSSummary->setBinLabel(2,"DDU PAF",2);
  hTTSSummary->setBinLabel(3,"ROS PAF",2);
  hTTSSummary->setBinLabel(4,"DDU PAF",2);
  hTTSSummary->setBinLabel(5,"DDU Full",2);
  hTTSSummary->setBinLabel(6,"L1A Mism.",2);
  hTTSSummary->setBinLabel(7,"ROS Error",2);
  hTTSSummary->setBinLabel(8,"BX Mism.",2);
  hTTSSummary->setBinLabel(9,"DDU Logic Err.",2);

  // bookkeeping of the
  hCorruptionSummary =  ibooker.book2D("DataCorruptionSummary", "Data Corruption Sources",
                   nFED,fedMin,fedMax+1, 8, 1, 9);
  hCorruptionSummary->setAxisTitle("FED",1);
  hCorruptionSummary->setBinLabel(1,"Miss Ch.",2);
  hCorruptionSummary->setBinLabel(2,"ROS BX mism",2);
  hCorruptionSummary->setBinLabel(3,"DDU BX mism",2);
  hCorruptionSummary->setBinLabel(4,"ROS L1A mism",2);
  hCorruptionSummary->setBinLabel(5,"Miss Payload",2);
  hCorruptionSummary->setBinLabel(6,"FCRC bit",2);
  hCorruptionSummary->setBinLabel(7,"Header check",2);
  hCorruptionSummary->setBinLabel(8,"Trailer Check",2);
  } 
}

// ******************uROS******************** //
void DTDataIntegrityTask::bookHistos(DQMStore::IBooker & ibooker, string folder, const int fed){

  string wheel = "ZERO";
  if (fed ==FEDIDmin) wheel="NEG";
  else if(fed==FEDIDmax) wheel="POS";
  string fed_s = to_string(fed);
  LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " Booking histos for FED: " << fed_s
    << " folder: " << folder << endl;

  string histoType;
  string histoName;
  string histoTitle;
  MonitorElement* histo = nullptr;

  // Crate (old DDU) Histograms
  if (folder == "CRATE") {

    ibooker.setCurrentFolder(topFolder(false) + "FED" + fed_s);

    histoType = "EventLength";
    histoName = "FED" + fed_s + "_" + histoType;
    histoTitle = "Event Length (Bytes) FED " +  fed_s;
    (fedHistos[histoType])[fed] = ibooker.book1D(histoName,histoTitle,501,0,30000);

    if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF
 
    histoType = "uROSStatus";
    histoName = "FED" + fed_s + "_" + histoType;
    (fedHistos[histoType])[fed] = ibooker.book2D(histoName,histoName,12,0,12,12,1,13);
    histo = (fedHistos[histoType])[fed];
    // only placeholders for the moment
    histo->setBinLabel(1,"Error G 1",1);
    histo->setBinLabel(2,"Error G 2",1);
    histo->setBinLabel(3,"Error G 3",1);
    histo->setBinLabel(4,"Error G 4",1);
    histo->setBinLabel(5,"Error G 5",1);
    histo->setBinLabel(6,"Error G 6",1);
    histo->setBinLabel(7,"Error G 7",1);
    histo->setBinLabel(8,"Error G 8",1);
    histo->setBinLabel(9,"Error G 9",1);
    histo->setBinLabel(10,"Error G 10",1);
    histo->setBinLabel(11,"Error G 11",1);
    histo->setBinLabel(12,"Error G 12",1);

    histo->setBinLabel(1,"uROS 1",2);
    histo->setBinLabel(2,"uROS 2",2);
    histo->setBinLabel(3,"uROS 3",2);
    histo->setBinLabel(4,"uROS 4",2);
    histo->setBinLabel(5,"uROS 5",2);
    histo->setBinLabel(6,"uROS 6",2);
    histo->setBinLabel(7,"uROS 7",2);
    histo->setBinLabel(8,"uROS 8",2);
    histo->setBinLabel(9,"uROS 9",2);
    histo->setBinLabel(10,"uROS 10",2);
    histo->setBinLabel(11,"uROS 11",2);
    histo->setBinLabel(12,"uROS 12",2);
    
    if(mode > 0) return; //Info for Online only

    histoType = "FEDAvgEvLengthvsLumi";
    histoName = "FED" + fed_s + "_" + histoType;
    histoTitle = "Avg Event Length (Bytes) vs LumiSec FED " +  fed_s;
    (fedTimeHistos[histoType])[fed] = new DTTimeEvolutionHisto(ibooker,histoName,histoTitle,200,10,true,0);
    
    histoType = "TTSValues";
    histoName = "FED" + fed_s + "_" + histoType;
    (fedHistos[histoType])[fed] = ibooker.book1D(histoName,histoName,8,0,8);
    histo = (fedHistos[histoType])[fed];
    histo->setBinLabel(1,"Disconnected",1);
    histo->setBinLabel(2,"Overflow Warning ",1);
    histo->setBinLabel(3,"Out of synch",1);
    histo->setBinLabel(4,"Busy",1);
    histo->setBinLabel(5,"Ready",1);
    histo->setBinLabel(6,"Error",1);
    histo->setBinLabel(7,"Disconnected",1);
    histo->setBinLabel(8,"Unknown",1);

    histoType = "uROSList";
    histoName = "FED" + fed_s + "_" + histoType;
    histoTitle = "# of uROS in the FED payload (FED" + fed_s + ")";
    (fedHistos[histoType])[fed] = ibooker.book1D(histoName,histoTitle,13,0,13);

    histoType = "BXID";
    histoName = "FED" + fed_s + "_BXID";
    histoTitle = "Distrib. BX ID (FED" + fed_s + ")";
    (fedHistos[histoType])[fed] = ibooker.book1D(histoName,histoTitle,3600,0,3600);
    
  }

  // uROS Histograms
  if ( folder == "FED" ) { // The summary of the error of the ROS on the same FED
    ibooker.setCurrentFolder(topFolder(false));

    if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

    histoType = "uROSSummary";
    histoName = "FED" + fed_s + "_uROSSummary";
    string histoTitle = "Summary Wheel" + wheel + " (FED " + fed_s + ")";

    ((summaryHistos[histoType])[fed]) = ibooker.book2D(histoName,histoTitle,12,0,12,12,1,13);
    MonitorElement *histo = ((summaryHistos[histoType])[fed]);
    // ROS error bins
    // Placeholders for Global Errors for the moment
    histo ->setBinLabel(1,"Error G 1",1);
    histo ->setBinLabel(2,"Error G 2",1);
    histo ->setBinLabel(3,"Error G 3",1);
    histo ->setBinLabel(4,"Error G 4",1);
    histo ->setBinLabel(5,"Error G 5",1);
    histo ->setBinLabel(6,"Error G 6",1);
    histo ->setBinLabel(7,"Error G 7",1);
    histo ->setBinLabel(8,"Error G 8",1);
    histo ->setBinLabel(9,"Error G 9",1);
    histo ->setBinLabel(10,"Error G 10",1);
    histo ->setBinLabel(11,"Error G 11",1);
    histo ->setBinLabel(12,"Error G 12",1);

    histo ->setBinLabel(1,"uROS1",2);
    histo ->setBinLabel(2,"uROS2",2);
    histo ->setBinLabel(3,"uROS3",2);
    histo ->setBinLabel(4,"uROS4",2);
    histo ->setBinLabel(5,"uROS5",2);
    histo ->setBinLabel(6,"uROS6",2);
    histo ->setBinLabel(7,"uROS7",2);
    histo ->setBinLabel(8,"uROS8",2);
    histo ->setBinLabel(9,"uROS9",2);
    histo ->setBinLabel(10,"uROS10",2);
    histo ->setBinLabel(11,"uROS11",2);
    histo ->setBinLabel(12,"uROS12",2);


    
  }

}
// ******************End uROS******************** //


void DTDataIntegrityTask::bookHistos(DQMStore::IBooker & ibooker, string folder, DTROChainCoding code) {

  string dduID_s = to_string(code.getDDU());
  string rosID_s = to_string(code.getROS());
  string robID_s = to_string(code.getROB());
  int wheel = (code.getDDUID() - 770)%5 - 2;
  string wheel_s = to_string(wheel);

  LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " Booking histos for FED: " << code.getDDU() << " ROS: " << code.getROS()
    << " ROB: " << code.getROB() << " folder: " << folder << endl;

  string histoType;
  string histoName;
  string histoTitle;
  MonitorElement* histo = nullptr;

  // DDU Histograms
  if (folder == "DDU") {

    ibooker.setCurrentFolder(topFolder(false) + "FED" + dduID_s);

    histoType = "EventLength";
    histoName = "FED" + dduID_s + "_" + histoType;
    histoTitle = "Event Length (Bytes) FED " +  dduID_s;
    (fedHistos[histoType])[code.getDDUID()] = ibooker.book1D(histoName,histoTitle,501,0,16032);

    if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

    histoType = "ROSStatus";
    histoName = "FED" + dduID_s + "_" + histoType;
    (fedHistos[histoType])[code.getDDUID()] = ibooker.book2D(histoName,histoName,12,0,12,12,0,12);
    histo = (fedHistos[histoType])[code.getDDUID()];
    histo->setBinLabel(1,"ch.enabled",1);
    histo->setBinLabel(2,"timeout",1);
    histo->setBinLabel(3,"ev.trailer lost",1);
    histo->setBinLabel(4,"opt.fiber lost",1);
    histo->setBinLabel(5,"tlk.prop.error",1);
    histo->setBinLabel(6,"tlk.pattern error",1);
    histo->setBinLabel(7,"tlk.sign.lost",1);
    histo->setBinLabel(8,"error from ROS",1);
    histo->setBinLabel(9,"if ROS in events",1);
    histo->setBinLabel(10,"Miss. Evt.",1);
    histo->setBinLabel(11,"Evt. ID Mismatch",1);
    histo->setBinLabel(12,"BX Mismatch",1);

    histo->setBinLabel(1,"ROS 1",2);
    histo->setBinLabel(2,"ROS 2",2);
    histo->setBinLabel(3,"ROS 3",2);
    histo->setBinLabel(4,"ROS 4",2);
    histo->setBinLabel(5,"ROS 5",2);
    histo->setBinLabel(6,"ROS 6",2);
    histo->setBinLabel(7,"ROS 7",2);
    histo->setBinLabel(8,"ROS 8",2);
    histo->setBinLabel(9,"ROS 9",2);
    histo->setBinLabel(10,"ROS 10",2);
    histo->setBinLabel(11,"ROS 11",2);
    histo->setBinLabel(12,"ROS 12",2);

    if(mode > 0) return;  //Info for Online only

    histoType = "FEDAvgEvLengthvsLumi";
    histoName = "FED" + dduID_s + "_" + histoType;
    histoTitle = "Avg Event Length (Bytes) vs LumiSec FED " +  dduID_s;
    fedTimeHistos[histoType][code.getDDUID()] = new DTTimeEvolutionHisto(ibooker,histoName,histoTitle,200,10,true,0);

    histoType = "TTSValues";
    histoName = "FED" + dduID_s + "_" + histoType;
    (fedHistos[histoType])[code.getDDUID()] = ibooker.book1D(histoName,histoName,8,0,8);
    histo = (fedHistos[histoType])[code.getDDUID()];
    histo->setBinLabel(1,"disconnected",1);
    histo->setBinLabel(2,"warning overflow",1);
    histo->setBinLabel(3,"out of synch",1);
    histo->setBinLabel(4,"busy",1);
    histo->setBinLabel(5,"ready",1);
    histo->setBinLabel(6,"error",1);
    histo->setBinLabel(7,"disconnected",1);
    histo->setBinLabel(8,"unknown",1);

    histoType = "EventType";
    histoName = "FED" + dduID_s + "_" + histoType;
    (fedHistos[histoType])[code.getDDUID()] = ibooker.book1D(histoName,histoName,2,1,3);
    histo = (fedHistos[histoType])[code.getDDUID()];
    histo->setBinLabel(1,"physics",1);
    histo->setBinLabel(2,"calibration",1);

    histoType = "ROSList";
    histoName = "FED" + dduID_s + "_" + histoType;
    histoTitle = "# of ROS in the FED payload (FED" + dduID_s + ")";
    (fedHistos[histoType])[code.getDDUID()] = ibooker.book1D(histoName,histoTitle,13,0,13);

    histoType = "FIFOStatus";
    histoName = "FED" + dduID_s + "_" + histoType;
    (fedHistos[histoType])[code.getDDUID()] = ibooker.book2D(histoName,histoName,7,0,7,3,0,3);
    histo = (fedHistos[histoType])[code.getDDUID()];
    histo->setBinLabel(1,"Input ch1-4",1);
    histo->setBinLabel(2,"Input ch5-8",1);
    histo->setBinLabel(3,"Input ch9-12",1);
    histo->setBinLabel(4,"Error/L1A ch1-4",1);
    histo->setBinLabel(5,"Error/L1A ch5-8",1);
    histo->setBinLabel(6,"Error/L1A ch9-12",1);
    histo->setBinLabel(7,"Output",1);
    histo->setBinLabel(1,"Full",2);
    histo->setBinLabel(2,"Almost Full",2);
    histo->setBinLabel(3,"Not Full",2);

    histoType = "BXID";
    histoName = "FED" + dduID_s + "_BXID";
    histoTitle = "Distrib. BX ID (FED" + dduID_s + ")";
    (fedHistos[histoType])[code.getDDUID()] = ibooker.book1D(histoName,histoTitle,3600,0,3600);

  }

  // ROS Histograms
  if ( folder == "ROS_S" ) { // The summary of the error of the ROS on the same FED
    ibooker.setCurrentFolder(topFolder(false));

    if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

    histoType = "ROSSummary";
    histoName = "FED" + dduID_s + "_ROSSummary";
    string histoTitle = "Summary Wheel" + wheel_s + " (FED " + dduID_s + ")";

    ((summaryHistos[histoType])[code.getDDUID()]) = ibooker.book2D(histoName,histoTitle,20,0,20,12,1,13);
    MonitorElement *histo = ((summaryHistos[histoType])[code.getDDUID()]);
    // ROS error bins
    histo ->setBinLabel(1,"Link TimeOut",1);
    histo ->setBinLabel(2,"Ev.Id.Mis.",1);
    histo ->setBinLabel(3,"FIFO almost full",1);
    histo ->setBinLabel(4,"FIFO full",1);
    histo ->setBinLabel(5,"CEROS timeout",1);
    histo ->setBinLabel(6,"Max. wds",1);
    histo ->setBinLabel(7,"WO L1A FIFO",1);
    histo ->setBinLabel(8,"TDC parity err.",1);
    histo ->setBinLabel(9,"BX ID Mis.",1);
    histo ->setBinLabel(10,"TXP",1);
    histo ->setBinLabel(11,"L1A almost full",1);
    histo ->setBinLabel(12,"Ch. blocked",1);
    histo ->setBinLabel(13,"Ev. Id. Mis.",1);
    histo ->setBinLabel(14,"CEROS blocked",1);
    // TDC error bins
    histo ->setBinLabel(15,"TDC Fatal",1);
    histo ->setBinLabel(16,"TDC RO FIFO ov.",1);
    histo ->setBinLabel(17,"TDC L1 buf. ov.",1);
    histo ->setBinLabel(18,"TDC L1A FIFO ov.",1);
    histo ->setBinLabel(19,"TDC hit err.",1);
    histo ->setBinLabel(20,"TDC hit rej.",1);

    histo ->setBinLabel(1,"ROS1",2);
    histo ->setBinLabel(2,"ROS2",2);
    histo ->setBinLabel(3,"ROS3",2);
    histo ->setBinLabel(4,"ROS4",2);
    histo ->setBinLabel(5,"ROS5",2);
    histo ->setBinLabel(6,"ROS6",2);
    histo ->setBinLabel(7,"ROS7",2);
    histo ->setBinLabel(8,"ROS8",2);
    histo ->setBinLabel(9,"ROS9",2);
    histo ->setBinLabel(10,"ROS10",2);
    histo ->setBinLabel(11,"ROS11",2);
    histo ->setBinLabel(12,"ROS12",2);
  }

  if ( folder == "ROS" ) {
    ibooker.setCurrentFolder(topFolder(false) + "FED" + dduID_s + "/" + folder + rosID_s);

    if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

    histoType = "ROSError";
    histoName = "FED" + dduID_s + "_" + folder + rosID_s + "_ROSError";
    histoTitle = histoName + " (ROBID error summary)";
    if(mode < 1) //Online only
      (rosHistos[histoType])[code.getROSID()] = ibooker.book2D(histoName,histoTitle,17,0,17,26,0,26);
    else
      (rosHistos[histoType])[code.getROSID()] = ibooker.book2D(histoName,histoTitle,11,0,11,26,0,26);

    MonitorElement* histo = (rosHistos[histoType])[code.getROSID()];
    // ROS error bins
    histo->setBinLabel(1,"Link TimeOut",1);
    histo->setBinLabel(2,"Ev.Id.Mis.",1);
    histo->setBinLabel(3,"FIFO almost full",1);
    histo->setBinLabel(4,"FIFO full",1);
    histo->setBinLabel(5,"CEROS timeout",1);
    histo->setBinLabel(6,"Max. wds",1);
    histo->setBinLabel(7,"TDC parity err.",1);
    histo->setBinLabel(8,"BX ID Mis.",1);
    histo->setBinLabel(9,"Ch. blocked",1);
    histo->setBinLabel(10,"Ev. Id. Mis.",1);
    histo->setBinLabel(11,"CEROS blocked",1);
    if(mode < 1) { //Online only
      // TDC error bins
      histo->setBinLabel(12,"TDC Fatal",1);
      histo->setBinLabel(13,"TDC RO FIFO ov.",1);
      histo->setBinLabel(14,"TDC L1 buf. ov.",1);
      histo->setBinLabel(15,"TDC L1A FIFO ov.",1);
      histo->setBinLabel(16,"TDC hit err.",1);
      histo->setBinLabel(17,"TDC hit rej.",1);
    }
    histo->setBinLabel(1,"ROB0",2);
    histo->setBinLabel(2,"ROB1",2);
    histo->setBinLabel(3,"ROB2",2);
    histo->setBinLabel(4,"ROB3",2);
    histo->setBinLabel(5,"ROB4",2);
    histo->setBinLabel(6,"ROB5",2);
    histo->setBinLabel(7,"ROB6",2);
    histo->setBinLabel(8,"ROB7",2);
    histo->setBinLabel(9,"ROB8",2);
    histo->setBinLabel(10,"ROB9",2);
    histo->setBinLabel(11,"ROB10",2);
    histo->setBinLabel(12,"ROB11",2);
    histo->setBinLabel(13,"ROB12",2);
    histo->setBinLabel(14,"ROB13",2);
    histo->setBinLabel(15,"ROB14",2);
    histo->setBinLabel(16,"ROB15",2);
    histo->setBinLabel(17,"ROB16",2);
    histo->setBinLabel(18,"ROB17",2);
    histo->setBinLabel(19,"ROB18",2);
    histo->setBinLabel(20,"ROB19",2);
    histo->setBinLabel(21,"ROB20",2);
    histo->setBinLabel(22,"ROB21",2);
    histo->setBinLabel(23,"ROB22",2);
    histo->setBinLabel(24,"ROB23",2);
    histo->setBinLabel(25,"ROB24",2);
    histo->setBinLabel(26,"SC",2);

    if(mode > 1) return;

    histoType = "ROSEventLength";
    histoName = "FED" + dduID_s + "_" + folder + rosID_s + "_ROSEventLength";
    histoTitle = "Event Length (Bytes) FED " +  dduID_s + " ROS " + rosID_s;
    (rosHistos[histoType])[code.getROSID()] = ibooker.book1D(histoName,histoTitle,101,0,1616);

    histoType = "ROSAvgEventLengthvsLumi";
    histoName = "FED" + dduID_s + "_" + folder + rosID_s + histoType;
    histoTitle = "Event Length (Bytes) FED " +  dduID_s + " ROS " + rosID_s;
    rosTimeHistos[histoType][code.getROSID()] = new DTTimeEvolutionHisto(ibooker,histoName,histoTitle,200,10,true,0);

    histoType = "TDCError";
    histoName = "FED" + dduID_s + "_" + folder + rosID_s + "_TDCError";
    histoTitle = histoName + " (ROBID error summary)";
    (rosHistos[histoType])[code.getROSID()] = ibooker.book2D(histoName,histoTitle,24,0,24,25,0,25);
    histo = (rosHistos[histoType])[code.getROSID()];
    // TDC error bins
    histo->setBinLabel(1,"Fatal",1);
    histo->setBinLabel(2,"RO FIFO ov.",1);
    histo->setBinLabel(3,"L1 buf. ov.",1);
    histo->setBinLabel(4,"L1A FIFO ov.",1);
    histo->setBinLabel(5,"hit err.",1);
    histo->setBinLabel(6,"hit rej.",1);
    histo->setBinLabel(7,"Fatal",1);
    histo->setBinLabel(8,"RO FIFO ov.",1);
    histo->setBinLabel(9,"L1 buf. ov.",1);
    histo->setBinLabel(10,"L1A FIFO ov.",1);
    histo->setBinLabel(11,"hit err.",1);
    histo->setBinLabel(12,"hit rej.",1);
    histo->setBinLabel(13,"Fatal",1);
    histo->setBinLabel(14,"RO FIFO ov.",1);
    histo->setBinLabel(15,"L1 buf. ov.",1);
    histo->setBinLabel(16,"L1A FIFO ov.",1);
    histo->setBinLabel(17,"hit err.",1);
    histo->setBinLabel(18,"hit rej.",1);
    histo->setBinLabel(19,"Fatal",1);
    histo->setBinLabel(20,"RO FIFO ov.",1);
    histo->setBinLabel(21,"L1 buf. ov.",1);
    histo->setBinLabel(22,"L1A FIFO ov.",1);
    histo->setBinLabel(23,"hit err.",1);
    histo->setBinLabel(24,"hit rej.",1);

    histo->setBinLabel(1,"ROB0",2);
    histo->setBinLabel(2,"ROB1",2);
    histo->setBinLabel(3,"ROB2",2);
    histo->setBinLabel(4,"ROB3",2);
    histo->setBinLabel(5,"ROB4",2);
    histo->setBinLabel(6,"ROB5",2);
    histo->setBinLabel(7,"ROB6",2);
    histo->setBinLabel(8,"ROB7",2);
    histo->setBinLabel(9,"ROB8",2);
    histo->setBinLabel(10,"ROB9",2);
    histo->setBinLabel(11,"ROB10",2);
    histo->setBinLabel(12,"ROB11",2);
    histo->setBinLabel(13,"ROB12",2);
    histo->setBinLabel(14,"ROB13",2);
    histo->setBinLabel(15,"ROB14",2);
    histo->setBinLabel(16,"ROB15",2);
    histo->setBinLabel(17,"ROB16",2);
    histo->setBinLabel(18,"ROB17",2);
    histo->setBinLabel(19,"ROB18",2);
    histo->setBinLabel(20,"ROB19",2);
    histo->setBinLabel(21,"ROB20",2);
    histo->setBinLabel(22,"ROB21",2);
    histo->setBinLabel(23,"ROB22",2);
    histo->setBinLabel(24,"ROB23",2);
    histo->setBinLabel(25,"ROB24",2);

    histoType = "ROB_mean";
    histoName = "FED" + dduID_s + "_" + "ROS" + rosID_s + "_ROB_mean";
    string fullName = topFolder(false) + "FED" + dduID_s + "/" + folder + rosID_s+ "/" + histoName;
    names.insert (pair<std::string,std::string> (histoType,string(fullName)));
    (rosHistos[histoType])[code.getROSID()] = ibooker.book2D(histoName,histoName,25,0,25,100,0,100);
    (rosHistos[histoType])[code.getROSID()]->setAxisTitle("ROB #",1);
    (rosHistos[histoType])[code.getROSID()]->setAxisTitle("ROB wordcounts",2);

  }

  // SC Histograms
  if ( folder == "SC" ) {
    // The plots are per wheel
    ibooker.setCurrentFolder(topFolder(false) + "FED" + dduID_s);
    if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

    // SC data Size
    histoType = "SCSizeVsROSSize";
    histoName = "FED" + dduID_s + "_SCSizeVsROSSize";
    histoTitle = "SC size vs SC (FED " + dduID_s + ")";
    rosHistos[histoType][code.getSCID()] = ibooker.book2D(histoName,histoTitle,12,1,13,51,-1,50);
    rosHistos[histoType][code.getSCID()]->setAxisTitle("SC",1);

  }
}


void DTDataIntegrityTask::bookHistosROS25(DQMStore::IBooker & ibooker, DTROChainCoding code) {
  
  bookHistos(ibooker, string("ROS"), code);

    if(mode < 1)
      if(getSCInfo)
    bookHistos(ibooker, string("SC"), code);
}

// ******************uROS******************** //
void DTDataIntegrityTask::bookHistosROS(DQMStore::IBooker & ibooker, const int wheel, const int ros){
  string wheel_s = to_string(wheel);
  string ros_s = to_string(ros);
  ibooker.setCurrentFolder(topFolder(false) + "Wheel" + wheel_s + "/ROS" + ros_s);

    string histoType = "ROSError";
    int linkDown = 0; string linkDown_s = to_string(linkDown);
    int linkUp = linkDown+24;  string linkUp_s = to_string(linkUp);
    string histoName = "W" + wheel_s + "_" + "ROS" + ros_s + "_"+histoType;
    string histoTitle = histoName + " (Link " + linkDown_s +"-"+ linkUp_s + " error summary)";
    unsigned int keyHisto = (uROSError)*1000 + (wheel+2)*100 +(ros-1);
    if(mode < 1) // Online only
            urosHistos[keyHisto] = ibooker.book2D(histoName,histoTitle,11,0,11,25,0,25);
    else
            urosHistos[keyHisto] = ibooker.book2D(histoName,histoTitle,5,0,5,25,0,25);

    MonitorElement* histo = urosHistos[keyHisto];
    // uROS error bins
    // Placeholders for the moment
        histo->setBinLabel(1,"Error 1",1);
        histo->setBinLabel(2,"Error 2",1);
        histo->setBinLabel(3,"Error 3",1);
        histo->setBinLabel(4,"Error 4",1);
        histo->setBinLabel(5,"Not OKFlag",1);
        if(mode < 1) { //Online only
    // TDC error bins
        histo->setBinLabel(6,"TDC Fatal",1);
        histo->setBinLabel(7,"TDC RO FIFO ov.",1);
        histo->setBinLabel(8,"TDC L1 buf. ov.",1);
        histo->setBinLabel(9,"TDC L1A FIFO ov.",1);
        histo->setBinLabel(10,"TDC hit err.",1);
        histo->setBinLabel(11,"TDC hit rej.",1);
        }
    for (int link=linkDown; link < (linkUp+1); ++link){
            string link_s = to_string(link);
            histo->setBinLabel(link+1,"Link"+link_s,2);
    }
     


  if(mode > 1) return;

        histoType = "TDCError";
        linkDown = 0; linkDown_s = to_string(linkDown);
        linkUp = linkDown+24;  linkUp_s = to_string(linkUp);
        histoName = "W" + wheel_s + "_" + "ROS" + ros_s + "_"+histoType;
        histoTitle = histoName + " (Link " + linkDown_s +"-"+ linkUp_s + " error summary)";
    keyHisto = (TDCError)*1000 + (wheel+2)*100 + (ros-1); 
        urosHistos[keyHisto] = ibooker.book2D(histoName,histoTitle,24,0,24,25,0,25);
        histo = urosHistos[keyHisto];
    // TDC error bins
        histo->setBinLabel(1,"Fatal",1);
        histo->setBinLabel(2,"RO FIFO ov.",1);
        histo->setBinLabel(3,"L1 buf. ov.",1);
        histo->setBinLabel(4,"L1A FIFO ov.",1);
        histo->setBinLabel(5,"hit err.",1);
        histo->setBinLabel(6,"hit rej.",1);
        histo->setBinLabel(7,"Fatal",1);
        histo->setBinLabel(8,"RO FIFO ov.",1);
        histo->setBinLabel(9,"L1 buf. ov.",1);
        histo->setBinLabel(10,"L1A FIFO ov.",1);
        histo->setBinLabel(11,"hit err.",1);
        histo->setBinLabel(12,"hit rej.",1);
        histo->setBinLabel(13,"Fatal",1);
        histo->setBinLabel(14,"RO FIFO ov.",1);
        histo->setBinLabel(15,"L1 buf. ov.",1);
        histo->setBinLabel(16,"L1A FIFO ov.",1);
        histo->setBinLabel(17,"hit err.",1);
        histo->setBinLabel(18,"hit rej.",1);
        histo->setBinLabel(19,"Fatal",1);
        histo->setBinLabel(20,"RO FIFO ov.",1);
        histo->setBinLabel(21,"L1 buf. ov.",1);
        histo->setBinLabel(22,"L1A FIFO ov.",1);
        histo->setBinLabel(23,"hit err.",1);
        histo->setBinLabel(24,"hit rej.",1);

        for (int link=linkDown; link < (linkUp+1); ++link){
                string link_s = to_string(link);
                histo->setBinLabel(link+1,"Link"+link_s,2);
        }
} //bookHistosROS

void DTDataIntegrityTask::bookHistosuROS(DQMStore::IBooker & ibooker, const int fed, const int uRos){
  string fed_s = to_string(fed);
  string uRos_s = to_string(uRos);
  ibooker.setCurrentFolder(topFolder(false) + "FED" + fed_s + "/uROS" + uRos_s);

  if(mode > 1) return;

  string histoType = "uROSEventLength";
  string histoName = "FED" + fed_s + "_uROS" +  uRos_s + "_" + "EventLength";
  string histoTitle = "Event Length (Bytes) FED " +  fed_s + " uROS" + uRos_s;
  unsigned int keyHisto = (uROSEventLength)*1000 + (fed-FEDIDmin)*100 + (uRos-1);
  urosHistos[keyHisto] = ibooker.book1D(histoName,histoTitle,101,0,5000);

  histoType = "uROSAvgEventLengthvsLumi";
  histoName = "FED" + fed_s + "_ROS" +  uRos_s + "AvgEventLengthvsLumi";
  histoTitle = "Event Length (Bytes) FED " +  fed_s + " ROS" + uRos_s;
  keyHisto = (fed-FEDIDmin)*100 + (uRos-1);
  urosTimeHistos[keyHisto] = new DTTimeEvolutionHisto(ibooker,histoName,histoTitle,200,10,true,0);

  histoType = "TTSValues";
  histoName = "FED" + fed_s + "_" + "uROS" + uRos_s + "_" + histoType;
  keyHisto = TTSValues*1000 + (fed-FEDIDmin)*100 + (uRos-1);
  urosHistos[keyHisto] = ibooker.book1D(histoName,histoName,8,0,8);
  MonitorElement* histo = urosHistos[keyHisto];
  histo->setBinLabel(1,"Disconnected",1);
  histo->setBinLabel(2,"Overflow Warning ",1);
  histo->setBinLabel(3,"Out of synch",1);
  histo->setBinLabel(4,"Busy",1);
  histo->setBinLabel(5,"Ready",1);
  histo->setBinLabel(6,"Error",1);
  histo->setBinLabel(7,"Disconnected",1);
  histo->setBinLabel(8,"Unknown",1);

}
// ******************End uROS******************** //

// ******************uROS******************** //
void DTDataIntegrityTask::processuROS(DTuROSROSData & data, int fed, int uRos){

  neventsuROS++; // FIXME: implement a counter which makes sense

      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
        << "[DTDataIntegrityTask]: " << neventsuROS << " events analyzed by processuROS" << endl;

  if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

  MonitorElement* uROSSummary = nullptr;
  uROSSummary = summaryHistos["uROSSummary"][fed];

  MonitorElement* uROSStatus = nullptr;
  uROSStatus = fedHistos["uROSStatus"][fed];

  if(!uROSSummary) {
    LogError("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask") <<
        "Trying to access non existing ME at FED " << fed  <<
        std::endl;
    return;
  }

  unsigned int slotMap = ( data.getboardId() ) & 0xF;
  if (slotMap==0) return; //prevention for Simulation empty uROS data
  int ros = theROS(slotMap, 0); //first sector correspondign to link 0
  int ddu = theDDU(fed,  slotMap, 0, 0);
  int wheel = (ddu - 770)%5 - 2;
  MonitorElement* ROSSummary = nullptr;
  ROSSummary = summaryHistos["ROSSummary"][wheel];

  // Summary of all Link errors
  MonitorElement* uROSError0 = nullptr;
  MonitorElement* uROSError1 = nullptr;
  MonitorElement* uROSError2 = nullptr;

  int errorX[5][12]={{0}}; //5th is notOK flag

  if(mode <= 2){

  if(uRos>2){ //sectors 1-12

    uROSError0 = urosHistos[(uROSError)*1000 + (wheel+2)*100 + (ros-1)]; //links 0-23
    uROSError1 = urosHistos[(uROSError)*1000 + (wheel+2)*100 + (ros)];   //links 24-47
    uROSError2 = urosHistos[(uROSError)*1000 + (wheel+2)*100 + (ros+1)]; //links 48-71

    if ((!uROSError2) || (!uROSError1) || (!uROSError0) ) {
      LogError("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask") <<
        "Trying to access non existing ME at uROS " << uRos  << 
        std::endl;
     return;
    }

  // uROS errors
   for (unsigned int link = 0; link<72; ++link){
      for (unsigned int flag = 0; flag<5; ++flag){
    if((data.getokxflag(link)>>flag) & 0x1) { // Undefined Flag 1-4 64bits word for each MTP (12 channels)
        int value = flag;
        if (flag==0) value=5; //move it to the 5th bin
            
        if (value>0){  
                   if(link<24) {
                    errorX[value-1][ros-1]+=1;
                    uROSError0->Fill(value-1,link); //bins start at 0 despite labelin
                    }
                               else if(link<48) {
                    errorX[value-1][ros]+=1;
                    uROSError1->Fill(value-1,link-23);
                    }
                               else if(link<72) {
                    errorX[value-1][ros+1]+=1;
                    uROSError2->Fill(value-1,link-47);
                }
        }//value>0  
    }//flag value
      } //loop on flags
    } //loop on links
  } //uROS>2

  else{//uRos<3
    
     for (unsigned int link = 0; link<12; ++link){
      for (unsigned int flag = 0; flag<5; ++flag){
        if((data.getokxflag(link)>>flag) & 0x1) {// Undefined Flag 1-4 64bits word for each MTP (12 channels)
        int value = flag;
        int sc = 24;
                if (flag==0) value=5; //move it to the 5th bin
                        
        if (value>0){
            unsigned int keyHisto = (uROSError)*1000 + (wheel+2)*100 +link; //ros -1 = link in this case
            uROSError0 = urosHistos[keyHisto];
            if(!uROSError0) {
                    LogError("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask") <<
                    "Trying to access non existing ME at uROS " << uRos  <<
                    std::endl;
                    return;
            }   
            errorX[value-1][link]+=1; // ros-1=link in this case
            uROSError0->Fill(value-1,sc); //bins start at 0 despite labeling, this is the old SC
        }
    } //flag values
       } //loop on flags
      } //loop on links
  } //else uRos<3
        
  } //mode<=2

// Fill the ROSSummary (1 per wheel) histo
  for (unsigned int iros = 0; iros<12;++iros){
    for (unsigned int bin=0; bin<5;++bin){
            if(errorX[bin][iros]!=0) ROSSummary->Fill(bin, iros+1); //bins start at 1 
    }
  }

// Global Errors for uROS
   for (unsigned int flag = 4; flag<16; ++flag){
      if((data.getuserWord()>>flag) & 0x1 ) {
        uROSSummary->Fill(flag-4, uRos);
        uROSStatus->Fill(flag-4, uRos); //duplicated info?
    }
   }

  // ROS error
  for (unsigned int icounter = 0; icounter<data.geterrors().size(); ++icounter){
    int link = data.geterrorROBID(icounter);
    int tdc = data.geterrorTDCID(icounter);
    int error = data.geterror(icounter);
    int tdcError_ROSSummary = 0;
    int tdcError_ROSError = 0;
    int tdcError_TDCHisto = 0;

    if(error & 0x4000 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
        << " ROS " << uRos << " ROB " << link
        << " Internal fatal Error 4000 in TDC " << error << endl;

      tdcError_ROSSummary = 5;
      tdcError_ROSError   = 5;
      tdcError_TDCHisto   = 0;

    } else if ( error & 0x0249 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
        << " ROS " << uRos << " ROB " << link
        << " TDC FIFO overflow in TDC " << error << endl;

      tdcError_ROSSummary = 6;
      tdcError_ROSError   = 6;
      tdcError_TDCHisto   = 1;

    } else if ( error & 0x0492 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
        << " ROS " << uRos << " ROB " << link
        << " TDC L1 buffer overflow in TDC " << error << endl;

      tdcError_ROSSummary = 7;
      tdcError_ROSError   = 7;
      tdcError_TDCHisto   = 2;

    } else if ( error & 0x2000 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
        << " ROS " << uRos << " ROB " << link
        << " TDC L1A FIFO overflow in TDC " << error << endl;

      tdcError_ROSSummary = 8;
      tdcError_ROSError   = 8;
      tdcError_TDCHisto   = 3;

    } else if ( error & 0x0924 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
        << " uROS " << uRos << " ROB " << link
        << " TDC hit error in TDC " << error << endl;

      tdcError_ROSSummary = 9;
      tdcError_ROSError   = 9;
      tdcError_TDCHisto   = 4;

    } else if ( error & 0x1000 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
        << " uROS " << uRos << " ROB " << link
        << " TDC hit rejected in TDC " << error << endl;

      tdcError_ROSSummary = 10;
      tdcError_ROSError   = 10;
      tdcError_TDCHisto   = 5;

    } else {
      LogWarning("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
        << " TDC error code not known " << error << endl;
    }

   if (uRos<3){
      ROSSummary->Fill(tdcError_ROSSummary,link+1); //link 0 = ROS 1
      int sc = 24;
      if(mode<=2) {urosHistos[(uROSError)*1000 + (wheel+2)*100 + (link)]->Fill(tdcError_ROSError,sc);
         if(mode<=1) urosHistos[(TDCError)*1000 + (wheel+2)*100 + (link)]->Fill(tdcError_TDCHisto+6*(tdc-1),sc); // ros-1=link in this case
    }//mode<=2
   } //uRos<3
   else{//uRos>2
      if (link<24) ROSSummary->Fill(tdcError_ROSSummary,ros); 
      else if (link<48) ROSSummary->Fill(tdcError_ROSSummary,ros+1);
      else if (link<72) ROSSummary->Fill(tdcError_ROSSummary,ros+2);

      if(mode<=2){
        if (link<24)    uROSError0->Fill(tdcError_ROSError,link);
        else if (link<48)  uROSError1->Fill(tdcError_ROSError,link-23);
        else if (link<72)  uROSError2->Fill(tdcError_ROSError,link-47);
     
        if(mode<=1){
        if (link<24) urosHistos[(TDCError)*1000 + (wheel+2)*100 + (ros-1)]->Fill(tdcError_TDCHisto+6*(tdc-1),link);
        else if (link<48) urosHistos[(TDCError)*1000 + (wheel+2)*100 + (ros)]->Fill(tdcError_TDCHisto+6*(tdc-1),link-23);
        else if (link<72) urosHistos[(TDCError)*1000 + (wheel+2)*100 + (ros+1)]->Fill(tdcError_TDCHisto+6*(tdc-1),link-47);

        } //mode<=1
      } //mode<=2
   } //uROS>2
  } //loop on errors


  // 1D histograms for TTS values per uROS
  int ttsCodeValue = -1;

  int value = (data.getuserWord() & 0xF);
  switch(value) { 
  case 0:{ //disconnected
    ttsCodeValue = 0;
    break;
  }
  case 1:{ //warning overflow
    ttsCodeValue = 1;
    break;
  }
  case 2:{ //out of sinch
    ttsCodeValue = 2;
    break;
  }
  case 4:{ //busy
    ttsCodeValue = 3;
    break;
  }
  case 8:{ //ready
    ttsCodeValue = 4;
    break;
  }
  case 12:{ //error
    ttsCodeValue = 5;
    break;
  }
  case 15:{ //disconnected
    ttsCodeValue = 6;
    break;
  }
  default:{
    LogError("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
      <<"[DTDataIntegrityTask] FED User control: wrong TTS value "<< value << " in FED " << fed << " uROS "<< uRos<< endl; //FIXME
    ttsCodeValue = 7;
  }
  }
  if(mode < 1) {
    urosHistos[TTSValues*1000 + (fed-FEDIDmin)*100 + (uRos-1)]->Fill(ttsCodeValue);

     // Plot the event length //NOHLT
        int uRosEventLength = (data.gettrailer() & 0xFFFFF)*8;
              urosTimeHistos[(fed-FEDIDmin)*100 + (uRos-1)]->accumulateValueTimeSlot(uRosEventLength);
     
              if(uRosEventLength > 5000) uRosEventLength = 5000;
              urosHistos[uROSEventLength*1000 + (fed-FEDIDmin)*100 + (uRos-1)]->Fill(uRosEventLength);
  }                      

}

// *****************End uROS ******************//

void DTDataIntegrityTask::processROS25(DTROS25Data & data, int ddu, int ros) {

  neventsuROS++; // FIXME: implement a counter which makes sense

      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << "[DTDataIntegrityTask]: " << neventsuROS << " events analyzed by processROS25" << endl;

  // The ID of the RO board (used to map the histos)
  DTROChainCoding code;
  code.setDDU(ddu);
  code.setROS(ros);

  if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

  MonitorElement* ROSSummary = summaryHistos["ROSSummary"][code.getDDUID()];

  // Summary of all ROB errors
  MonitorElement* ROSError = nullptr;
  if(mode <= 2) ROSError = rosHistos["ROSError"][code.getROSID()];

  if ( (mode<=2) && (!ROSError) ) {
    LogError("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask") <<
    "Trying to access non existing ME at ROSID " << code.getROSID() <<
    std::endl;
    return;
  }

  // L1A ids to be checked against FED one
  rosL1AIdsPerFED[ddu].insert(data.getROSHeader().TTCEventCounter());

  // ROS errors


  // check for TPX errors
  if (data.getROSTrailer().TPX() != 0) {
    LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask") << " TXP error en ROS "
                                      << code.getROS() << endl;
    ROSSummary->Fill(9,code.getROS());
  }

  // L1 Buffer almost full (non-critical error!)
  if(data.getROSTrailer().l1AFifoOccupancy() > 31) {
     ROSSummary->Fill(10,code.getROS());
   }


  for (vector<DTROSErrorWord>::const_iterator error_it = data.getROSErrors().begin();
       error_it != data.getROSErrors().end(); error_it++) { // Loop over ROS error words

    LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask") << " Error in ROS " << code.getROS()
                                      << " ROB Id " << (*error_it).robID()
                                      << " Error type " << (*error_it).errorType() << endl;

    // Fill the ROSSummary (1 per FED) histo
    ROSSummary->Fill((*error_it).errorType(), code.getROS());
    if((*error_it).errorType() <= 11) { // set error flag
       eventErrorFlag = true;
    }

    if(mode <= 2) {
      // Fill the ROB Summary (1 per ROS) histo
      if ((*error_it).robID() != 31) {
    ROSError->Fill((*error_it).errorType(),(*error_it).robID());
      }
      else if ((*error_it).errorType() == 4) {
    vector<int> channelBins;
    channelsInROS((*error_it).cerosID(),channelBins);
    vector<int>::const_iterator channelIt  = channelBins.begin();
    vector<int>::const_iterator channelEnd = channelBins.end();
    for(;channelIt!=channelEnd;++channelIt) {
      ROSError->Fill(4,(*channelIt));
    }
      }
    }
  }


  int ROSDebug_BunchNumber = -1;

  for (vector<DTROSDebugWord>::const_iterator debug_it = data.getROSDebugs().begin();
       debug_it != data.getROSDebugs().end(); debug_it++) { // Loop over ROS debug words

    int debugROSSummary = 0;
    int debugROSError   = 0;
    vector<int> debugBins;
    bool hasEvIdMis = false;
    vector<int> evIdMisBins;

    if ((*debug_it).debugType() == 0 ) {
      ROSDebug_BunchNumber = (*debug_it).debugMessage();
    } else if ((*debug_it).debugType() == 1 ) {
      // not used
      // ROSDebug_BcntResCntLow = (*debug_it).debugMessage();
    } else if ((*debug_it).debugType() == 2 ) {
      // not used
      // ROSDebug_BcntResCntHigh = (*debug_it).debugMessage();
    } else if ((*debug_it).debugType() == 3) {
      if ((*debug_it).dontRead()){
    debugROSSummary = 11;
    debugROSError   = 8;
    if (mode <= 2) channelsInCEROS((*debug_it).cerosIdCerosStatus(),(*debug_it).dontRead(),debugBins);
      } if ((*debug_it).evIdMis()){
    hasEvIdMis = true;
    if (mode <= 2) channelsInCEROS((*debug_it).cerosIdCerosStatus(),(*debug_it).evIdMis(),evIdMisBins);
      }
    } else if ((*debug_it).debugType() == 4 &&
           (*debug_it).cerosIdRosStatus()){
      debugROSSummary = 13;
      debugROSError   = 10;
      if (mode <= 2) channelsInROS((*debug_it).cerosIdRosStatus(),debugBins);
    }

    if (debugROSSummary) {
      ROSSummary->Fill(debugROSSummary,code.getROS());
      if (mode <= 2) {
    vector<int>::const_iterator channelIt  = debugBins.begin();
    vector<int>::const_iterator channelEnd = debugBins.end();
    for (;channelIt!=channelEnd;++channelIt) {
      ROSError->Fill(debugROSError,(*channelIt));
    }
      }
    }

    if (hasEvIdMis) {
      ROSSummary->Fill(12,code.getROS());
      if (mode <= 2) {
    vector<int>::const_iterator channelIt  = evIdMisBins.begin();
    vector<int>::const_iterator channelEnd = evIdMisBins.end();
    for (;channelIt!=channelEnd;++channelIt) {
      ROSError->Fill(9,(*channelIt));
    }
      }
    }

  }

  // ROB Group Header
  // Check the BX of the ROB headers against the BX of the ROS
  for (vector<DTROBHeader>::const_iterator rob_it = data.getROBHeaders().begin();
       rob_it != data.getROBHeaders().end(); rob_it++) { // loop over ROB headers

    code.setROB((*rob_it).first);
    DTROBHeaderWord robheader = (*rob_it).second;

    rosBxIdsPerFED[ddu].insert(ROSDebug_BunchNumber);

    if (robheader.bunchID() != ROSDebug_BunchNumber) {
      // fill ROS Summary plot
      ROSSummary->Fill(8,code.getROS());
      eventErrorFlag = true;

      // fill ROB Summary plot for that particular ROS
      if(mode <= 2) ROSError->Fill(7,robheader.robID());
    }
  }


  if(mode < 1) { // produce only when not in HLT or SM
    // ROB Trailer
    for (vector<DTROBTrailerWord>::const_iterator robt_it = data.getROBTrailers().begin();
     robt_it != data.getROBTrailers().end(); robt_it++) { // loop over ROB trailers
      float  wCount = (*robt_it).wordCount()<100. ? (*robt_it).wordCount() : 99.9;
      rosHistos["ROB_mean"][code.getROSID()]->Fill((*robt_it).robID(),wCount);
    }

    // Plot the event length //NOHLT
    int rosEventLength = data.getROSTrailer().EventWordCount()*4;
    rosTimeHistos["ROSAvgEventLengthvsLumi"][code.getROSID()]->accumulateValueTimeSlot(rosEventLength);

    if(rosEventLength > 1600) rosEventLength = 1600;
    rosHistos["ROSEventLength"][code.getROSID()]->Fill(rosEventLength);
  }


  // TDC Data
  for (vector<DTTDCData>::const_iterator tdc_it = data.getTDCData().begin();
       tdc_it != data.getTDCData().end(); tdc_it++) { // loop over TDC data

    DTTDCMeasurementWord tdcDatum = (*tdc_it).second;

    if ( tdcDatum.PC() !=0)  {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " PC error in ROS " << code.getROS() << " TDC " << (*tdc_it).first << endl;
      //     fill ROS Summary plot
      ROSSummary->Fill(7,code.getROS());

      eventErrorFlag = true;

      // fill ROB Summary plot for that particular ROS
      if(mode <= 2) ROSError->Fill(6,(*tdc_it).first);
    }
  }

  // TDC Error
  for (vector<DTTDCError>::const_iterator tdc_it = data.getTDCError().begin();
       tdc_it != data.getTDCError().end(); tdc_it++) { // loop over TDC errors

    code.setROB((*tdc_it).first);

    int tdcError_ROSSummary = 0;
    int tdcError_ROSError = 0;
    int tdcError_TDCHisto = 0;

    if(((*tdc_it).second).tdcError() & 0x4000 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " ROS " << code.getROS() << " ROB " << code.getROB()
    << " Internal fatal Error 4000 in TDC " << (*tdc_it).first << endl;

      tdcError_ROSSummary = 14;
      tdcError_ROSError   = 11;
      tdcError_TDCHisto   = 0;

    } else if ( ((*tdc_it).second).tdcError() & 0x0249 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " ROS " << code.getROS() << " ROB " << code.getROB()
    << " TDC FIFO overflow in TDC " << (*tdc_it).first << endl;

      tdcError_ROSSummary = 15;
      tdcError_ROSError   = 12;
      tdcError_TDCHisto   = 1;

    } else if ( ((*tdc_it).second).tdcError() & 0x0492 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " ROS " << code.getROS() << " ROB " << code.getROB()
    << " TDC L1 buffer overflow in TDC " << (*tdc_it).first << endl;

      tdcError_ROSSummary = 16;
      tdcError_ROSError   = 13;
      tdcError_TDCHisto   = 2;

    } else if ( ((*tdc_it).second).tdcError() & 0x2000 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " ROS " << code.getROS() << " ROB " << code.getROB()
    << " TDC L1A FIFO overflow in TDC " << (*tdc_it).first << endl;

      tdcError_ROSSummary = 17;
      tdcError_ROSError   = 14;
      tdcError_TDCHisto   = 3;

    } else if ( ((*tdc_it).second).tdcError() & 0x0924 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " ROS " << code.getROS() << " ROB " << code.getROB()
    << " TDC hit error in TDC " << (*tdc_it).first << endl;

      tdcError_ROSSummary = 18;
      tdcError_ROSError   = 15;
      tdcError_TDCHisto   = 4;

    } else if ( ((*tdc_it).second).tdcError() & 0x1000 ) {
      LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " ROS " << code.getROS() << " ROB " << code.getROB()
    << " TDC hit rejected in TDC " << (*tdc_it).first << endl;

      tdcError_ROSSummary = 19;
      tdcError_ROSError   = 16;
      tdcError_TDCHisto   = 5;

    } else {
      LogWarning("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
    << " TDC error code not known " << ((*tdc_it).second).tdcError() << endl;
    }

    ROSSummary->Fill(tdcError_ROSSummary,code.getROS());

    if(tdcError_ROSSummary <= 15) {
      eventErrorFlag = true;
    }

    if(mode <= 2) {
      ROSError->Fill(tdcError_ROSError,(*tdc_it).first);
      if(mode <= 1)
    rosHistos["TDCError"][code.getROSID()]->Fill(tdcError_TDCHisto+6*((*tdc_it).second).tdcID(),(*tdc_it).first);
    }
  }

  // Read SC data
  if (mode < 1 && getSCInfo) {
    // NumberOf16bitWords counts the # of words + 1 subheader
    // the SC includes the SC "private header" and the ROS header and trailer (= NumberOf16bitWords +3)
    rosHistos["SCSizeVsROSSize"][code.getSCID()]->Fill(ros,data.getSCTrailer().wordCount());

  }
}

// ******************uROS******************** //
void DTDataIntegrityTask::processFED(DTuROSFEDData  & data, int fed){

  neventsFED++;
  if (neventsFED%1000 == 0)
    LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
      << "[DTDataIntegrityTask]: " << neventsFED << " events analyzed by processFED" << endl;

  if(fed < FEDIDmin || fed > FEDIDmax) return;

  hFEDEntry->Fill(fed);

  if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

  //1D HISTOS: EVENT LENGHT from trailer
  int fedEvtLength = data.getevtlgth()*8;  //1 word = 8 bytes
  //   if(fedEvtLength > 16000) fedEvtLength = 16000; // overflow bin
  fedHistos["EventLength"][fed]->Fill(fedEvtLength);

  if(mode > 1) return;

  fedTimeHistos["FEDAvgEvLengthvsLumi"][fed]->accumulateValueTimeSlot(fedEvtLength);

  // fill the distribution of the BX ids
  fedHistos["BXID"][fed]->Fill(data.getBXId()); 

 // size of the list of ROS in the Read-Out
  fedHistos["uROSList"][fed]->Fill(data.getnslots());

  // Fill the status summary of the TTS
  
  //1D HISTO WITH TTS VALUES form trailer (7 bins = 7 values)
     
  int ttsCodeValue = -1;
  int value = data.getTTS();
  switch(value) {
  case 0:{ //disconnected
    ttsCodeValue = 0;
    break;
  }
  case 1:{ //warning overflow
    ttsCodeValue = 1;
    break;
  }
  case 2:{ //out of sinch
    ttsCodeValue = 2;
    break;
  }
  case 4:{ //busy
    ttsCodeValue = 3;
    break;
  }
  case 8:{ //ready
    ttsCodeValue = 4;
    break;
  }
  case 12:{ //error
    ttsCodeValue = 5;
    break;
  }
  case 15:{ //disconnected
    ttsCodeValue = 6;
    break;
  }
  default:{
    LogError("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
      <<"[DTDataIntegrityTask] FED TTS control: wrong TTS value "<< value << " in FED "<< fed<< endl;
    ttsCodeValue = 7;
  }
  }
  if(mode < 1) fedHistos["TTSValues"][fed]->Fill(ttsCodeValue);
 
}
// *****************End uROS ******************//


void DTDataIntegrityTask::processFED(DTDDUData & data, const std::vector<DTROS25Data> & rosData, int ddu) {

  neventsFED++;
  if (neventsFED%1000 == 0)
    LogTrace("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
      << "[DTDataIntegrityTask]: " << neventsFED << " events analyzed by processFED" << endl;


  DTROChainCoding code;
  code.setDDU(ddu);
  if(code.getDDUID() < FEDIDmin || code.getDDUID() > FEDIDmax) return;

  hFEDEntry->Fill(code.getDDUID());

  FEDTrailer trailer = data.getDDUTrailer();
  FEDHeader header = data.getDDUHeader();

  // check consistency of header and trailer
  if(!header.check()) {
    // error code 7
    hFEDFatal->Fill(code.getDDUID());
    hCorruptionSummary->Fill(code.getDDUID(), 7);
  }

  if(!trailer.check()) {
    // error code 8
    hFEDFatal->Fill(code.getDDUID());
    hCorruptionSummary->Fill(code.getDDUID(), 8);
  }

  // check CRC error bit set by DAQ before sending data on SLink
  if(data.crcErrorBit()) {
    // error code 6
    hFEDFatal->Fill(code.getDDUID());
    hCorruptionSummary->Fill(code.getDDUID(), 6);
  }

  if(mode == 3 || mode ==1) return; //Avoid duplication of Info in FEDIntegrity_EvF

  const DTDDUSecondStatusWord& secondWord = data.getSecondStatusWord();

  // Fill the status summary of the TTS

  //1D HISTO WITH TTS VALUES form trailer (7 bins = 7 values)
  int ttsCodeValue = -1;
  int ttsSummaryBin = -1;

  switch(trailer.ttsBits()) {
  case 0:{ //disconnected
    ttsCodeValue = 0;
    break;
  }
  case 1:{ //warning overflow
    ttsCodeValue = 1;
    if(secondWord.warningROSPAF()) { // ROS PAF
      ttsSummaryBin = 1;
    } else { // DDU PAF
      ttsSummaryBin = 2;
    }

    break;
  }
  case 2:{ //out of sinch
    ttsCodeValue = 2;
    bool knownOrigin = false;
    if(secondWord.outOfSynchROSError()) {// ROS Error
      ttsSummaryBin = 7;
      knownOrigin = true;
    }
    if(secondWord.l1AIDError()) {// L1A Mism.
      ttsSummaryBin = 6;
      knownOrigin = true;
    }
    if(secondWord.bxIDError()) {// BX Mism.
      ttsSummaryBin = 8;
      knownOrigin = true;
    }
    if(secondWord.outputFifoFull() || secondWord.inputFifoFull() || secondWord.fifoFull()) { // DDU Full
      ttsSummaryBin = 5;
      knownOrigin = true;
    }
    if(!knownOrigin) ttsSummaryBin = 9; // Error in DDU logic

    break;
  }
  case 4:{ //busy
    ttsCodeValue = 3;
    bool knownOrigin = false;
    if(secondWord.busyROSPAF()) { // ROS PAF
      ttsSummaryBin = 3;
      knownOrigin = true;
    }
    if(secondWord.outputFifoAlmostFull() || secondWord.inputFifoAlmostFull() || secondWord.fifoAlmostFull() ){ // DDU PAF
      ttsSummaryBin = 4;
      knownOrigin = true;
    }
    if(!knownOrigin) ttsSummaryBin = 9; // Error in DDU logic
    break;
  }
  case 8:{ //ready
    ttsCodeValue = 4;
    break;
  }
  case 12:{ //error
    ttsCodeValue = 5;
    break;
  }
  case 16:{ //disconnected
    ttsCodeValue = 6;
    break;
  }
  default:{
    LogError("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
      <<"[DTDataIntegrityTask] DDU control: wrong TTS value "<<trailer.ttsBits()<<endl;
    ttsCodeValue = 7;
  }
  }
  if(mode < 1) fedHistos["TTSValues"][code.getDDUID()]->Fill(ttsCodeValue);
  if(ttsSummaryBin != -1) {
    hTTSSummary->Fill(ddu, ttsSummaryBin);
  }


  //2D HISTO: ROS VS STATUS (8 BIT = 8 BIN) from 1st-2nd status words (9th BIN FROM LIST OF ROS in 2nd status word)
  MonitorElement* hROSStatus = fedHistos["ROSStatus"][code.getDDUID()];
  //1D HISTO: NUMBER OF ROS IN THE EVENTS from 2nd status word

  int rosList = secondWord.rosList();
  set<int> rosPositions;
  for(int i=0;i<12;i++) {
    if(rosList & 0x1) {
      rosPositions.insert(i);
      //9th BIN FROM LIST OF ROS in 2nd status word
      if(mode <= 2) hROSStatus->Fill(8,i,1);
    }
    rosList >>= 1;
  }

  int channel=0;
  for (vector<DTDDUFirstStatusWord>::const_iterator fsw_it = data.getFirstStatusWord().begin();
       fsw_it != data.getFirstStatusWord().end(); fsw_it++) {
    // assuming association one-to-one between DDU channel and ROS
    if(mode <= 2) {
      hROSStatus->Fill(0,channel,(*fsw_it).channelEnabled());
      hROSStatus->Fill(1,channel,(*fsw_it).timeout());
      hROSStatus->Fill(2,channel,(*fsw_it).eventTrailerLost());
      hROSStatus->Fill(3,channel,(*fsw_it).opticalFiberSignalLost());
      hROSStatus->Fill(4,channel,(*fsw_it).tlkPropagationError());
      hROSStatus->Fill(5,channel,(*fsw_it).tlkPatternError());
      hROSStatus->Fill(6,channel,(*fsw_it).tlkSignalLost());
      hROSStatus->Fill(7,channel,(*fsw_it).errorFromROS());
    }
    // check that the enabled channel was also in the read-out
    if((*fsw_it).channelEnabled() == 1 &&
       rosPositions.find(channel) == rosPositions.end()) {
      if(mode <= 2) hROSStatus->Fill(9,channel,1);
      // error code 1
      hFEDFatal->Fill(code.getDDUID());
      hCorruptionSummary->Fill(code.getDDUID(), 1);
    }
    channel++;
  }


  // ---------------------------------------------------------------------
  // cross checks between FED and ROS data
  // check the BX ID against the ROSs
  set<int> rosBXIds = rosBxIdsPerFED[ddu];
  if((rosBXIds.size() > 1 || rosBXIds.find(header.bxID()) == rosBXIds.end()) && !rosBXIds.empty() ) { // in this case look for faulty ROSs
    for(vector<DTROS25Data>::const_iterator rosControlData = rosData.begin();
    rosControlData != rosData.end(); ++rosControlData) { // loop over the ROS data
      for (vector<DTROSDebugWord>::const_iterator debug_it = (*rosControlData).getROSDebugs().begin();
       debug_it != (*rosControlData).getROSDebugs().end(); debug_it++) { // Loop over ROS debug words
    if ((*debug_it).debugType() == 0 && (*debug_it).debugMessage() != header.bxID()) { // check the BX
      int ros = (*rosControlData).getROSID();
      // fill the error bin
      if(mode <= 2) hROSStatus->Fill(11,ros-1);
      // error code 2
      hFEDFatal->Fill(code.getDDUID());
      hCorruptionSummary->Fill(code.getDDUID(), 2);
    }
      }
    }
  }

  // check the BX ID against other FEDs
  fedBXIds.insert(header.bxID());
  if(fedBXIds.size() != 1) {
    LogWarning("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask")
      << "ERROR: FED " << ddu << " BX ID different from other feds: " << header.bxID() << endl;
    // error code 3
    hFEDFatal->Fill(code.getDDUID());
    hCorruptionSummary->Fill(code.getDDUID(), 3);
  }


  // check the L1A ID against the ROSs
  set<int> rosL1AIds = rosL1AIdsPerFED[ddu];
  if((rosL1AIds.size() > 1 || rosL1AIds.find(header.lvl1ID()-1) == rosL1AIds.end()) && !rosL1AIds.empty() ){ // in this case look for faulty ROSs
    //If L1A_ID error identify which ROS has wrong L1A
    for (vector<DTROS25Data>::const_iterator rosControlData = rosData.begin();
     rosControlData != rosData.end(); rosControlData++) { // loop over the ROS data
      unsigned int ROSHeader_TTCCount = ((*rosControlData).getROSHeader().TTCEventCounter() + 1) % 0x1000000; // fix comparison in case of last counting bin in ROS /first one in DDU
      if( ROSHeader_TTCCount != header.lvl1ID() ) {
    int ros = (*rosControlData).getROSID();
    if(mode <= 2) hROSStatus->Fill(10,ros-1);
    // error code 4
    hFEDFatal->Fill(code.getDDUID());
    hCorruptionSummary->Fill(code.getDDUID(), 4);
      }
    }
  }

  //1D HISTOS: EVENT LENGHT from trailer
  int fedEvtLength = trailer.fragmentLength()*8;
  //   if(fedEvtLength > 16000) fedEvtLength = 16000; // overflow bin
  fedHistos["EventLength"][code.getDDUID()]->Fill(fedEvtLength);

  if(mode > 1) return;

  fedTimeHistos["FEDAvgEvLengthvsLumi"][code.getDDUID()]->accumulateValueTimeSlot(fedEvtLength);

  // size of the list of ROS in the Read-Out
  fedHistos["ROSList"][code.getDDUID()]->Fill(rosPositions.size());


  //2D HISTO: FIFO STATUS from 2nd status word
  MonitorElement *hFIFOStatus = fedHistos["FIFOStatus"][code.getDDUID()];
  int inputFifoFull = secondWord.inputFifoFull();
  int inputFifoAlmostFull = secondWord.inputFifoAlmostFull();
  int fifoFull = secondWord.fifoFull();
  int fifoAlmostFull = secondWord.fifoAlmostFull();
  int outputFifoFull = secondWord.outputFifoFull();
  int outputFifoAlmostFull = secondWord.outputFifoAlmostFull();
  for(int i=0;i<3;i++){
    if(inputFifoFull & 0x1){
      hFIFOStatus->Fill(i,0);
    }
    if(inputFifoAlmostFull & 0x1){
      hFIFOStatus->Fill(i,1);
    }
    if(fifoFull & 0x1){
      hFIFOStatus->Fill(3+i,0);
    }
    if(fifoAlmostFull & 0x1){
      hFIFOStatus->Fill(3+i,1);
    }
    if(!(inputFifoFull & 0x1) && !(inputFifoAlmostFull & 0x1)){
      hFIFOStatus->Fill(i,2);
    }
    if(!(fifoFull & 0x1) && !(fifoAlmostFull & 0x1)){
      hFIFOStatus->Fill(3+i,2);
    }
    inputFifoFull >>= 1;
    inputFifoAlmostFull >>= 1;
    fifoFull >>= 1;
    fifoAlmostFull >>= 1;
  }

  if(outputFifoFull){
    hFIFOStatus->Fill(6,0);
  }
  if(outputFifoAlmostFull){
    hFIFOStatus->Fill(6,1);
  }
  if(!outputFifoFull && !outputFifoAlmostFull){
    hFIFOStatus->Fill(6,2);
  }

  //1D HISTO: EVENT TYPE from header
  fedHistos["EventType"][code.getDDUID()]->Fill(header.triggerType());

  // fill the distribution of the BX ids
  fedHistos["BXID"][code.getDDUID()]->Fill(header.bxID());

}

bool DTDataIntegrityTask::eventHasErrors() const {
  return eventErrorFlag;
}


// log number of times the payload of each fed is unpacked
void DTDataIntegrityTask::fedEntry(int dduID) {
  hFEDEntry->Fill(dduID);
}



// log number of times the payload of each fed is skipped (no ROS inside)
void DTDataIntegrityTask::fedFatal(int dduID) {
  hFEDFatal->Fill(dduID);
}



// log number of times the payload of each fed is partially skipped (some ROS skipped)
void DTDataIntegrityTask::fedNonFatal(int dduID) {
  hFEDNonFatal->Fill(dduID);
}

std::string DTDataIntegrityTask::topFolder(bool isFEDIntegrity) const {

  string folder = isFEDIntegrity ? fedIntegrityFolder : "DT/00-DataIntegrity/";

  if (mode == 0 || mode == 2)
    folder = "DT/00-DataIntegrity/"; //Move everything from FEDIntegrity except for SM and HLT modes

  return folder;

}

void DTDataIntegrityTask::channelsInCEROS(int cerosId, int chMask, vector<int>& channels ){
  for (int iCh=0; iCh<6;++iCh) {
    if ((chMask >> iCh) & 0x1){
      channels.push_back(cerosId*6+iCh);
    }
  }
  return;
}

void DTDataIntegrityTask::channelsInROS(int cerosMask, vector<int>& channels){
  for (int iCeros=0; iCeros<5;++iCeros) {
    if ((cerosMask >> iCeros) & 0x1){
      for (int iCh=0; iCh<6;++iCh) {
    channels.push_back(iCeros*6+iCh);
      }
    }
  }
  return;
}

void DTDataIntegrityTask::beginLuminosityBlock(const edm::LuminosityBlock& ls, const edm::EventSetup& es) {

  nEventsLS = 0;

}

void DTDataIntegrityTask::endLuminosityBlock(const edm::LuminosityBlock& ls, const edm::EventSetup& es) {

  int lumiBlock = ls.luminosityBlock();

  if (checkUros){
  map<string, map<int, DTTimeEvolutionHisto*> >::iterator fedIt  = fedTimeHistos.begin();
  map<string, map<int, DTTimeEvolutionHisto*> >::iterator fedEnd = fedTimeHistos.end();
  for(; fedIt!=fedEnd; ++fedIt) {
    map<int, DTTimeEvolutionHisto*>::iterator histoIt  = fedIt->second.begin();
    map<int, DTTimeEvolutionHisto*>::iterator histoEnd = fedIt->second.end();
    for(; histoIt!=histoEnd; ++histoIt) {
      histoIt->second->updateTimeSlot(lumiBlock,nEventsLS);
    }
  }

  map<unsigned int, DTTimeEvolutionHisto*>::iterator urosIt  = urosTimeHistos.begin();
  map<unsigned int, DTTimeEvolutionHisto*>::iterator urosEnd = urosTimeHistos.end();
  for(; urosIt!=urosEnd; ++urosIt) {
        urosIt->second->updateTimeSlot(lumiBlock,nEventsLS);
  }

  }//uROS starting on 2018
  else{
  map<string, map<int, DTTimeEvolutionHisto*> >::iterator dduIt  = fedTimeHistos.begin();
  map<string, map<int, DTTimeEvolutionHisto*> >::iterator dduEnd = fedTimeHistos.end();
  for(; dduIt!=dduEnd; ++dduIt) {
    map<int, DTTimeEvolutionHisto*>::iterator histoIt  = dduIt->second.begin();
    map<int, DTTimeEvolutionHisto*>::iterator histoEnd = dduIt->second.end();
    for(; histoIt!=histoEnd; ++histoIt) {
      histoIt->second->updateTimeSlot(lumiBlock,nEventsLS);
    }
  }

  map<string, map<int, DTTimeEvolutionHisto*> >::iterator rosIt  = rosTimeHistos.begin();
  map<string, map<int, DTTimeEvolutionHisto*> >::iterator rosEnd = rosTimeHistos.end();
  for(; rosIt!=rosEnd; ++rosIt) {
    map<int, DTTimeEvolutionHisto*>::iterator histoIt  = rosIt->second.begin();
    map<int, DTTimeEvolutionHisto*>::iterator histoEnd = rosIt->second.end();
    for(; histoIt!=histoEnd; ++histoIt) {
      histoIt->second->updateTimeSlot(lumiBlock,nEventsLS);
    }
  }
  }//ROS Legacy
}

void DTDataIntegrityTask::analyze(const edm::Event& e, const edm::EventSetup& c)
{
  nevents++;
  nEventMonitor->Fill(nevents);

  nEventsLS++;

  LogTrace("DTRawToDigi|TDQM|DTMonitorModule|DTDataIntegrityTask") << "[DTDataIntegrityTask]: preProcessEvent" <<endl;

  if (checkUros){ //uROS starting on 2018
  // Digi collection
  edm::Handle<DTuROSFEDDataCollection> fedCol;
  e.getByToken(fedToken, fedCol);
  DTuROSFEDData fedData;
  DTuROSROSData urosData;

  if(fedCol.isValid()){
    for(unsigned int j=0; j <fedCol->size();++j){
    fedData = fedCol->at(j);
    int fed = fedData.getfed(); //argument should be void
    if (fed>FEDIDmax || fed<FEDIDmin) {
    LogError("DTRawToDigi|DTDQM|DTMonitorModule|DTDataIntegrityTask") << "[DTDataIntegrityTask]: analyze, FED ID " << fed <<" not expected."  << endl;
    continue;
    }
    processFED(fedData, fed);
    
    for(int slot=1; slot<=DOCESLOTS; ++slot)
    {
        urosData = fedData.getuROS(slot);
    if(fedData.getslotsize(slot)==0 || urosData.getslot()==-1) continue;
        processuROS(urosData,fed,slot);
      }
    }
  }
  } // checkUros
  else{ //Legacy ROS
  // clear the set of BXids from the ROSs
  for(map<int, set<int> >::iterator rosBxIds = rosBxIdsPerFED.begin(); rosBxIds != rosBxIdsPerFED.end(); ++rosBxIds) {
    (*rosBxIds).second.clear();
  }

  fedBXIds.clear();

  for(map<int, set<int> >::iterator rosL1AIds = rosL1AIdsPerFED.begin(); rosL1AIds != rosL1AIdsPerFED.end(); ++rosL1AIds) {
    (*rosL1AIds).second.clear();
  }

  // reset the error flag
  eventErrorFlag = false;

  // Digi collection
  edm::Handle<DTDDUCollection> dduProduct;
  e.getByToken(dduToken, dduProduct);
  edm::Handle<DTROS25Collection> ros25Product;
  e.getByToken(ros25Token, ros25Product);

  DTDDUData dduData;
  std::vector<DTROS25Data> ros25Data;
  if(dduProduct.isValid() && ros25Product.isValid()) {
    for(unsigned int i=0; i<dduProduct->size(); ++i)
    {
      dduData = dduProduct->at(i);
      ros25Data = ros25Product->at(i);
      // FIXME: passing id variable is not needed anymore - change processFED interface for next release!
      FEDHeader header = dduData.getDDUHeader();
      int id = header.sourceID();
      if (id>FEDIDmax || id<FEDIDmin) continue; //SIM uses extra FEDs not monitored

      processFED(dduData, ros25Data, id);
      for(unsigned int j=0; j < ros25Data.size(); ++j) {
        int rosid = j+1;
        processROS25(ros25Data[j],id,rosid);
      }
    }
  }
  }

}

// Conversions
int DTDataIntegrityTask::theDDU(int crate, int slot, int link, bool tenDDU) {

  int ros = theROS(slot,link);

  int ddu = 772;
  //if (crate == 1368) { ddu = 775; }
  //Needed just in case this FED should be used due to fibers length

  if (crate == FEDNumbering::MINDTUROSFEDID) {
    if (slot < 7)
      ddu = 770;
    else
      ddu = 771;
  }

  if (crate == (FEDNumbering::MINDTUROSFEDID+1)) { ddu = 772; }

  if (crate == FEDNumbering::MAXDTUROSFEDID) {
    if (slot < 7)
      ddu = 773;
    else
      ddu = 774;
  }

  if (ros > 6 && tenDDU && ddu < 775)
    ddu += 5;

  return ddu;
}

int DTDataIntegrityTask::theROS(int slot, int link) {

  if (slot%6 == 5) return link+1;

  int ros = (link/24) + 3*(slot%6) - 2;
  return ros;
}

  

// Local Variables:
// show-trailing-whitespace: t
// truncate-lines: t
// End: