Project CMSSW displayed by LXR CMSSW_15_0_X_2024-12-08-2300/​EventFilter/​SiPixelRawToDigi/​test/​SiPixelRawDumper.cc	Source navigation Diff markup Identifier search General search
	Version: CMSSW_15_0_X_2024-12-08-2300 CMSSW_15_0_X_2024-12-06-2300 CMSSW_15_0_X_2024-12-05-2300 CMSSW_15_0_X_2024-12-04-2300 CMSSW_15_0_X_2024-12-03-2300 CMSSW_15_0_X_2024-12-02-2300 Revert   Change

File indexing completed on 2024-04-06 12:11:01

 /** \class SiPixelRawDumper_H
  *  Plug-in module that dump raw data file 
  *  for pixel subdetector
  *  Added class to interpret the data d.k. 30/10/08
  *  Add histograms. Add pix 0 detection.
  * Works with v7x, comment out the digis access.
  */
 
 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 
 #include "DataFormats/Common/interface/Handle.h"
 
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
 #include "DataFormats/FEDRawData/interface/FEDRawData.h"
 
 #include "DataFormats/FEDRawData/interface/FEDNumbering.h"
 
 #include "EventFilter/SiPixelRawToDigi/interface/PixelDataFormatter.h"
 
 // For L1  NOT IN RAW
 //#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtUtils.h"
 //#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetupFwd.h"
 //#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetup.h"
 //#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
 //#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMapRecord.h"
 
 // For luminisoty NOT IN RAW
 //#include "FWCore/Framework/interface/LuminosityBlock.h"
 //#include "DataFormats/Luminosity/interface/LumiSummary.h"
 //#include "DataFormats/Common/interface/ConditionsInEdm.h"
 
 // To use root histos
 #include "FWCore/ServiceRegistry/interface/Service.h"
 #include "CommonTools/UtilAlgos/interface/TFileService.h"
 
 // For ROOT
 #include <TROOT.h>
 //#include <TChain.h>
 #include <TFile.h>
 #include <TF1.h>
 #include <TH2F.h>
 #include <TH1D.h>
 #include <TProfile.h>
 #include <TProfile2D.h>
 
 #include <iostream>
 #include <fstream>
 
 using namespace std;
 
 // #define L1  // L1 information not in RAW
 //#define OUTFILE
 
 namespace {
   bool printErrors = true;
   bool printData = false;
   bool printHeaders = false;
   const bool CHECK_PIXELS = true;
   const bool PRINT_BASELINE = false;
   // to store the previous pixel
   int fed0 = -1, chan0 = -1, roc0 = -1, dcol0 = -1, pix0 = -1, count0 = -1;
   int countDecodeErrors1 = 0, countDecodeErrors2 = 0;
 }  // namespace
 
 // Include the helper decoding class
 /////////////////////////////////////////////////////////////////////////////
 class MyDecode {
 public:
   MyDecode() {}
   ~MyDecode() {}
   static int error(int error, int &fedChannel, int fed, int &stat1, int &stat2, bool print = false);
   static int data(int error, int &fedChannel, int fed, int &stat1, int &stat2, bool print = false);
   static int header(unsigned long long word64, int fed, bool print, unsigned int &bx);
   static int trailer(unsigned long long word64, int fed, bool print);
   static int convertToCol(int dcol, int pix);
   static int convertToRow(int pix);
   static int checkLayerLink(int fed, int chan);
 
 private:
 };
 /////////////////////////////////////////////////////////////////////////////
 //Returns 1,2,3 for layer 1,2,3 full modules, 11,12,13 for 1/2 modules
 // 0 for fpix
 // needs fedid 0-31, and channel 1-36.
 int MyDecode::checkLayerLink(int fed, int chan) {
   int layer = 0;
   if (fed < 0 || fed > 31)
     return layer;  // return 0 for invalid of fpix
 
   if (chan > 24) {  // layer 3
 
     if (fed == 0 || fed == 8) {  // Type A
 
       if (chan == 28 || chan == 34 || chan == 35 || chan == 36)
         layer = 13;  // 1/2 module
       else
         layer = 3;
 
     } else if (fed == 23 || fed == 31) {  // Type A
 
       if (chan == 27 || chan == 31 || chan == 32 || chan == 33)
         layer = 13;  // 1/2 module
       else
         layer = 3;
 
     } else if (fed == 7 || fed == 15 || fed == 16 || fed == 24) {  // Type D
 
       if (chan == 25 || chan == 26 || chan == 29 || chan == 30)
         layer = 13;
       else
         layer = 3;
 
     } else {
       layer = 3;
     }
 
     return layer;  // layer 3
 
   } else if ((chan >= 13 && chan <= 19) || chan == 24) {
     return 2;  //layer 2
 
   } else {
     if (fed == 0 || fed == 8 || fed == 16 || fed == 24) {  // Type A   WRONG AFTER FIBER SWAP
 
       if (chan == 5 || chan == 6 || chan == 22 || chan == 23)
         layer = 12;  // 1/2 module
       else if (chan == 4 || chan == 10 || chan == 11 || chan == 12)
         layer = 11;  // 1/2 module
       else
         layer = 1;
 
     } else if (fed == 7 || fed == 15 || fed == 23 || fed == 31) {  // Type D
 
       if (chan == 1 || chan == 2 || chan == 20 || chan == 21)
         layer = 12;  // 1/2
       else if (chan == 3 || chan == 7 || chan == 8 || chan == 9)
         layer = 11;  // 1/2
       else
         layer = 1;
 
     } else if (fed == 1 || fed == 2 || fed == 3 || fed == 9 || fed == 10 || fed == 11 || fed == 17 || fed == 18 ||
                fed == 19 || fed == 25 || fed == 26 || fed == 27) {  // Type B
 
       if ((chan >= 4 && chan <= 6) || (chan >= 10 && chan <= 12) || (chan >= 22 && chan <= 23))
         layer = 2;
       else
         layer = 1;
 
     } else if (fed == 4 || fed == 5 || fed == 6 || fed == 12 || fed == 13 || fed == 14 || fed == 20 || fed == 21 ||
                fed == 22 || fed == 28 || fed == 29 || fed == 30) {  // Type C
 
       if ((chan >= 1 && chan <= 3) || (chan >= 7 && chan <= 9) || (chan >= 20 && chan <= 21))
         layer = 2;
       else
         layer = 1;
 
     } else {
       cout << "unknown fed " << fed << endl;
     }  // if fed
 
     return layer;
 
   }  // if chan
 }
 
 int MyDecode::convertToCol(int dcol, int pix) {
   // First find if we are in the first or 2nd col of a dcol.
   int colEvenOdd = pix % 2;  // module(2), 0-1st sol, 1-2nd col.
   // Transform
   return (dcol * 2 + colEvenOdd);  // col address, starts from 0
 }
 int MyDecode::convertToRow(int pix) {
   return abs(int(pix / 2) - 80);  // row addres, starts from 0
 }
 
 int MyDecode::header(unsigned long long word64, int fed, bool print, unsigned int &bx) {
   int fed_id = (word64 >> 8) & 0xfff;
   int event_id = (word64 >> 32) & 0xffffff;
   bx = (word64 >> 20) & 0xfff;
   //   if(bx!=101) {
   //     cout<<" Header "<<" for FED "
   //    <<fed_id<<" event "<<event_id<<" bx "<<bx<<endl;
   //     int dummy=0;
   //     cout<<" : ";
   //     cin>>dummy;
   //   }
   if (print)
     cout << "Header "
          << " for FED " << fed_id << " event " << event_id << " bx " << bx << endl;
   fed0 = -1;  // reset the previous hit fed id
   return event_id;
 }
 //
 int MyDecode::trailer(unsigned long long word64, int fed, bool print) {
   int slinkLength = int((word64 >> 32) & 0xffffff);
   int crc = int((word64 & 0xffff0000) >> 16);
   int tts = int((word64 & 0xf0) >> 4);
   int slinkError = int((word64 & 0xf00) >> 8);
   if (print)
     cout << "Trailer "
          << " len " << slinkLength << " tts " << tts << " error " << slinkError << " crc " << hex << crc << dec << endl;
   return slinkLength;
 }
 //
 // Decode error FIFO
 // Works for both, the error FIFO and the SLink error words. d.k. 25/04/07
 int MyDecode::error(int word, int &fedChannel, int fed, int &stat1, int &stat2, bool print) {
   int status = -1;
   print = print || printErrors;
 
   const unsigned int errorMask = 0x3e00000;
   const unsigned int dummyMask = 0x03600000;
   const unsigned int gapMask = 0x03400000;
   const unsigned int timeOut = 0x3a00000;
   const unsigned int eventNumError = 0x3e00000;
   const unsigned int trailError = 0x3c00000;
   const unsigned int fifoError = 0x3800000;
 
   //  const unsigned int  timeOutChannelMask = 0x1f;  // channel mask for timeouts
   //const unsigned int  eventNumMask = 0x1fe000; // event number mask
   const unsigned int channelMask = 0xfc000000;  // channel num mask
   const unsigned int tbmEventMask = 0xff;       // tbm event num mask
   const unsigned int overflowMask = 0x100;      // data overflow
   const unsigned int tbmStatusMask = 0xff;      //TBM trailer info
   const unsigned int BlkNumMask = 0x700;        //pointer to error fifo #
   const unsigned int FsmErrMask = 0x600;        //pointer to FSM errors
   const unsigned int RocErrMask = 0x800;        //pointer to #Roc errors
   const unsigned int ChnFifMask = 0x1f;         //channel mask for fifo error
   const unsigned int Fif2NFMask = 0x40;         //mask for fifo2 NF
   const unsigned int TrigNFMask = 0x80;         //mask for trigger fifo NF
 
   const int offsets[8] = {0, 4, 9, 13, 18, 22, 27, 31};
   unsigned int channel = 0;
 
   //cout<<"error word "<<hex<<word<<dec<<endl;
 
   if ((word & errorMask) == dummyMask) {  // DUMMY WORD
     //cout<<" Dummy word";
     return 0;
 
   } else if ((word & errorMask) == gapMask) {  // GAP WORD
     //cout<<" Gap word";
     return 0;
 
   } else if ((word & errorMask) == timeOut) {  // TIMEOUT
 
     unsigned int bit20 = (word & 0x100000) >> 20;  // works only for slink format
 
     if (bit20 == 0) {  // 2nd word
 
       unsigned int timeoutCnt = (word & 0x7f800) >> 11;  // only for slink
       // unsigned int timeoutCnt = ((word&0xfc000000)>>24) + ((word&0x1800)>>11); // only for fifo
       // More than 1 channel within a group can have a timeout error
       // More than 1 channel within a group can have a timeout error
 
       unsigned int index = (word & 0x1F);  // index within a group of 4/5
       unsigned int chip = (word & BlkNumMask) >> 8;
       int offset = offsets[chip];
       if (print)
         cout << "Timeout Error- channel: ";
       //cout<<"Timeout Error- channel: ";
       for (int i = 0; i < 5; i++) {
         if ((index & 0x1) != 0) {
           channel = offset + i + 1;
           if (print)
             cout << channel << " ";
           //cout<<channel<<" ";
         }
         index = index >> 1;
       }
 
       if (print)
         cout << " TimeoutCount: " << timeoutCnt;
       //cout << " TimeoutCount: " << timeoutCnt<<endl;;
 
       //if(print) cout<<" for Fed "<<fed<<endl;
       status = -10;
       fedChannel = channel;
       //end of timeout  chip and channel decoding
 
     } else {  // this is the 1st timout word with the baseline correction
 
       int baselineCorr = 0;
       if (word & 0x200) {
         baselineCorr = -(((~word) & 0x1ff) + 1);
       } else {
         baselineCorr = (word & 0x1ff);
       }
 
       if (PRINT_BASELINE && print)
         cout << "Timeout BaselineCorr: " << baselineCorr << endl;
       //cout<<"Timeout BaselineCorr: "<<baselineCorr<<endl;
       status = 0;
     }
 
   } else if ((word & errorMask) == eventNumError) {  // EVENT NUMBER ERROR
     channel = (word & channelMask) >> 26;
     unsigned int tbm_event = (word & tbmEventMask);
 
     if (print)
       cout << " Event Number Error- channel: " << channel << " tbm event nr. " << tbm_event << " ";
     status = -11;
     fedChannel = channel;
 
   } else if (((word & errorMask) == trailError)) {  // TRAILER
     channel = (word & channelMask) >> 26;
     unsigned int tbm_status = (word & tbmStatusMask);
 
     if (tbm_status != 0) {
       if (print)
         cout << " Trailer Error- "
              << "channel: " << channel << " TBM status:0x" << hex << tbm_status << dec << " ";  // <<endl;
       status = -15;
       // implement the resync/reset 17
     }
 
     if (word & RocErrMask) {
       if (print)
         cout << "Number of Rocs Error- "
              << "channel: " << channel << " ";  // <<endl;
       status = -12;
     }
 
     if (word & overflowMask) {
       if (print)
         cout << "Overflow Error- "
              << "channel: " << channel << " ";  // <<endl;
       status = -14;
     }
 
     if (word & FsmErrMask) {
       if (print)
         cout << "Finite State Machine Error- "
              << "channel: " << channel << " Error status:0x" << hex << ((word & FsmErrMask) >> 9) << dec
              << " ";  // <<endl;
       status = -13;
     }
 
     fedChannel = channel;
 
   } else if ((word & errorMask) == fifoError) {  // FIFO
     if (print) {
       if (word & Fif2NFMask)
         cout << "A fifo 2 is Nearly full- ";
       if (word & TrigNFMask)
         cout << "The trigger fifo is nearly Full - ";
       if (word & ChnFifMask)
         cout << "fifo-1 is nearly full for channel" << (word & ChnFifMask);
       //cout<<endl;
       status = -16;
     }
 
   } else {
     cout << " Unknown error?"
          << " : ";
     cout << " for FED " << fed << " Word " << hex << word << dec << endl;
   }
 
   if (print && status < 0)
     cout << " FED " << fed << " status " << status << endl;
   return status;
 }
 ///////////////////////////////////////////////////////////////////////////
 int MyDecode::data(int word, int &fedChannel, int fed, int &stat1, int &stat2, bool print) {
   //const int ROCMAX = 24;
   const unsigned int plsmsk = 0xff;    // pulse height
   const unsigned int pxlmsk = 0xff00;  // pixel index
   const unsigned int dclmsk = 0x1f0000;
   const unsigned int rocmsk = 0x3e00000;
   const unsigned int chnlmsk = 0xfc000000;
   int status = 0;
 
   int roc = ((word & rocmsk) >> 21);  // rocs start from 1
   // Check for embeded special words
   if (roc > 0 && roc < 25) {  // valid ROCs go from 1-24
     //if(print) cout<<"data "<<hex<<word<<dec;
     int channel = ((word & chnlmsk) >> 26);
 
     if (channel > 0 && channel < 37) {  // valid channels 1-36
       //cout<<hex<<word<<dec;
       int dcol = (word & dclmsk) >> 16;
       int pix = (word & pxlmsk) >> 8;
       int adc = (word & plsmsk);
       fedChannel = channel;
 
       int col = convertToCol(dcol, pix);
       int row = convertToRow(pix);
 
       // print the roc number according to the online 0-15 scheme
       if (print)
         cout << " Fed " << fed << " Channel- " << channel << " ROC- " << (roc - 1) << " DCOL- " << dcol << " Pixel- "
              << pix << " (" << col << "," << row << ") ADC- " << adc << endl;
       status++;
 
       if (CHECK_PIXELS) {
         // invalid roc number
         if ((fed > 31 && roc > 24) || (fed <= 31 && roc > 16)) {  //inv ROC
                                                                   //if(printErrors)
           cout << " Fed " << fed << " wrong roc number chan/roc/dcol/pix/adc = " << channel << "/" << roc - 1 << "/"
                << dcol << "/" << pix << "/" << adc << endl;
           status = -4;
 
         } else if (fed <= 31 && channel <= 24 && roc > 8) {
           // Check invalid ROC numbers
 
           // protect for rerouted signals
           if (!((fed == 13 && channel == 17) || (fed == 15 && channel == 5) || (fed == 31 && channel == 10) ||
                 (fed == 27 && channel == 15))) {
             //if(printErrors)
             cout << " Fed " << fed << " wrong roc number, chan/roc/dcol/pix/adc = " << channel << "/" << roc - 1 << "/"
                  << dcol << "/" << pix << "/" << adc << endl;
             status = -4;
           }
         }
 
         // Check pixels
         if (pix == 0) {  // PIX=0
                          // Detect pixel 0 events
           if (printErrors)
             cout << " Fed " << fed << " pix=0 chan/roc/dcol/pix/adc = " << channel << "/" << roc - 1 << "/" << dcol
                  << "/" << pix << "/" << adc << " (" << col << "," << row << ")" << endl;
           count0++;
           stat1 = roc - 1;
           stat2 = count0;
           status = -5;
 
         } else if (fed == fed0 && channel == chan0 && roc == roc0 && dcol == dcol0 && pix == pix0) {
           // detect multiple pixels
 
           count0++;
           if (printErrors)
             cout << " Fed "
                  << fed
                  //cout<<" Fed "<<fed
                  << " double pixel  chan/roc/dcol/pix/adc = " << channel << "/" << roc - 1 << "/" << dcol << "/" << pix
                  << "/" << adc << " (" << col << "," << row << ") " << count0 << endl;
           stat1 = roc - 1;
           stat2 = count0;
           status = -6;
 
         } else {  // normal
 
           count0 = 0;
 
           fed0 = fed;
           chan0 = channel;
           roc0 = roc;
           dcol0 = dcol;
           pix0 = pix;
 
           // Decode errors
           if (pix < 2 || pix > 161) {  // inv PIX
             if (printErrors)
               cout << " Fed " << fed << " wrong pix number chan/roc/dcol/pix/adc = " << channel << "/" << roc - 1 << "/"
                    << dcol << "/" << pix << "/" << adc << " (" << col << "," << row << ")" << endl;
             status = -3;
           }
 
           if (dcol < 0 || dcol > 25) {  // inv DCOL
             if (printErrors)
               cout << " Fed " << fed << " wrong dcol number chan/roc/dcol/pix/adc = " << channel << "/" << roc - 1
                    << "/" << dcol << "/" << pix << "/" << adc << " (" << col << "," << row << ")" << endl;
             status = -3;
           }
 
         }  // check pixels
 
         // Summary error count (for testing only)
         if (pix < 2 || pix > 161 || dcol < 0 || dcol > 25) {
           countDecodeErrors2++;  // count pixels with errors
           if (pix < 2 || pix > 161)
             countDecodeErrors1++;  // count errors
           if (dcol < 0 || dcol > 25)
             countDecodeErrors1++;  // count errors
           //if(fed==6 && channel==35 ) cout<<" Fed "<<fed<<" wrong dcol number chan/roc/dcol/pix/adc = "<<channel<<"/"
           //             <<roc-1<<"/"<<dcol<<"/"<<pix<<"/"<<adc<<" ("<<col<<","<<row<<")"<<endl;
         }
 
       }  // if CHECK_PIXELS
 
     } else {  // channel
 
       cout << " Wrong channel " << channel << " : ";
       cout << " for FED " << fed << " Word " << hex << word << dec << endl;
       return -2;
     }
 
   } else if (roc == 25) {  // ROC?
     unsigned int channel = ((word & chnlmsk) >> 26);
     cout << "Wrong roc 25 "
          << " in fed/chan " << fed << "/" << channel << endl;
     status = -4;
 
   } else {  // error word
 
     //cout<<"error word "<<hex<<word<<dec;
     status = error(word, fedChannel, fed, stat1, stat2, print);
   }
 
   return status;
 }
 ////////////////////////////////////////////////////////////////////////////
 
 class SiPixelRawDumper : public edm::one::EDAnalyzer<edm::one::SharedResources> {
 public:
   /// ctor
   explicit SiPixelRawDumper(const edm::ParameterSet &cfg);
 
   //explicit SiPixelRawDumper( const edm::ParameterSet& cfg) : theConfig(cfg) {
   //consumes<FEDRawDataCollection>(theConfig.getUntrackedParameter<std::string>("InputLabel","source"));}
 
   /// dtor
   virtual ~SiPixelRawDumper() = default;
 
   void beginJob();
 
   // end of job
   void endJob();
 
   /// get data, convert to digis attach againe to Event
   virtual void analyze(const edm::Event &, const edm::EventSetup &);
 
 private:
   edm::ParameterSet theConfig;
   edm::EDGetTokenT<FEDRawDataCollection> rawData;
 
   int printLocal;
   double printThreshold;
   int countEvents, countAllEvents;
   int countTotErrors;
   float sumPixels, sumFedSize, sumFedPixels[40];
   int fedErrors[40][36];
   int fedErrorsENE[40][36];
   int fedErrorsTime[40][36];
   int fedErrorsOver[40][36];
   int decodeErrors[40][36];
   int decodeErrors000[40][36];     // pix 0 problem
   int decodeErrorsDouble[40][36];  // double pix  problem
   int errorType[20];
 
 #ifdef OUTFILE
   ofstream outfile;
 #endif
 
   TH1D *hsize, *hsize0, *hsize1, *hsize2, *hsize3;
 #ifdef IND_FEDS
   TH1D *hsizeFeds[40];
 #endif
   TH1D *hpixels, *hpixels0, *hpixels1, *hpixels2, *hpixels3, *hpixels4;
   TH1D *htotPixels, *htotPixels0, *htotPixels1;
   TH1D *herrors, *htotErrors;
   TH1D *herrorType1, *herrorType1Fed, *herrorType1Chan, *herrorType2, *herrorType2Fed, *herrorType2Chan;
   TH1D *hcountDouble, *hcount000, *hrocDouble, *hroc000;
 
   TH2F *hfed2DErrorsType1, *hfed2DErrorsType2;
   TH2F *hfed2DErrors1, *hfed2DErrors2, *hfed2DErrors3, *hfed2DErrors4, *hfed2DErrors5, *hfed2DErrors6, *hfed2DErrors7,
       *hfed2DErrors8, *hfed2DErrors9, *hfed2DErrors10, *hfed2DErrors11, *hfed2DErrors12, *hfed2DErrors13,
       *hfed2DErrors14, *hfed2DErrors15, *hfed2DErrors16;
   TH2F *hfed2d, *hsize2d, *hfedErrorType1ls, *hfedErrorType2ls, *hcountDouble2, *hcount0002;
   TH2F *hfed2DErrors1ls, *hfed2DErrors2ls, *hfed2DErrors3ls, *hfed2DErrors4ls, *hfed2DErrors5ls, *hfed2DErrors6ls,
       *hfed2DErrors7ls, *hfed2DErrors8ls, *hfed2DErrors9ls, *hfed2DErrors10ls, *hfed2DErrors11ls, *hfed2DErrors12ls,
       *hfed2DErrors13ls, *hfed2DErrors14ls, *hfed2DErrors15ls, *hfed2DErrors16ls;
 
   TH1D *hevent, *hlumi, *horbit, *hbx, *hlumi0, *hbx0;
   //TH1D *hbx1,*hbx2,*hbx3,*hbx4,*hbx5,*hbx6,*hbx7,*hbx8,*hbx9,*hbx10,*hbx11,*hbx12;
   TProfile *htotPixelsls, *hsizels, *herrorType1ls, *herrorType2ls, *havsizels, *htotPixelsbx, *herrorType1bx,
       *herrorType2bx, *havsizebx, *hsizep;
   TProfile *herror1ls, *herror2ls, *herror3ls, *herror4ls, *herror5ls, *herror6ls, *herror7ls, *herror8ls, *herror9ls,
       *herror10ls, *herror11ls, *herror12ls, *herror13ls, *herror14ls, *herror15ls, *herror16ls;
   TProfile2D *hfedchannelsize;
   TH1D *herrorTimels, *herrorOverls, *herrorTimels1, *herrorOverls1, *herrorTimels2, *herrorOverls2, *herrorTimels3,
       *herrorOverls3, *herrorTimels0, *herrorOverls0;
   TH1D *hfedchannelsizeb, *hfedchannelsizeb1, *hfedchannelsizeb2, *hfedchannelsizeb3, *hfedchannelsizef;
 };
 //----------------------------------------------------------------------------------
 SiPixelRawDumper::SiPixelRawDumper(const edm::ParameterSet &cfg) : theConfig(cfg) {
   string label = theConfig.getUntrackedParameter<std::string>("InputLabel", "source");
   // For the ByToken method
   rawData = consumes<FEDRawDataCollection>(label);
   usesResource(TFileService::kSharedResource);
 }
 //----------------------------------------------------------------------------------------
 void SiPixelRawDumper::endJob() {
   string errorName[18] = {" ",
                           " ",
                           "wrong channel",
                           "wrong pix or dcol",
                           "wrong roc",
                           "pix=0",
                           " double-pix",
                           " ",
                           " ",
                           " ",
                           "timeout",
                           "ENE",
                           "NOR",
                           "FSM",
                           "overflow",
                           "trailer",
                           "fifo",
                           "reset/resync"};
 
   // 2 - wrong channel
   // 3 - wrong pix or dcol
   // 4 - wrong roc
   // 5 - pix=0
   // 6 - double pixel
   // 10 - timeout ()
   // 11 - ene ()
   // 12 - mum pf rocs error ()
   // 13 - fsm ()
   // 14 - overflow ()
   // 15 - trailer ()
   // 16 - fifo  (30)
   // 17 - reset/resync NOT INCLUDED YET
 
   if (countEvents > 0) {
     sumPixels /= float(countEvents);
     sumFedSize /= float(countAllEvents);
     for (int i = 0; i < 40; ++i) {
       sumFedPixels[i] /= float(countEvents);
       hpixels4->Fill(float(i), sumFedPixels[i]);  //pixels only
     }
   }
 
   cout << " Total/non-empty events " << countAllEvents << " / " << countEvents << " average number of pixels "
        << sumPixels << endl;
 
   cout << " Average Fed size per event for all events (in 4-words) " << (sumFedSize * 2. / 40.)
        << " total for all feds " << (sumFedSize * 2.) << endl;
 
   cout << " Size for ech FED per event in units of hit pixels:" << endl;
 
   for (int i = 0; i < 40; ++i)
     cout << sumFedPixels[i] << " ";
   cout << endl;
 
   cout << " Total number of errors " << countTotErrors << " print threshold " << int(countEvents * printThreshold)
        << " total errors per fed channel" << endl;
   cout << " FED errors " << endl << "Fed Channel Tot-Errors ENE-Errors Time-Errors Over-Errors" << endl;
 
   for (int i = 0; i < 40; ++i) {
     for (int j = 0; j < 36; ++j)
       if ((fedErrors[i][j]) > int(countEvents * printThreshold) || (fedErrorsENE[i][j] > 0)) {
         cout << " " << i << "  -  " << (j + 1) << " -  " << fedErrors[i][j] << " - " << fedErrorsENE[i][j] << " -  "
              << fedErrorsTime[i][j] << " - " << fedErrorsOver[i][j] << endl;
       }
   }
   cout << " Decode errors " << endl << "Fed Channel Errors Pix_000 Double_Pix" << endl;
   for (int i = 0; i < 40; ++i) {
     for (int j = 0; j < 36; ++j) {
       int tmp = decodeErrors[i][j] + decodeErrors000[i][j] + decodeErrorsDouble[i][j];
       if (tmp > 10)
         cout << " " << i << " -  " << (j + 1) << "   -  " << decodeErrors[i][j] << "  -    " << decodeErrors000[i][j]
              << "  -   " << decodeErrorsDouble[i][j] << endl;
     }
   }
 
   cout << " Total errors for all feds " << endl << " Type Name Num-Of-Errors" << endl;
   for (int i = 0; i < 20; ++i) {
     if (errorType[i] > 0)
       cout << "   " << i << " - " << errorName[i] << " - " << errorType[i] << endl;
   }
 
   cout << " Test decode errors " << countDecodeErrors1 << " " << countDecodeErrors2 << endl;
 
 #ifdef OUTFILE
   outfile.close();
 #endif
 }
 //----------------------------------------------------------------------
 void SiPixelRawDumper::beginJob() {
   printLocal = theConfig.getUntrackedParameter<int>("Verbosity", 1);
   // threshold per event for printing errors
   printThreshold = theConfig.getUntrackedParameter<double>("PrintThreshold", 0.001);
   cout << " beginjob " << printLocal << " " << printThreshold << endl;
 
   if (printLocal > 0)
     printErrors = true;
   else
     printErrors = false;
   if (printLocal > 1)
     printData = true;
   else
     printData = false;
   if (printLocal > 2)
     printHeaders = true;
   else
     printHeaders = false;
 
   countEvents = 0;
   countAllEvents = 0;
   countTotErrors = 0;
   sumPixels = 0.;
   sumFedSize = 0;
   for (int i = 0; i < 40; ++i) {
     sumFedPixels[i] = 0;
     for (int j = 0; j < 36; ++j) {
       fedErrors[i][j] = 0;
       fedErrorsENE[i][j] = 0;
       fedErrorsTime[i][j] = 0;
       fedErrorsOver[i][j] = 0;
     }
     for (int j = 0; j < 36; ++j) {
       decodeErrors[i][j] = 0;
       decodeErrors000[i][j] = 0;
       decodeErrorsDouble[i][j] = 0;
     }
   }
   for (int i = 0; i < 20; ++i)
     errorType[i] = 0;
 
   edm::Service<TFileService> fs;
 
   //const float pixMax = 5999.5;   // pp value
   //const float totMax = 99999.5;  // pp value
   //const float maxLink = 200.;    // pp value
 
   const float pixMax = 19999.5;   // hi value
   const float totMax = 399999.5;  // hi value
   const float maxLink = 1000.;    // hi value
 
   hsize = fs->make<TH1D>("hsize", "FED event size in words-4", 6000, -0.5, pixMax);
   hsize0 = fs->make<TH1D>("hsize0", "FED event size in words-4", 2000, -0.5, 19999.5);
   hsize1 = fs->make<TH1D>("hsize1", "bpix FED event size in words-4", 6000, -0.5, pixMax);
   hsize2 = fs->make<TH1D>("hsize2", "fpix FED event size in words-4", 6000, -0.5, pixMax);
   hsize3 = fs->make<TH1D>("hsize3", "ave bpix FED event size in words-4", 6000, -0.5, pixMax);
 
   hpixels = fs->make<TH1D>("hpixels", "pixels per FED", 2000, -0.5, 19999.5);
   hpixels0 = fs->make<TH1D>("hpixels0", "pixels per FED", 6000, -0.5, pixMax);
   hpixels1 = fs->make<TH1D>("hpixels1", "pixels >0 per FED", 6000, -0.5, pixMax);
   hpixels2 = fs->make<TH1D>("hpixels2", "pixels >0 per BPix FED", 6000, -0.5, pixMax);
   hpixels3 = fs->make<TH1D>("hpixels3", "pixels >0 per Fpix FED", 6000, -0.5, pixMax);
   hpixels4 = fs->make<TH1D>("hpixels4", "pixels per each FED", 40, -0.5, 39.5);
 
   htotPixels = fs->make<TH1D>("htotPixels", "pixels per event", 10000, -0.5, totMax);
   htotPixels0 = fs->make<TH1D>("htotPixels0", "pixels per event, zoom low region", 20000, -0.5, 19999.5);
   htotPixels1 = fs->make<TH1D>("htotPixels1", "pixels >0 per event", 10000, -0.5, totMax);
 
   herrors = fs->make<TH1D>("herrors", "errors per FED", 100, -0.5, 99.5);
   htotErrors = fs->make<TH1D>("htotErrors", "errors per event", 1000, -0.5, 999.5);
 
   herrorType1 = fs->make<TH1D>("herrorType1", "errors 1 per type", 20, -0.5, 19.5);
   herrorType1Fed = fs->make<TH1D>("herrorType1Fed", "errors 1 per FED", 40, -0.5, 39.5);
   herrorType1Chan = fs->make<TH1D>("herrorType1Chan", "errors 1 per chan", 37, -0.5, 36.5);
   herrorType2 = fs->make<TH1D>("herrorType2", "readout errors 2 per type", 20, -0.5, 19.5);
   herrorType2Fed = fs->make<TH1D>("herrorType2Fed", "readout errors 2 per FED", 40, -0.5, 39.5);
   herrorType2Chan = fs->make<TH1D>("herrorType2Chan", "readout errors 2 per chan", 37, -0.5, 36.5);
 
   hcountDouble = fs->make<TH1D>("hcountDouble", "count double pixels", 100, -0.5, 99.5);
   hcountDouble2 = fs->make<TH2F>("hcountDouble2", "count double pixels", 40, -0.5, 39.5, 10, 0., 10.);
   hcount000 = fs->make<TH1D>("hcount000", "count 000 pixels", 100, -0.5, 99.5);
   hcount0002 = fs->make<TH2F>("hcount0002", "count 000 pixels", 40, -0.5, 39.5, 10, 0., 10.);
   hrocDouble = fs->make<TH1D>("hrocDouble", "double pixels rocs", 25, -0.5, 24.5);
   hroc000 = fs->make<TH1D>("hroc000", "000 pixels rocs", 25, -0.5, 24.5);
 
   hfed2d = fs->make<TH2F>("hfed2d", "errors", 40, -0.5, 39.5, 21, -0.5, 20.5);  // ALL
 
   hsize2d = fs->make<TH2F>("hsize2d", "size vs fed", 40, -0.5, 39.5, 50, 0, 500);   // ALL
   hsizep = fs->make<TProfile>("hsizep", "size vs fed", 40, -0.5, 39.5, 0, 100000);  // ALL
   //hsize2dls = fs->make<TH2F>( "hsize2dls", "size vs lumi",100,0,1000, 50,0.,500.); // ALL
 
 #ifdef IND_FEDS
   hsizeFeds[0] = fs->make<TH1D>("hsizeFed0", "FED 0 event size ", 1000, -0.5, pixMax);
   hsizeFeds[1] = fs->make<TH1D>("hsizeFed1", "FED 1 event size ", 1000, -0.5, pixMax);
   hsizeFeds[2] = fs->make<TH1D>("hsizeFed2", "FED 2 event size ", 1000, -0.5, pixMax);
   hsizeFeds[3] = fs->make<TH1D>("hsizeFed3", "FED 3 event size ", 1000, -0.5, pixMax);
   hsizeFeds[4] = fs->make<TH1D>("hsizeFed4", "FED 4 event size ", 1000, -0.5, pixMax);
   hsizeFeds[5] = fs->make<TH1D>("hsizeFed5", "FED 5 event size ", 1000, -0.5, pixMax);
   hsizeFeds[6] = fs->make<TH1D>("hsizeFed6", "FED 6 event size ", 1000, -0.5, pixMax);
   hsizeFeds[7] = fs->make<TH1D>("hsizeFed7", "FED 7 event size ", 1000, -0.5, pixMax);
   hsizeFeds[8] = fs->make<TH1D>("hsizeFed8", "FED 8 event size ", 1000, -0.5, pixMax);
   hsizeFeds[9] = fs->make<TH1D>("hsizeFed9", "FED 9 event size ", 1000, -0.5, pixMax);
   hsizeFeds[10] = fs->make<TH1D>("hsizeFed10", "FED 10 event size ", 1000, -0.5, pixMax);
   hsizeFeds[11] = fs->make<TH1D>("hsizeFed11", "FED 11 event size ", 1000, -0.5, pixMax);
   hsizeFeds[12] = fs->make<TH1D>("hsizeFed12", "FED 12 event size ", 1000, -0.5, pixMax);
   hsizeFeds[13] = fs->make<TH1D>("hsizeFed13", "FED 13 event size ", 1000, -0.5, pixMax);
   hsizeFeds[14] = fs->make<TH1D>("hsizeFed14", "FED 14 event size ", 1000, -0.5, pixMax);
   hsizeFeds[15] = fs->make<TH1D>("hsizeFed15", "FED 15 event size ", 1000, -0.5, pixMax);
   hsizeFeds[16] = fs->make<TH1D>("hsizeFed16", "FED 16 event size ", 1000, -0.5, pixMax);
   hsizeFeds[17] = fs->make<TH1D>("hsizeFed17", "FED 17 event size ", 1000, -0.5, pixMax);
   hsizeFeds[18] = fs->make<TH1D>("hsizeFed18", "FED 18 event size ", 1000, -0.5, pixMax);
   hsizeFeds[19] = fs->make<TH1D>("hsizeFed19", "FED 19 event size ", 1000, -0.5, pixMax);
   hsizeFeds[20] = fs->make<TH1D>("hsizeFed20", "FED 20 event size ", 1000, -0.5, pixMax);
   hsizeFeds[21] = fs->make<TH1D>("hsizeFed21", "FED 21 event size ", 1000, -0.5, pixMax);
   hsizeFeds[22] = fs->make<TH1D>("hsizeFed22", "FED 22 event size ", 1000, -0.5, pixMax);
   hsizeFeds[23] = fs->make<TH1D>("hsizeFed23", "FED 23 event size ", 1000, -0.5, pixMax);
   hsizeFeds[24] = fs->make<TH1D>("hsizeFed24", "FED 24 event size ", 1000, -0.5, pixMax);
   hsizeFeds[25] = fs->make<TH1D>("hsizeFed25", "FED 25 event size ", 1000, -0.5, pixMax);
   hsizeFeds[26] = fs->make<TH1D>("hsizeFed26", "FED 26 event size ", 1000, -0.5, pixMax);
   hsizeFeds[27] = fs->make<TH1D>("hsizeFed27", "FED 27 event size ", 1000, -0.5, pixMax);
   hsizeFeds[28] = fs->make<TH1D>("hsizeFed28", "FED 28 event size ", 1000, -0.5, pixMax);
   hsizeFeds[29] = fs->make<TH1D>("hsizeFed29", "FED 29 event size ", 1000, -0.5, pixMax);
   hsizeFeds[30] = fs->make<TH1D>("hsizeFed30", "FED 30 event size ", 1000, -0.5, pixMax);
   hsizeFeds[31] = fs->make<TH1D>("hsizeFed31", "FED 31 event size ", 1000, -0.5, pixMax);
   hsizeFeds[32] = fs->make<TH1D>("hsizeFed32", "FED 32 event size ", 1000, -0.5, pixMax);
   hsizeFeds[33] = fs->make<TH1D>("hsizeFed33", "FED 33 event size ", 1000, -0.5, pixMax);
   hsizeFeds[34] = fs->make<TH1D>("hsizeFed34", "FED 34 event size ", 1000, -0.5, pixMax);
   hsizeFeds[35] = fs->make<TH1D>("hsizeFed35", "FED 35 event size ", 1000, -0.5, pixMax);
   hsizeFeds[36] = fs->make<TH1D>("hsizeFed36", "FED 36 event size ", 1000, -0.5, pixMax);
   hsizeFeds[37] = fs->make<TH1D>("hsizeFed37", "FED 37 event size ", 1000, -0.5, pixMax);
   hsizeFeds[38] = fs->make<TH1D>("hsizeFed38", "FED 38 event size ", 1000, -0.5, pixMax);
   hsizeFeds[39] = fs->make<TH1D>("hsizeFed39", "FED 39 event size ", 1000, -0.5, pixMax);
 #endif
 
   hevent = fs->make<TH1D>("hevent", "event", 1000, 0, 10000000.);
   //horbit = fs->make<TH1D>("horbit","orbit",100, 0,100000000.);
   hlumi = fs->make<TH1D>("hlumi", "lumi", 3000, 0, 3000.);
   hlumi0 = fs->make<TH1D>("hlumi0", "lumi", 3000, 0, 3000.);
 
   hbx = fs->make<TH1D>("hbx", "bx", 4000, 0, 4000.);
   hbx0 = fs->make<TH1D>("hbx0", "bx", 4000, 0, 4000.);
 
   //   hbx1    = fs->make<TH1D>("hbx1",   "bx",   4000,0,4000.);
   //   hbx2    = fs->make<TH1D>("hbx2",   "bx",   4000,0,4000.);
   //   hbx3    = fs->make<TH1D>("hbx3",   "bx",   4000,0,4000.);
   //   hbx4    = fs->make<TH1D>("hbx4",   "bx",   4000,0,4000.);
   //   hbx5    = fs->make<TH1D>("hbx5",   "bx",   4000,0,4000.);
   //   hbx6    = fs->make<TH1D>("hbx6",   "bx",   4000,0,4000.);
   //   hbx7    = fs->make<TH1D>("hbx7",   "bx",   4000,0,4000.);
   //   hbx8    = fs->make<TH1D>("hbx8",   "bx",   4000,0,4000.);
   //   hbx9    = fs->make<TH1D>("hbx9",   "bx",   4000,0,4000.);
   //   hbx10    = fs->make<TH1D>("hbx10",   "bx",   4000,0,4000.);
   //   hbx11    = fs->make<TH1D>("hbx11",   "bx",   4000,0,4000.);
   //   hbx12    = fs->make<TH1D>("hbx12",   "bx",   4000,0,4000.);
 
   herrorTimels = fs->make<TH1D>("herrorTimels", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls = fs->make<TH1D>("herrorOverls", "overflows vs ls", 1000, 0, 3000);
   herrorTimels1 = fs->make<TH1D>("herrorTimels1", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls1 = fs->make<TH1D>("herrorOverls1", "overflows vs ls", 1000, 0, 3000);
   herrorTimels2 = fs->make<TH1D>("herrorTimels2", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls2 = fs->make<TH1D>("herrorOverls2", "overflows vs ls", 1000, 0, 3000);
   herrorTimels3 = fs->make<TH1D>("herrorTimels3", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls3 = fs->make<TH1D>("herrorOverls3", "overflows vs ls", 1000, 0, 3000);
   herrorTimels0 = fs->make<TH1D>("herrorTimels0", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls0 = fs->make<TH1D>("herrorOverls0", "overflows vs ls", 1000, 0, 3000);
 
   hfed2DErrorsType1 = fs->make<TH2F>("hfed2DErrorsType1", "errors type 1 per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrorsType2 = fs->make<TH2F>("hfed2DErrorsType2", "errors type 2 per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
 
   hfed2DErrors1 = fs->make<TH2F>("hfed2DErrors1", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   //hfed2DErrors2 = fs->make<TH2F>("hfed2DErrors2", "errors per FED", 40,-0.5,39.5,37, -0.5, 36.5);
   hfed2DErrors3 = fs->make<TH2F>("hfed2DErrors3", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors4 = fs->make<TH2F>("hfed2DErrors4", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors5 = fs->make<TH2F>("hfed2DErrors5", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors6 = fs->make<TH2F>("hfed2DErrors6", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   //hfed2DErrors7 = fs->make<TH2F>("hfed2DErrors7", "errors per FED", 40,-0.5,39.5,37, -0.5, 36.5);
   //hfed2DErrors8 = fs->make<TH2F>("hfed2DErrors8", "errors per FED", 40,-0.5,39.5,37, -0.5, 36.5);
   //hfed2DErrors9 = fs->make<TH2F>("hfed2DErrors9", "errors per FED", 40,-0.5,39.5,37, -0.5, 36.5);
   hfed2DErrors10 = fs->make<TH2F>("hfed2DErrors10", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors11 = fs->make<TH2F>("hfed2DErrors11", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors12 = fs->make<TH2F>("hfed2DErrors12", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors13 = fs->make<TH2F>("hfed2DErrors13", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors14 = fs->make<TH2F>("hfed2DErrors14", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors15 = fs->make<TH2F>("hfed2DErrors15", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors16 = fs->make<TH2F>("hfed2DErrors16", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
 
   hfedErrorType1ls = fs->make<TH2F>("hfedErrorType1ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfedErrorType2ls = fs->make<TH2F>("hfedErrorType2ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
 
   hfed2DErrors1ls = fs->make<TH2F>("hfed2DErrors1ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   //hfed2DErrors2ls  = fs->make<TH2F>("hfed2DErrors2ls", "errors vs lumi",300,0,3000, 40,-0.5,39.5); //
   hfed2DErrors3ls = fs->make<TH2F>("hfed2DErrors3ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors4ls = fs->make<TH2F>("hfed2DErrors4ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors5ls = fs->make<TH2F>("hfed2DErrors5ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors6ls = fs->make<TH2F>("hfed2DErrors6ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   //hfed2DErrors7ls  = fs->make<TH2F>("hfed2DErrors7ls", "errors vs lumi",300,0,3000, 40,-0.5,39.5); //
   //hfed2DErrors8ls  = fs->make<TH2F>("hfed2DErrors8ls", "errors vs lumi",300,0,3000, 40,-0.5,39.5); //
   //hfed2DErrors9ls  = fs->make<TH2F>("hfed2DErrors9ls", "errors vs lumi",300,0,3000, 40,-0.5,39.5); //
   hfed2DErrors10ls = fs->make<TH2F>("hfed2DErrors10ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors11ls = fs->make<TH2F>("hfed2DErrors11ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors12ls = fs->make<TH2F>("hfed2DErrors12ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors13ls = fs->make<TH2F>("hfed2DErrors13ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors14ls = fs->make<TH2F>("hfed2DErrors14ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors15ls = fs->make<TH2F>("hfed2DErrors15ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors16ls = fs->make<TH2F>("hfed2DErrors16ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
 
   herrorTimels = fs->make<TH1D>("herrorTimels", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls = fs->make<TH1D>("herrorOverls", "overflows vs ls", 1000, 0, 3000);
   herrorTimels1 = fs->make<TH1D>("herrorTimels1", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls1 = fs->make<TH1D>("herrorOverls1", "overflows vs ls", 1000, 0, 3000);
   herrorTimels2 = fs->make<TH1D>("herrorTimels2", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls2 = fs->make<TH1D>("herrorOverls2", "overflows vs ls", 1000, 0, 3000);
   herrorTimels3 = fs->make<TH1D>("herrorTimels3", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls3 = fs->make<TH1D>("herrorOverls3", "overflows vs ls", 1000, 0, 3000);
   herrorTimels0 = fs->make<TH1D>("herrorTimels0", "timeouts vs ls", 1000, 0, 3000);
   herrorOverls0 = fs->make<TH1D>("herrorOverls0", "overflows vs ls", 1000, 0, 3000);
 
   hfed2DErrorsType1 = fs->make<TH2F>("hfed2DErrorsType1", "errors type 1 per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrorsType2 = fs->make<TH2F>("hfed2DErrorsType2", "errors type 2 per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
 
   hfed2DErrors1 = fs->make<TH2F>("hfed2DErrors1", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   //hfed2DErrors2 = fs->make<TH2F>("hfed2DErrors2", "errors per FED", 40,-0.5,39.5,37, -0.5, 36.5);
   hfed2DErrors3 = fs->make<TH2F>("hfed2DErrors3", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors4 = fs->make<TH2F>("hfed2DErrors4", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors5 = fs->make<TH2F>("hfed2DErrors5", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors6 = fs->make<TH2F>("hfed2DErrors6", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   //hfed2DErrors7 = fs->make<TH2F>("hfed2DErrors7", "errors per FED", 40,-0.5,39.5,37, -0.5, 36.5);
   //hfed2DErrors8 = fs->make<TH2F>("hfed2DErrors8", "errors per FED", 40,-0.5,39.5,37, -0.5, 36.5);
   //hfed2DErrors9 = fs->make<TH2F>("hfed2DErrors9", "errors per FED", 40,-0.5,39.5,37, -0.5, 36.5);
   hfed2DErrors10 = fs->make<TH2F>("hfed2DErrors10", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors11 = fs->make<TH2F>("hfed2DErrors11", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors12 = fs->make<TH2F>("hfed2DErrors12", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors13 = fs->make<TH2F>("hfed2DErrors13", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors14 = fs->make<TH2F>("hfed2DErrors14", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors15 = fs->make<TH2F>("hfed2DErrors15", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
   hfed2DErrors16 = fs->make<TH2F>("hfed2DErrors16", "errors per FED", 40, -0.5, 39.5, 37, -0.5, 36.5);
 
   hfedErrorType1ls = fs->make<TH2F>("hfedErrorType1ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfedErrorType2ls = fs->make<TH2F>("hfedErrorType2ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
 
   hfed2DErrors1ls = fs->make<TH2F>("hfed2DErrors1ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   //hfed2DErrors2ls  = fs->make<TH2F>("hfed2DErrors2ls", "errors vs lumi",300,0,3000, 40,-0.5,39.5); //
   hfed2DErrors3ls = fs->make<TH2F>("hfed2DErrors3ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors4ls = fs->make<TH2F>("hfed2DErrors4ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors5ls = fs->make<TH2F>("hfed2DErrors5ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors6ls = fs->make<TH2F>("hfed2DErrors6ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   //hfed2DErrors7ls  = fs->make<TH2F>("hfed2DErrors7ls", "errors vs lumi",300,0,3000, 40,-0.5,39.5); //
   //hfed2DErrors8ls  = fs->make<TH2F>("hfed2DErrors8ls", "errors vs lumi",300,0,3000, 40,-0.5,39.5); //
   //hfed2DErrors9ls  = fs->make<TH2F>("hfed2DErrors9ls", "errors vs lumi",300,0,3000, 40,-0.5,39.5); //
   hfed2DErrors10ls = fs->make<TH2F>("hfed2DErrors10ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors11ls = fs->make<TH2F>("hfed2DErrors11ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors12ls = fs->make<TH2F>("hfed2DErrors12ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors13ls = fs->make<TH2F>("hfed2DErrors13ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors14ls = fs->make<TH2F>("hfed2DErrors14ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors15ls = fs->make<TH2F>("hfed2DErrors15ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
   hfed2DErrors16ls = fs->make<TH2F>("hfed2DErrors16ls", "errors vs lumi", 300, 0, 3000, 40, -0.5, 39.5);  //
 
   hsizels = fs->make<TProfile>("hsizels", " bpix fed size vs ls", 300, 0, 3000, 0, 200000.);
   htotPixelsls = fs->make<TProfile>("htotPixelsls", " tot pixels vs ls", 300, 0, 3000, 0, 300000.);
   havsizels = fs->make<TProfile>("havsizels", "av. bpix fed size vs ls", 300, 0, 3000, 0, 300000.);
 
   herrorType1ls = fs->make<TProfile>("herrorType1ls", "error type 1 vs ls", 300, 0, 3000, 0, 1000.);
   herrorType2ls = fs->make<TProfile>("herrorType2ls", "error type 2 vs ls", 300, 0, 3000, 0, 1000.);
 
   herror1ls = fs->make<TProfile>("herror1ls", "error 1 vs ls", 300, 0, 3000, 0, 1000.);
   //herror2ls = fs->make<TProfile>("herror2ls","error 2 vs ls",300,0,3000,0,1000.);
   herror3ls = fs->make<TProfile>("herror3ls", "error 3 vs ls", 300, 0, 3000, 0, 1000.);
   herror4ls = fs->make<TProfile>("herror4ls", "error 4 vs ls", 300, 0, 3000, 0, 1000.);
   herror5ls = fs->make<TProfile>("herror5ls", "error 5 vs ls", 300, 0, 3000, 0, 1000.);
   herror6ls = fs->make<TProfile>("herror6ls", "error 6 vs ls", 300, 0, 3000, 0, 1000.);
   //herror7ls = fs->make<TProfile>("herror7ls","error 7 vs ls",300,0,3000,0,1000.);
   //herror8ls = fs->make<TProfile>("herror8ls","error 8 vs ls",300,0,3000,0,1000.);
   //herror9ls = fs->make<TProfile>("herror9ls","error 9 vs ls",300,0,3000,0,1000.);
   herror10ls = fs->make<TProfile>("herror10ls", "error 10 vs ls", 300, 0, 3000, 0, 1000.);
   herror11ls = fs->make<TProfile>("herror11ls", "error 11 vs ls", 300, 0, 3000, 0, 1000.);
   herror12ls = fs->make<TProfile>("herror12ls", "error 12 vs ls", 300, 0, 3000, 0, 1000.);
   herror13ls = fs->make<TProfile>("herror13ls", "error 13 vs ls", 300, 0, 3000, 0, 1000.);
   herror14ls = fs->make<TProfile>("herror14ls", "error 14 vs ls", 300, 0, 3000, 0, 1000.);
   herror15ls = fs->make<TProfile>("herror15ls", "error 15 vs ls", 300, 0, 3000, 0, 1000.);
   herror16ls = fs->make<TProfile>("herror16ls", "error 16 vs ls", 300, 0, 3000, 0, 1000.);
 
   htotPixelsbx = fs->make<TProfile>("htotPixelsbx", " tot pixels vs bx", 4000, -0.5, 3999.5, 0, 300000.);
   havsizebx = fs->make<TProfile>("havsizebx", " ave bpix fed size vs bx", 4000, -0.5, 3999.5, 0, 300000.);
   herrorType1bx = fs->make<TProfile>("herrorType1bx", " error type 1 vs bx", 4000, -0.5, 3999.5, 0, 300000.);
   herrorType2bx = fs->make<TProfile>("herrorType2bx", " error type 2 vs bx", 4000, -0.5, 3999.5, 0, 300000.);
 
   //hintgl  = fs->make<TProfile>("hintgl", "inst lumi vs ls ",1000,0.,3000.,0.0,1000.);
   //hinstl  = fs->make<TProfile>("hinstl", "intg lumi vs ls ",1000,0.,3000.,0.0,10.);
 
   hfedchannelsize =
       fs->make<TProfile2D>("hfedchannelsize", "pixels per fed/channel", 40, -0.5, 39.5, 37, -0.5, 36.5, 0.0, 10000.);
 
   hfedchannelsizeb = fs->make<TH1D>("hfedchannelsizeb", "pixels per bpix channel", 200, 0.0, maxLink);
   hfedchannelsizeb1 = fs->make<TH1D>("hfedchannelsizeb1", "pixels per bpix1 channel", 200, 0.0, maxLink);
   hfedchannelsizeb2 = fs->make<TH1D>("hfedchannelsizeb2", "pixels per bpix2 channel", 200, 0.0, maxLink);
   hfedchannelsizeb3 = fs->make<TH1D>("hfedchannelsizeb3", "pixels per bpix3 channel", 200, 0.0, maxLink);
   hfedchannelsizef = fs->make<TH1D>("hfedchannelsizef", "pixels per fpix channel", 200, 0.0, maxLink);
 
 #ifdef OUTFILE
   outfile.open("pixfed.csv");
   for (int i = 0; i < 40; ++i) {
     if (i < 39)
       outfile << i << ",";
     else
       outfile << i << endl;
   }
 #endif
 }
 //-----------------------------------------------------------------------
 void SiPixelRawDumper::analyze(const edm::Event &ev, const edm::EventSetup &es) {
   // Access event information
   int run = ev.id().run();
   int event = ev.id().event();
   int lumiBlock = ev.luminosityBlock();
   int bx = ev.bunchCrossing();
   //int orbit     = ev.orbitNumber();
 
   hevent->Fill(float(event));
   hlumi0->Fill(float(lumiBlock));
   hbx0->Fill(float(bx));
   //horbit->Fill(float(orbit));
 
 #ifdef L1
   // Get L1
   edm::Handle<L1GlobalTriggerReadoutRecord> L1GTRR;
   ev.getByLabel("gtDigis", L1GTRR);
 
   if (L1GTRR.isValid()) {
     bool l1a = L1GTRR->decision();
     cout << " L1 status :" << l1a << endl;
   } else {
     cout << " NO L1 status " << endl;
   }  // if l1a
 #endif
 
   // Get lumi info (does not work for raw)
   //  edm::LuminosityBlock const& iLumi = ev.getLuminosityBlock();
   //   edm::Handle<LumiSummary> lumi;
   //   iLumi.getByLabel("lumiProducer", lumi);
   //   edm::Handle<edm::ConditionsInLumiBlock> cond;
   //   float intlumi = 0, instlumi=0;
   //   int beamint1=0, beamint2=0;
   //   iLumi.getByLabel("conditionsInEdm", cond);
   //   // This will only work when running on RECO until (if) they fix it in the FW
   //   // When running on RAW and reconstructing, the LumiSummary will not appear
   //   // in the event before reaching endLuminosityBlock(). Therefore, it is not
   //   // possible to get this info in the event
   //   if (lumi.isValid()) {
   //     intlumi =(lumi->intgRecLumi())/1000.; // integrated lumi per LS in -pb
   //     instlumi=(lumi->avgInsDelLumi())/1000.; //ave. inst lumi per LS in -pb
   //     beamint1=(cond->totalIntensityBeam1)/1000;
   //     beamint2=(cond->totalIntensityBeam2)/1000;
   //   } else {
   //     std::cout << "** ERROR: Event does not get lumi info\n";
   //   }
   //   cout<<instlumi<<" "<<intlumi<<" "<<lumiBlock<<endl;
 
   //   hinstl->Fill(float(lumiBlock),float(instlumi));
   //   hintgl->Fill(float(lumiBlock),float(intlumi));
 
   edm::Handle<FEDRawDataCollection> buffers;
   //static std::string label = theConfig.getUntrackedParameter<std::string>("InputLabel","source");
   //static std::string instance = theConfig.getUntrackedParameter<std::string>("InputInstance","");
   //ev.getByLabel( label, instance, buffers);
   ev.getByToken(rawData, buffers);  // the new bytoken
 
   std::pair<int, int> fedIds(FEDNumbering::MINSiPixelFEDID, FEDNumbering::MAXSiPixelFEDID);
 
   //PixelDataFormatter formatter(0);  // only for digis
   //bool dummyErrorBool;
 
   //typedef unsigned int Word32;
   //typedef long long Word64;
   typedef uint32_t Word32;
   typedef uint64_t Word64;
   int status = 0;
   int countPixels = 0;
   int eventId = -1;
   int countErrorsPerEvent = 0;
   int countErrorsPerEvent1 = 0;
   int countErrorsPerEvent2 = 0;
   double aveFedSize = 0.;
   int stat1 = -1, stat2 = -1;
   int fedchannelsize[36];
 
   int countErrors[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
   countAllEvents++;
 
   if (printHeaders || printLocal > 0)
     cout << "Event = " << countEvents << " Event number " << event << " Run " << run << " LS " << lumiBlock << endl;
 
   // Loop over FEDs
   for (int fedId = fedIds.first; fedId <= fedIds.second; fedId++) {
     //edm::DetSetVector<PixelDigi> collection;
     PixelDataFormatter::Errors errors;
 
     //get event data for this fed
     const FEDRawData &rawData = buffers->FEDData(fedId);
 
     if (printHeaders)
       cout << "Get data For FED = " << fedId << " size in bytes " << rawData.size() << endl;
     if (rawData.size() == 0)
       continue;  // skip if not data for this fed
 
     for (int i = 0; i < 36; ++i)
       fedchannelsize[i] = 0;
 
     int nWords = rawData.size() / sizeof(Word64);
     //cout<<" size "<<nWords<<endl;
 
     sumFedSize += float(nWords);
     if (fedId < 32)
       aveFedSize += double(2. * nWords);
 
     hsize->Fill(float(2 * nWords));   // fed buffer size in words (32bit)
     hsize0->Fill(float(2 * nWords));  // fed buffer size in words (32bit)
     if (fedId < 32)
       hsize1->Fill(float(2 * nWords));  // bpix fed buffer size in words (32bit)
     else
       hsize2->Fill(float(2 * nWords));  // fpix fed buffer size in words (32bit)
 
 #ifdef IND_FEDS
     hsizeFeds[fedId]->Fill(float(2 * nWords));  // size, includes errors and dummy words
 #endif
     hsize2d->Fill(float(fedId), float(2 * nWords));  // 2d
     hsizep->Fill(float(fedId), float(2 * nWords));   // profile
     if (fedId < 32)
       hsizels->Fill(float(lumiBlock), float(2 * nWords));  // bpix versu sls
 
     // check headers
     const Word64 *header = reinterpret_cast<const Word64 *>(rawData.data());
     //cout<<hex<<*header<<dec<<endl;
 
     unsigned int bxid = 0;
     eventId = MyDecode::header(*header, fedId, printHeaders, bxid);
     //if(fedId = fedIds.first)
     if (bx != int(bxid))
       cout << " Inconsistent BX: from event " << bx << " from FED " << bxid << endl;
 
     const Word64 *trailer = reinterpret_cast<const Word64 *>(rawData.data()) + (nWords - 1);
     //cout<<hex<<*trailer<<dec<<endl;
     status = MyDecode::trailer(*trailer, fedId, printHeaders);
 
     int countPixelsInFed = 0;
     int countErrorsInFed = 0;
     int countErrorsInFed1 = 0;
     int countErrorsInFed2 = 0;
     int fedChannel = 0;
     int num = 0;
 
     // Loop over payload words
     for (const Word64 *word = header + 1; word != trailer; word++) {
       static const Word64 WORD32_mask = 0xffffffff;
 
       for (int ipart = 0; ipart < 2; ++ipart) {
         Word32 w = 0;
         if (ipart == 0) {
           w = *word & WORD32_mask;  // 1st word
           //w1=w;
         } else if (ipart == 1) {
           w = *word >> 32 & WORD32_mask;  // 2nd word
         }
 
         num++;
         if (printLocal > 3)
           cout << " " << num << " " << hex << w << dec << endl;
 
         status = MyDecode::data(w, fedChannel, fedId, stat1, stat2, printData);
         int layer = MyDecode::checkLayerLink(fedId, fedChannel);  // get bpix layer
         if (layer > 10)
           layer = layer - 10;  // ignore 1/2 modules
         if (status > 0) {      // data
           countPixels++;
           countPixelsInFed++;
           fedchannelsize[fedChannel - 1]++;
 
         } else if (status < 0) {  // error word
           countErrorsInFed++;
           //if( status == -6 || status == -5)
           if (printErrors)
             cout << " Bad stats for FED " << fedId << " Event " << eventId << "/" << countAllEvents << " chan "
                  << fedChannel << " status " << status << endl;
           status = abs(status);
           // 2 - wrong channel
           // 3 - wrong pix or dcol
           // 4 - wrong roc
           // 5 - pix=0
           // 6 - double pixel
           // 10 - timeout ()
           // 11 - ene ()
           // 12 - mum pf rocs error ()
           // 13 - fsm ()
           // 14 - overflow ()
           // 15 - trailer ()
           // 16 - fifo  (30)
           // 17 - reset/resync NOT INCLUDED YET
 
           switch (status) {
             case (10): {  // Timeout
 
               countErrors[10]++;
               fedErrorsTime[fedId][(fedChannel - 1)]++;
               hfed2DErrors10->Fill(float(fedId), float(fedChannel));
               hfed2DErrors10ls->Fill(float(lumiBlock), float(fedId));  //errors
 
               herrorTimels->Fill(float(lumiBlock));
               if (layer == 1)
                 herrorTimels1->Fill(float(lumiBlock));
               else if (layer == 2)
                 herrorTimels2->Fill(float(lumiBlock));
               else if (layer == 3)
                 herrorTimels3->Fill(float(lumiBlock));
               else if (layer == 0)
                 herrorTimels0->Fill(float(lumiBlock));
 
               //hbx1->Fill(float(bx));
               break;
             }
 
             case (14): {  // OVER
 
               countErrors[14]++;
               fedErrorsOver[fedId][(fedChannel - 1)]++;
               hfed2DErrors14->Fill(float(fedId), float(fedChannel));
               hfed2DErrors14ls->Fill(float(lumiBlock), float(fedId));  //errors
 
               herrorOverls->Fill(float(lumiBlock));
               if (layer == 1)
                 herrorOverls1->Fill(float(lumiBlock));
               else if (layer == 2)
                 herrorOverls2->Fill(float(lumiBlock));
               else if (layer == 3)
                 herrorOverls3->Fill(float(lumiBlock));
               else if (layer == 0)
                 herrorOverls0->Fill(float(lumiBlock));
               //hbx2->Fill(float(bx));
               break;
             }
 
             case (11): {  // ENE
 
               countErrors[11]++;
               hfed2DErrors11->Fill(float(fedId), float(fedChannel));
               hfed2DErrors11ls->Fill(float(lumiBlock), float(fedId));  //errors
               //hbx3->Fill(float(bx));
               fedErrorsENE[fedId][(fedChannel - 1)]++;
               break;
             }
 
             case (16): {  //FIFO
 
               countErrors[16]++;
               hfed2DErrors16->Fill(float(fedId), float(fedChannel));
               hfed2DErrors16ls->Fill(float(lumiBlock), float(fedId));  //errors
               break;
             }
 
             case (12): {  // NOR
 
               countErrors[12]++;
               hfed2DErrors12->Fill(float(fedId), float(fedChannel));
               hfed2DErrors12ls->Fill(float(lumiBlock), float(fedId));  //errors
               //hbx5->Fill(float(bx));
               break;
             }
 
             case (15): {  // TBM Trailer
 
               countErrors[15]++;
               hfed2DErrors15->Fill(float(fedId), float(fedChannel));
               hfed2DErrors15ls->Fill(float(lumiBlock), float(fedId));  //errors
               break;
             }
 
             case (13): {  // FSM
 
               countErrors[13]++;
               hfed2DErrors13->Fill(float(fedId), float(fedChannel));
               hfed2DErrors13ls->Fill(float(lumiBlock), float(fedId));  //errors
               break;
             }
 
             case (3): {  //  inv. pix-dcol
 
               countErrors[3]++;
               hfed2DErrors3->Fill(float(fedId), float(fedChannel));
               hfed2DErrors3ls->Fill(float(lumiBlock), float(fedId));  //errors
               //hbx8->Fill(float(bx));
               break;
             }
 
             case (4): {  // inv roc
               countErrors[4]++;
               hfed2DErrors4->Fill(float(fedId), float(fedChannel));
               hfed2DErrors4ls->Fill(float(lumiBlock), float(fedId));  //errors
               //hbx9->Fill(float(bx));
               break;
             }
 
             case (5): {  // pix=0
               countErrors[5]++;
               hfed2DErrors5->Fill(float(fedId), float(fedChannel));
               hfed2DErrors5ls->Fill(float(lumiBlock), float(fedId));  //errors
               //hbx10->Fill(float(bx));
 
               hroc000->Fill(float(stat1));  // count rocs
               hcount000->Fill(float(stat2));
               hcount0002->Fill(float(fedId), float(stat2));
               break;
             }
 
             case (6): {  // double pix
 
               countErrors[6]++;
               hfed2DErrors6->Fill(float(fedId), float(fedChannel));
               hfed2DErrors6ls->Fill(float(lumiBlock), float(fedId));  //errors
               //hbx12->Fill(float(bx));
 
               hrocDouble->Fill(float(stat1));  // count rocs
               hcountDouble->Fill(float(stat2));
               hcountDouble2->Fill(float(fedId), float(stat2));
               break;
             }
 
             case (1): {  // unknown
               countErrors[1]++;
               hfed2DErrors1->Fill(float(fedId), float(fedChannel));
               hfed2DErrors1ls->Fill(float(lumiBlock), float(fedId));  //errors
               break;
             }
 
           }  // end switch
 
           if (status < 20)
             errorType[status]++;
 
           //herrorType0->Fill(float(status));
           //herrorFed0->Fill(float(fedId));
           //herrorChan0->Fill(float(fedChannel));
 
           hfed2d->Fill(float(fedId), float(status));
 
           if (status >= 10) {  // hard errors
             // Type - 1 Errors
 
             countErrorsInFed1++;
             hfedErrorType1ls->Fill(float(lumiBlock), float(fedId));  // hard errors
             hfed2DErrorsType1->Fill(float(fedId), float(fedChannel));
 
             herrorType1->Fill(float(status));
             herrorType1Fed->Fill(float(fedId));
             herrorType1Chan->Fill(float(fedChannel));
 
             fedErrors[fedId][(fedChannel - 1)]++;
 
           } else if (status > 0) {  // decode errors
             // Type 2 errprs
 
             countErrorsInFed2++;
             hfedErrorType2ls->Fill(float(lumiBlock), float(fedId));  // decode errors
             hfed2DErrorsType2->Fill(float(fedId), float(fedChannel));
 
             herrorType2->Fill(float(status));
             herrorType2Fed->Fill(float(fedId));
             herrorType2Chan->Fill(float(fedChannel));
 
             if (status == 5)
               decodeErrors000[fedId][(fedChannel - 1)]++;
             else if (status == 6)
               decodeErrorsDouble[fedId][(fedChannel - 1)]++;
             else
               decodeErrors[fedId][(fedChannel - 1)]++;
           }
         }
       }  // for  1/2 word
 
     }  // loop over longlong  words
 
     countTotErrors += countErrorsInFed;
     countErrorsPerEvent += countErrorsInFed;
     countErrorsPerEvent1 += countErrorsInFed1;
     countErrorsPerEvent2 += countErrorsInFed2;
 
     //convert data to digi (dummy for the moment)
     //formatter.interpretRawData( dummyErrorBool, fedId, rawData, collection, errors);
     //cout<<dummyErrorBool<<" "<<digis.size()<<" "<<errors.size()<<endl;
 
     if (countPixelsInFed > 0) {
       sumFedPixels[fedId] += countPixelsInFed;
     }
 
     hpixels->Fill(float(countPixelsInFed));
     hpixels0->Fill(float(countPixelsInFed));
     if (countPixelsInFed > 0)
       hpixels1->Fill(float(countPixelsInFed));
     if (countPixelsInFed > 0 && fedId < 32)
       hpixels2->Fill(float(countPixelsInFed));
     if (countPixelsInFed > 0 && fedId >= 32)
       hpixels3->Fill(float(countPixelsInFed));
     herrors->Fill(float(countErrorsInFed));
 
     for (int i = 0; i < 36; ++i) {
       hfedchannelsize->Fill(float(fedId), float(i + 1), float(fedchannelsize[i]));
       if (fedId < 32) {
         hfedchannelsizeb->Fill(float(fedchannelsize[i]));
         int layer = MyDecode::checkLayerLink(fedId, i);  // get bpix layer
         if (layer > 10)
           layer = layer - 10;  // ignore 1/2 modules
         if (layer == 3)
           hfedchannelsizeb3->Fill(float(fedchannelsize[i]));  // layer 3
         else if (layer == 2)
           hfedchannelsizeb2->Fill(float(fedchannelsize[i]));  // layer 2
         else if (layer == 1)
           hfedchannelsizeb1->Fill(float(fedchannelsize[i]));  // layer 1
         else
           cout << " Cannot be " << layer << " " << fedId << " " << i << endl;
       } else
         hfedchannelsizef->Fill(float(fedchannelsize[i]));  // fpix
     }
     //    if(fedId == fedIds.first || countPixelsInFed>0 || countErrorsInFed>0 )  {
     //       eventId = MyDecode::header(*header, true);
     //       if(countPixelsInFed>0 || countErrorsInFed>0 ) cout<<"fed "<<fedId<<" pix "<<countPixelsInFed<<" err "<<countErrorsInFed<<endl;
     //       status = MyDecode::trailer(*trailer,true);
     //     }
 
 #ifdef OUTFILE
     // print number of bytes per fed, CSV
     if (fedId == fedIds.second)
       outfile << (nWords * 8) << endl;
     else
       outfile << (nWords * 8) << ",";
 #endif
 
   }  // loop over feds
 
   htotPixels->Fill(float(countPixels));
   htotPixels0->Fill(float(countPixels));
   htotErrors->Fill(float(countErrorsPerEvent));
 
   htotPixelsls->Fill(float(lumiBlock), float(countPixels));
   htotPixelsbx->Fill(float(bx), float(countPixels));
 
   herrorType1ls->Fill(float(lumiBlock), float(countErrorsPerEvent1));
   herrorType2ls->Fill(float(lumiBlock), float(countErrorsPerEvent2));
 
   herror1ls->Fill(float(lumiBlock), float(countErrors[1]));
   herror3ls->Fill(float(lumiBlock), float(countErrors[3]));
   herror4ls->Fill(float(lumiBlock), float(countErrors[4]));
   herror5ls->Fill(float(lumiBlock), float(countErrors[5]));
   herror6ls->Fill(float(lumiBlock), float(countErrors[6]));
   herror10ls->Fill(float(lumiBlock), float(countErrors[10]));
   herror11ls->Fill(float(lumiBlock), float(countErrors[11]));
   herror12ls->Fill(float(lumiBlock), float(countErrors[12]));
   herror13ls->Fill(float(lumiBlock), float(countErrors[13]));
   herror14ls->Fill(float(lumiBlock), float(countErrors[14]));
   herror15ls->Fill(float(lumiBlock), float(countErrors[15]));
   herror16ls->Fill(float(lumiBlock), float(countErrors[16]));
 
   herrorType1bx->Fill(float(bx), float(countErrorsPerEvent1));
   herrorType2bx->Fill(float(bx), float(countErrorsPerEvent2));
 
   aveFedSize /= 32.;
   hsize3->Fill(aveFedSize);
   //hsize2dls->Fill(float(lumiBlock),aveFedSize);
 
   havsizels->Fill(float(lumiBlock), aveFedSize);
   havsizebx->Fill(float(bx), aveFedSize);
 
   if (countPixels > 0) {
     hlumi->Fill(float(lumiBlock));
     hbx->Fill(float(bx));
     htotPixels1->Fill(float(countPixels));
 
     //cout<<"EVENT: "<<countEvents<<" "<<eventId<<" pixels "<<countPixels<<" errors "<<countTotErrors<<endl;
     sumPixels += countPixels;
     countEvents++;
     //int dummy=0;
     //cout<<" : ";
     //cin>>dummy;
   }  // end if
 
 }  // end analyze
 
 // 2 - wrong channel
 // 4 - wrong roc
 // 3 - wrong pix or dcol
 // 5 - pix=0
 // 6 - double pix
 // 10 - timeout ()
 // 11 - ene ()
 // 12 - mum pf rocs error ()
 // 13 - fsm ()
 // 14 - overflow ()
 // 15 - trailer ()
 // 16 - fifo  (30)
 // 17 - reset/resync NOT INCLUDED YET
 
 #include "FWCore/Framework/interface/MakerMacros.h"
 DEFINE_FWK_MODULE(SiPixelRawDumper);

This page was automatically generated by the 2.2.1 LXR engine. The LXR team