d7/d93/HcalRawDataMonitor_8cc_source.html

 #include "DQM/HcalMonitorTasks/interface/HcalRawDataMonitor.h"

 #include "EventFilter/HcalRawToDigi/interface/HcalDCCHeader.h"

 #include "CalibFormats/HcalObjects/interface/HcalDbService.h"

 #include "CalibFormats/HcalObjects/interface/HcalDbRecord.h"

 #include "FWCore/Framework/interface/LuminosityBlock.h"


 HcalRawDataMonitor::HcalRawDataMonitor(const edm::ParameterSet& ps) {

   Online_                = ps.getParameter<bool>("online");

   mergeRuns_             = ps.getParameter<bool>("mergeRuns");

   enableCleanup_         = ps.getUntrackedParameter<bool>("enableCleanup");

   debug_                 = ps.getUntrackedParameter<int>("debug",0);

   prefixME_              = ps.getUntrackedParameter<std::string>("subSystemFolder", "Hcal/"); // Hcal

   if (prefixME_.substr(prefixME_.size()-1,prefixME_.size())!="/")

     prefixME_.append("/");

   subdir_                = ps.getUntrackedParameter<std::string>("TaskFolder", "RawDataMonitor_Hcal/"); // RawDataMonitor_Hcal

   if (subdir_.size()>0 && subdir_.substr(subdir_.size()-1,subdir_.size())!="/")

     subdir_.append("/");

   subdir_=prefixME_+subdir_;

   AllowedCalibTypes_     = ps.getUntrackedParameter<std::vector<int> > ("AllowedCalibTypes");

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

   NLumiBlocks_           = ps.getUntrackedParameter<int>("NLumiBlocks",-1);

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


   FEDRawDataCollection_  = ps.getUntrackedParameter<edm::InputTag>("FEDRawDataCollection");

   digiLabel_             = ps.getUntrackedParameter<edm::InputTag>("digiLabel");


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


   //inputLabelReport_      = ps.getUntrackedParameter<edm::InputTag>("UnpackerReport");


   // Initialize an array of MonitorElements

   meChann_DataIntegrityCheck_[0] =meCh_DataIntegrityFED00_;

   meChann_DataIntegrityCheck_[1] =meCh_DataIntegrityFED01_;

   meChann_DataIntegrityCheck_[2] =meCh_DataIntegrityFED02_;

   meChann_DataIntegrityCheck_[3] =meCh_DataIntegrityFED03_;

   meChann_DataIntegrityCheck_[4] =meCh_DataIntegrityFED04_;

   meChann_DataIntegrityCheck_[5] =meCh_DataIntegrityFED05_;

   meChann_DataIntegrityCheck_[6] =meCh_DataIntegrityFED06_;

   meChann_DataIntegrityCheck_[7] =meCh_DataIntegrityFED07_;

   meChann_DataIntegrityCheck_[8] =meCh_DataIntegrityFED08_;

   meChann_DataIntegrityCheck_[9] =meCh_DataIntegrityFED09_;

   meChann_DataIntegrityCheck_[10]=meCh_DataIntegrityFED10_;

   meChann_DataIntegrityCheck_[11]=meCh_DataIntegrityFED11_;

   meChann_DataIntegrityCheck_[12]=meCh_DataIntegrityFED12_;

   meChann_DataIntegrityCheck_[13]=meCh_DataIntegrityFED13_;

   meChann_DataIntegrityCheck_[14]=meCh_DataIntegrityFED14_;

   meChann_DataIntegrityCheck_[15]=meCh_DataIntegrityFED15_;

   meChann_DataIntegrityCheck_[16]=meCh_DataIntegrityFED16_;

   meChann_DataIntegrityCheck_[17]=meCh_DataIntegrityFED17_;

   meChann_DataIntegrityCheck_[18]=meCh_DataIntegrityFED18_;

   meChann_DataIntegrityCheck_[19]=meCh_DataIntegrityFED19_;

   meChann_DataIntegrityCheck_[20]=meCh_DataIntegrityFED20_;

   meChann_DataIntegrityCheck_[21]=meCh_DataIntegrityFED21_;

   meChann_DataIntegrityCheck_[22]=meCh_DataIntegrityFED22_;

   meChann_DataIntegrityCheck_[23]=meCh_DataIntegrityFED23_;

   meChann_DataIntegrityCheck_[24]=meCh_DataIntegrityFED24_;

   meChann_DataIntegrityCheck_[25]=meCh_DataIntegrityFED25_;

   meChann_DataIntegrityCheck_[26]=meCh_DataIntegrityFED26_;

   meChann_DataIntegrityCheck_[27]=meCh_DataIntegrityFED27_;

   meChann_DataIntegrityCheck_[28]=meCh_DataIntegrityFED28_;

   meChann_DataIntegrityCheck_[29]=meCh_DataIntegrityFED29_;

   meChann_DataIntegrityCheck_[30]=meCh_DataIntegrityFED30_;

   meChann_DataIntegrityCheck_[31]=meCh_DataIntegrityFED31_;


   // register for data access

   tok_raw_ = consumes<FEDRawDataCollection>(FEDRawDataCollection_);

   tok_unpack_ = consumes<HcalUnpackerReport>(digiLabel_);


   this->reset();

 } // HcalRawDataMonitor::HcalRawDataMonitor()


 // destructor

 HcalRawDataMonitor::~HcalRawDataMonitor(){}


 // reset

 void HcalRawDataMonitor::reset(void)

 {


   for (int f=0; f<NUMDCCS; f++) {

     for (int s=0; s<15; s++) {

       UScount[f][s]=0;}}


   for (int x=0; x<THREE_FED; x++)

     for (int y=0; y<THREE_SPG; y++)

       HalfHTRDataCorruptionIndicators_  [x][y]=0;


   for (int x=0; x<THREE_FED; x++)

     for (int y=0; y<THREE_SPG; y++)

       LRBDataCorruptionIndicators_  [x][y]=0;


   for (int x=0; x<TWO___FED; x++)

     for (int y=0; y<TWO__SPGT; y++)

       ChannSumm_DataIntegrityCheck_[x][y]=0;


   for (int x=0; x<TWO___FED; x++)

     for (int y=0; y<THREE_SPG; y++)

       DataFlowInd_[x][y]=0;


   for (int f=0; f<NUMDCCS; f++)

     for (int x=0; x<  TWO_CHANN; x++)

       for (int y=0; y<TWO__SPGT; y++)

     Chann_DataIntegrityCheck_  [f][x][y]=0;


   for (int i=0; i<(NUMDCCS * NUMSPIGS * HTRCHANMAX); i++)

     hashedHcalDetId_[i]=HcalDetId::Undefined;


   for (int d=0; d<DEPTHBINS; d++) {

     for (int eta=0; eta<ETABINS; eta++) {

       for (int phi=0; phi<PHIBINS; phi++){

     uniqcounter[eta][phi][d] = 0.0;

     problemcount[eta][phi][d] = 0.0;

     problemfound[eta][phi][d] = false;

       }

     }

   }


   // Properly initialze bylumi counters.

   NumBadHB=0;

   NumBadHE=0;

   NumBadHO=0;

   NumBadHF=0;

   NumBadHFLUMI=0;

   NumBadHO0=0;

   NumBadHO12=0;


 } // HcalRawDataMonitor::HcalRawDataMonitor()


 // BeginRun

 void HcalRawDataMonitor::beginRun(const edm::Run& run, const edm::EventSetup& c){

   HcalBaseDQMonitor::beginRun(run,c);

   edm::ESHandle<HcalDbService> pSetup;

   c.get<HcalDbRecord>().get( pSetup );


   readoutMap_=pSetup->getHcalMapping();

   DetId detid_;

   HcalDetId hcaldetid_;


   // Build a map of readout hardware unit to calorimeter channel

   std::vector <HcalElectronicsId> AllElIds = readoutMap_->allElectronicsIdPrecision();

   uint32_t itsdcc    =0;

   uint32_t itsspigot =0;

   uint32_t itshtrchan=0;


   // by looping over all precision (non-trigger) items.

   for (std::vector <HcalElectronicsId>::iterator eid = AllElIds.begin();

        eid != AllElIds.end();

        eid++) {


     //Get the HcalDetId from the HcalElectronicsId

     detid_ = readoutMap_->lookup(*eid);

     // NULL if illegal; ignore

     if (!detid_.null()) {

       if (detid_.det()!=4) continue; //not Hcal

       if (detid_.subdetId()!=HcalBarrel &&

       detid_.subdetId()!=HcalEndcap &&

       detid_.subdetId()!=HcalOuter  &&

       detid_.subdetId()!=HcalForward) continue;


       itsdcc    =(uint32_t) eid->dccid();

       itsspigot =(uint32_t) eid->spigot();

       itshtrchan=(uint32_t) eid->htrChanId();

       hcaldetid_ = HcalDetId(detid_);

       stashHDI(hashup(itsdcc,itsspigot,itshtrchan),

            hcaldetid_);

     } // if (!detid_.null())

   }

 }


 // Begin LumiBlock

 void HcalRawDataMonitor::beginLuminosityBlock(const edm::LuminosityBlock& lumiSeg,

                           const edm::EventSetup& c) {

   if (LumiInOrder(lumiSeg.luminosityBlock())==false) return;

   HcalBaseDQMonitor::beginLuminosityBlock(lumiSeg,c);

   //zeroCounters(); // zero hot cell counters at the start of each luminosity block

   ProblemsCurrentLB->Reset();

   return;

 }

 // Setup

 void HcalRawDataMonitor::setup(void){

   // Call base class setup

   HcalBaseDQMonitor::setup();

   if (!dbe_) {

     if (debug_>1)

       std::cout <<"<HcalRawDataMonitor::setup>  No DQMStore instance available. Bailing out."<<std::endl;

     return;}


   /******* Set up all histograms  ********/

   if (debug_>1)

     std::cout <<"<HcalRawDataMonitor::beginRun>  Setting up histograms"<<std::endl;


   dbe_->setCurrentFolder(subdir_);

   ProblemsVsLB=dbe_->bookProfile("RAW_Problems_HCAL_vs_LS",

                  "Total HCAL RAW Problems vs lumi section",

                  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);


   ProblemsVsLB_HB=dbe_->bookProfile("Total_RAW_Problems_HB_vs_LS",

                     "Total HB RAW Problems vs lumi section",

                     NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,3000);

   ProblemsVsLB_HE=dbe_->bookProfile("Total_RAW_Problems_HE_vs_LS",

                     "Total HE RAW Problems vs lumi section",

                     NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,3000);

   ProblemsVsLB_HO=dbe_->bookProfile("Total_RAW_Problems_HO_vs_LS",

                     "Total HO RAW Problems vs lumi section",

                     NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,3000);

   ProblemsVsLB_HF=dbe_->bookProfile("Total_RAW_Problems_HF_vs_LS",

                     "Total HF RAW Problems vs lumi section",

                     NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,2000);

   ProblemsVsLB_HBHEHF=dbe_->bookProfile("Total_RAW_Problems_HBHEHF_vs_LS",

                     "Total HBHEHF RAW Problems vs lumi section",

                     NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,2000);


   ProblemsVsLB->getTProfile()->SetMarkerStyle(20);

   ProblemsVsLB_HB->getTProfile()->SetMarkerStyle(20);

   ProblemsVsLB_HE->getTProfile()->SetMarkerStyle(20);

   ProblemsVsLB_HO->getTProfile()->SetMarkerStyle(20);

   ProblemsVsLB_HF->getTProfile()->SetMarkerStyle(20);

   ProblemsVsLB_HBHEHF->getTProfile()->SetMarkerStyle(20);

   MonitorElement* excludeHO2=dbe_->bookInt("ExcludeHOring2");

   // Fill with 0 if ring is not to be excluded; fill with 1 if it is to be excluded

   if (excludeHO2) excludeHO2->Fill(excludeHORing2_==true ? 1 : 0);


   //  Already done in base class:

   //dbe_->setCurrentFolder(subdir_);

   //meIevt_ = dbe_->bookInt("EventsProcessed");

   //if (meIevt_) meIevt_->Fill(-1);

   //meLevt_ = dbe_->bookInt("EventsProcessed_currentLS");

   //if (meLevt_) meLevt_->Fill(-1);

   //meTevt_ = dbe_->bookInt("EventsProcessed_All");

   //if (meTevt_) meTevt_->Fill(-1);

   //meTevtHist_=dbe_->book1D("EventsProcessed_AllHists","Counter of Events Processed By This Task",1,0.5,1.5);

   //if (meTevtHist_) meTevtHist_->Reset();


   std::string type;


   dbe_->setCurrentFolder(subdir_ + "Corruption");

   type = "01 Common Data Format violations";

   meCDFErrorFound_ = dbe_->book2D(type,type,32,699.5,731.5,9,0.5,9.5);

   meCDFErrorFound_->setAxisTitle("HCAL FED ID", 1);

   meCDFErrorFound_->setBinLabel(1, "Hdr1BitUnset", 2);

   meCDFErrorFound_->setBinLabel(2, "FmtNumChange", 2);

   meCDFErrorFound_->setBinLabel(3, "BOE not '0x5'", 2);

   meCDFErrorFound_->setBinLabel(4, "Hdr2Bit Set", 2);

   meCDFErrorFound_->setBinLabel(5, "Hdr1 36-55", 2);

   meCDFErrorFound_->setBinLabel(6, "BOE not 0", 2);

   meCDFErrorFound_->setBinLabel(7, "Trlr1Bit Set", 2);

   meCDFErrorFound_->setBinLabel(8, "Size Error", 2);

   meCDFErrorFound_->setBinLabel(9, "TrailerBad", 2);


   type = "02 DCC Event Format violation";

   meDCCEventFormatError_ = dbe_->book2D(type,type,32,699.5,731.5,6,0.5,6.5);

   meDCCEventFormatError_->setAxisTitle("HCAL FED ID", 1);

   meDCCEventFormatError_->setBinLabel(1, "FmtVers Changed", 2);

   meDCCEventFormatError_->setBinLabel(2, "StrayBits Changed", 2);

   meDCCEventFormatError_->setBinLabel(3, "HTRStatusPad", 2);

   meDCCEventFormatError_->setBinLabel(4, "32bitPadErr", 2);

   meDCCEventFormatError_->setBinLabel(5, "Number Mismatch Bit Miscalc", 2);

   meDCCEventFormatError_->setBinLabel(6, "Low 8 HTR Status Bits Miscopy", 2);


   type = "04 HTR BCN when OrN Diff";

   meBCNwhenOrNDiff_ = dbe_->book1D(type,type,3564,-0.5,3563.5);

   meBCNwhenOrNDiff_->setAxisTitle("BCN",1);

   meBCNwhenOrNDiff_->setAxisTitle("# of Entries",2);


   type = "03 OrN NonZero Difference HTR - DCC";

   meOrNCheck_ = dbe_->book1D(type,type,65,-32.5,32.5);

   meOrNCheck_->setAxisTitle("htr OrN - dcc OrN",1);


   type = "03 OrN Inconsistent - HTR vs DCC";

   meOrNSynch_= dbe_->book2D(type,type,32,700,732, 15,0,15);

   meOrNSynch_->setAxisTitle("FED #",1);

   meOrNSynch_->setAxisTitle("Spigot #",2);


   type = "05 BCN NonZero Difference HTR - DCC";

   meBCNCheck_ = dbe_->book1D(type,type,501,-250.5,250.5);

   meBCNCheck_->setAxisTitle("htr BCN - dcc BCN",1);


   type = "05 BCN Inconsistent - HTR vs DCC";

   meBCNSynch_= dbe_->book2D(type,type,32,700,732, 15,0,15);

   meBCNSynch_->setAxisTitle("FED #",1);

   meBCNSynch_->setAxisTitle("Slot #",2);


   type = "06 EvN NonZero Difference HTR - DCC";

   meEvtNCheck_ = dbe_->book1D(type,type,601,-300.5,300.5);

   meEvtNCheck_->setAxisTitle("htr Evt # - dcc Evt #",1);


   type = "06 EvN Inconsistent - HTR vs DCC";

   meEvtNumberSynch_= dbe_->book2D(type,type,32,700,732, 15,0,15);

   meEvtNumberSynch_->setAxisTitle("FED #",1);

   meEvtNumberSynch_->setAxisTitle("Slot #",2);


   //     ----------------

   //     | E!P | UE | TR |

   // ----|  ND | OV | ID |

   // | T | CRC | ST | ODD|

   // --------------------

   type="07 LRB Data Corruption Indicators";

   meLRBDataCorruptionIndicators_= dbe_->book2D(type,type,

                         THREE_FED,0,THREE_FED,

                         THREE_SPG,0,THREE_SPG);

   label_xFEDs   (meLRBDataCorruptionIndicators_, 4); // 3 bins + 1 margin per ch.

   label_ySpigots(meLRBDataCorruptionIndicators_, 4); // 3 bins + 1 margin each spgt


   //     ----------------

   //     | CT | BE |    |

   //     | HM | 15 | WW | (Wrong Wordcount)

   //     | TM | CK | IW | (Illegal Wordcount)

   //     ----------------

   type="08 Half-HTR Data Corruption Indicators";

   meHalfHTRDataCorruptionIndicators_= dbe_->book2D(type,type,

                             THREE_FED,0,THREE_FED,

                             THREE_SPG,0,THREE_SPG);

   label_xFEDs   (meHalfHTRDataCorruptionIndicators_, 4); // 3 bins + 1 margin per ch.

   label_ySpigots(meHalfHTRDataCorruptionIndicators_, 4); // 3 bins + 1 margin each spgt


   //    ------------

   //    | !DV | Er  |

   //    | NTS | Cap |

   //    ------------

   type = "09 Channel Integrity Summarized by Spigot";

   meChannSumm_DataIntegrityCheck_= dbe_->book2D(type,type,

                          TWO___FED,0,TWO___FED,

                          TWO__SPGT,0,TWO__SPGT);

   label_xFEDs   (meChannSumm_DataIntegrityCheck_, 3); // 2 bins + 1 margin per ch.

   label_ySpigots(meChannSumm_DataIntegrityCheck_, 3); // 2 bins + 1 margin per spgt


   dbe_->setCurrentFolder(subdir_ + "Corruption/Channel Data Integrity");

   char label[256];

   for (int f=0; f<NUMDCCS; f++){

     snprintf(label, 256, "FED %03d Channel Integrity", f+700);

     meChann_DataIntegrityCheck_[f] =  dbe_->book2D(label,label,

                             TWO_CHANN,0,TWO_CHANN,

                             TWO__SPGT,0,TWO__SPGT);

     label_xChanns (meChann_DataIntegrityCheck_[f], 3); // 2 bins + 1 margin per ch.

     label_ySpigots(meChann_DataIntegrityCheck_[f], 3); // 2 bins + 1 margin per spgt

     ;}


   dbe_->setCurrentFolder(subdir_ + "Data Flow");

   type="DCC Event Counts";

   mefedEntries_ = dbe_->book1D(type,type,32,699.5,731.5);


   type = "BCN from DCCs";

   medccBCN_ = dbe_->book1D(type,type,3564,-0.5,3563.5);

   medccBCN_->setAxisTitle("BCN",1);

   medccBCN_->setAxisTitle("# of Entries",2);


   type = "BCN from HTRs";

   meBCN_ = dbe_->book1D(type,type,3564,-0.5,3563.5);

   meBCN_->setAxisTitle("BCN",1);

   meBCN_->setAxisTitle("# of Entries",2);


   type = "DCC Data Block Size Distribution";

   meFEDRawDataSizes_=dbe_->book1D(type,type,1200,-0.5,12000.5);

   meFEDRawDataSizes_->setAxisTitle("# of bytes",1);

   meFEDRawDataSizes_->setAxisTitle("# of Data Blocks",2);


   type = "DCC Data Block Size Profile";

   meEvFragSize_ = dbe_->bookProfile(type,type,32,699.5,731.5,100,-1000.0,12000.0,"");

   type = "DCC Data Block Size Each FED";

   meEvFragSize2_ =  dbe_->book2D(type,type,64,699.5,731.5, 240,0,12000);


   //     ------------

   //     | OW | OFW |    "Two Caps HTR; Three Caps FED."

   //     | BZ | BSY |

   //     | EE | RL  |

   // ----------------

   // | CE |            (corrected error, Hamming code)

   // ------

   type = "01 Data Flow Indicators";

   meDataFlowInd_= dbe_->book2D(type,type,

                 TWO___FED,0,TWO___FED,

                 THREE_SPG,0,THREE_SPG);

   label_xFEDs   (meDataFlowInd_, 3); // 2 bins + 1 margin per ch.

   label_ySpigots(meDataFlowInd_, 4); // 3 bins + 1 margin each spgt


   dbe_->setCurrentFolder(subdir_ + "Diagnostics");


   type = "DCC Firmware Version";

   meDCCVersion_ = dbe_->bookProfile(type,type, 32, 699.5, 731.5, 256, -0.5, 255.5);

   meDCCVersion_ ->setAxisTitle("FED ID", 1);


   type = "HTR Status Word HBHE";

   HTR_StatusWd_HBHE =  dbe_->book1D(type,type,16,-0.5,15.5);

   labelHTRBits(HTR_StatusWd_HBHE,1);


   type = "HTR Status Word HF";

   HTR_StatusWd_HF =  dbe_->book1D(type,type,16,-0.5,15.5);

   labelHTRBits(HTR_StatusWd_HF,1);


   type = "HTR Status Word HO";

   HTR_StatusWd_HO = dbe_->book1D(type,type,16,-0.5,15.5);

   labelHTRBits(HTR_StatusWd_HO,1);


   int maxbits = 16;//Look at all 16 bits of the Error Words

   type = "HTR Status Word by Crate";

   meStatusWdCrate_ = dbe_->book2D(type,type,18,-0.5,17.5,maxbits,-0.5,maxbits-0.5);

   meStatusWdCrate_ -> setAxisTitle("Crate #",1);

   labelHTRBits(meStatusWdCrate_,2);


   type = "Unpacking - HcalHTRData check failures";

   meInvHTRData_= dbe_->book2D(type,type,16,-0.5,15.5,32,699.5,731.5);

   meInvHTRData_->setAxisTitle("Spigot #",1);

   meInvHTRData_->setAxisTitle("DCC #",2);


   type = "HTR Fiber Orbit Message BCN";

   meFibBCN_ = dbe_->book1D(type,type,3564,-0.5,3563.5);

   meFibBCN_->setAxisTitle("BCN of Fib Orb Msg",1);


   type = "HTR Status Word - Crate 0";

   meCrate0HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate0HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate0HTRStatus_,2);


   type = "HTR Status Word - Crate 1";

   meCrate1HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate1HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate1HTRStatus_,2);


   type = "HTR Status Word - Crate 2";

   meCrate2HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate2HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate2HTRStatus_,2);


   type = "HTR Status Word - Crate 3";

   meCrate3HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate3HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate3HTRStatus_,2);


   type = "HTR Status Word - Crate 4";

   meCrate4HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate4HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate4HTRStatus_,2);


   type = "HTR Status Word - Crate 5";

   meCrate5HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate5HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate5HTRStatus_,2);


   type = "HTR Status Word - Crate 6";

   meCrate6HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate6HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate6HTRStatus_,2);


   type = "HTR Status Word - Crate 7";

   meCrate7HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate7HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate7HTRStatus_,2);


   type = "HTR Status Word - Crate 9";

   meCrate9HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate9HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate9HTRStatus_,2);


   type = "HTR Status Word - Crate 10";

   meCrate10HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate10HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate10HTRStatus_,2);


   type = "HTR Status Word - Crate 11";

   meCrate11HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate11HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate11HTRStatus_,2);


   type = "HTR Status Word - Crate 12";

   meCrate12HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate12HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate12HTRStatus_,2);


   type = "HTR Status Word - Crate 13";

   meCrate13HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate13HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate13HTRStatus_,2);


   type = "HTR Status Word - Crate 14";

   meCrate14HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate14HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate14HTRStatus_,2);


   type = "HTR Status Word - Crate 15";

   meCrate15HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate15HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate15HTRStatus_,2);


   type = "HTR Status Word - Crate 17";

   meCrate17HTRStatus_ = dbe_->book2D(type,type,40,-0.25,19.75,maxbits,-0.5,maxbits-0.5);

   meCrate17HTRStatus_ ->setAxisTitle("Slot #",1);

   labelHTRBits(meCrate17HTRStatus_,2);


   type = "HTR UnSuppressed Event Fractions";

   meUSFractSpigs_ = dbe_->book1D(type,type,481,0,481);

   for(int f=0; f<NUMDCCS; f++) {

     snprintf(label, 256, "FED 7%02d", f);

     meUSFractSpigs_->setBinLabel(1+(HcalDCCHeader::SPIGOT_COUNT*f), label);

     for(int s=1; s<HcalDCCHeader::SPIGOT_COUNT; s++) {

       snprintf(label, 256, "sp%02d", s);

       meUSFractSpigs_->setBinLabel(1+(HcalDCCHeader::SPIGOT_COUNT*f)+s, label);}}


   // Firmware version

   type = "HTR Firmware Version";

   //  Maybe change to Profile histo eventually

   //meHTRFWVersion_ = dbe_->bookProfile(type,type,18,-0.5,17.5,245,10.0,255.0,"");

   meHTRFWVersion_ = dbe_->book2D(type,type ,18,-0.5,17.5,180,75.5,255.5);

   meHTRFWVersion_->setAxisTitle("Crate #",1);

   meHTRFWVersion_->setAxisTitle("HTR Firmware Version",2);


   type = "HTR Fiber 1 Orbit Message BCNs";

   meFib1OrbMsgBCN_= dbe_->book2D(type,type,40,-0.25,19.75,18,-0.5,17.5);

   type = "HTR Fiber 2 Orbit Message BCNs";

   meFib2OrbMsgBCN_= dbe_->book2D(type,type,40,-0.25,19.75,18,-0.5,17.5);

   type = "HTR Fiber 3 Orbit Message BCNs";

   meFib3OrbMsgBCN_= dbe_->book2D(type,type,40,-0.25,19.75,18,-0.5,17.5);

   type = "HTR Fiber 4 Orbit Message BCNs";

   meFib4OrbMsgBCN_= dbe_->book2D(type,type,40,-0.25,19.75,18,-0.5,17.5);

   type = "HTR Fiber 5 Orbit Message BCNs";

   meFib5OrbMsgBCN_= dbe_->book2D(type,type,40,-0.25,19.75,18,-0.5,17.5);

   type = "HTR Fiber 6 Orbit Message BCNs";

   meFib6OrbMsgBCN_= dbe_->book2D(type,type,40,-0.25,19.75,18,-0.5,17.5);

   type = "HTR Fiber 7 Orbit Message BCNs";

   meFib7OrbMsgBCN_= dbe_->book2D(type,type,40,-0.25,19.75,18,-0.5,17.5);

   type = "HTR Fiber 8 Orbit Message BCNs";

   meFib8OrbMsgBCN_= dbe_->book2D(type,type,40,-0.25,19.75,18,-0.5,17.5);


 }


 // Analyze

 void HcalRawDataMonitor::analyze(const edm::Event& e, const edm::EventSetup& s){

   if (!IsAllowedCalibType()) return;

   if (LumiInOrder(e.luminosityBlock())==false) return;


   HcalBaseDQMonitor::analyze(e,s); // base class increments ievt_, etc. counters


   // try to get die Data

   edm::Handle<FEDRawDataCollection> rawraw;

   if (!(e.getByToken(tok_raw_,rawraw)))

   //  if (!(e.getByType(rawraw)))

     {

       edm::LogWarning("HcalRawDataMonitor")<<" raw data with label "<<FEDRawDataCollection_ <<" not available";

       return;

     }

   edm::Handle<HcalUnpackerReport> report;

   if (!(e.getByToken(tok_unpack_,report)))

     {

       edm::LogWarning("HcalRawDataMonitor")<<" Unpacker Report "<<digiLabel_<<" not available";

       return;

     }


   // all objects grabbed; event is good

   if (debug_>1) std::cout <<"\t<HcalRawDataMonitor::analyze>  Processing good event! event # = "<<ievt_<<std::endl;


   // Raw Data collection was grabbed successfully; process the Event

   processEvent(*rawraw, *report);


   //Loop over all cells, tallying problem counts before resetting

   //Extract the subdetector region given the location

   for (int d=0; d<DEPTHBINS; d++) {

     for (int eta=0; eta<ETABINS; eta++) {

       int ieta=CalcIeta(eta,d+1);

       if (ieta==-9999) continue;

       for (int phi=0; phi<PHIBINS; phi++){

     if (problemcount[eta][phi][d]) {

       //      std::cout<<" "<<eta<<","<<phi<<","<<d<<" count:"<<problemcount[eta][phi][d]<<std::endl;

       HcalSubdetector subdet=HcalEmpty;

       if (isHB(eta,d+1))subdet=HcalBarrel;

       else if (isHE(eta,d+1)) subdet=HcalEndcap;

       else if (isHF(eta,d+1)) subdet=HcalForward;

       else if (isHO(eta,d+1)) subdet=HcalOuter;

       if (subdet!=HcalEmpty){

         if (subdet==HcalBarrel)       {if(uniqcounter[eta][phi][d]<1) NumBadHB+= problemcount[eta][phi][d]; uniqcounter[eta][phi][d]++; }

         else if (subdet==HcalEndcap)  {if(uniqcounter[eta][phi][d]<1) NumBadHE+= problemcount[eta][phi][d]; uniqcounter[eta][phi][d]++; }

         else if (subdet==HcalOuter)

           {

         if(uniqcounter[eta][phi][d]<1)

           NumBadHO += problemcount[eta][phi][d];

         uniqcounter[eta][phi][d]++;

         if (abs(ieta)<5) NumBadHO0+= problemcount[eta][phi][d];

         else NumBadHO12+= problemcount[eta][phi][d];

           }

         else if (subdet==HcalForward)

           {

         if(uniqcounter[eta][phi][d]<1)

           NumBadHF+= problemcount[eta][phi][d];

         uniqcounter[eta][phi][d]++;

         if (d==1 && (abs(ieta)==33 || abs(ieta)==34))

           NumBadHFLUMI+= problemcount[eta][phi][d];

         else if (d==2 && (abs(ieta)==35 || abs(ieta)==36))

           NumBadHFLUMI+= problemcount[eta][phi][d];

           }

       }

       problemcount[eta][phi][d]=0;

     }

       }

     }

   }

 }


 void HcalRawDataMonitor::processEvent(const FEDRawDataCollection& rawraw,

                       const HcalUnpackerReport& report){

   if(!dbe_) {

     if (debug_>1)

       printf("HcalRawDataMonitor::processEvent DQMStore not instantiated!\n");

     return;}


   // Fill event counters (underflow bins of histograms)

   meLRBDataCorruptionIndicators_->update();

   meHalfHTRDataCorruptionIndicators_->update();

   meChannSumm_DataIntegrityCheck_->update();

   for (int f=0; f<NUMDCCS; f++)

     meChann_DataIntegrityCheck_[f]->update();

   meDataFlowInd_->update();


   // Loop over all FEDs reporting the event, unpacking if good.

   for (int i=FEDNumbering::MINHCALFEDID; i<=FEDNumbering::MAXHCALFEDID; i++) {

     const FEDRawData& fed = rawraw.FEDData(i);

     if (fed.size()<12) continue;  //At least the size of headers and trailers of a DCC.

     unpack(fed); //Interpret data, fill histograms, everything.

   }


   //increment problemcount[] where problemfound[], and clear problemfound[]

   for (int x=0; x<ETABINS; x++)

       for (int y=0; y<PHIBINS; y++)

     for (int z=0; z<DEPTHBINS; z++)

       if (problemfound[x][y][z]) {

         problemcount[x][y][z]++;

         problemfound[x][y][z]=false;

       }

   return;

 } //void HcalRawDataMonitor::processEvent()


 // Process one FED's worth (one DCC's worth) of the event data.

 void HcalRawDataMonitor::unpack(const FEDRawData& raw){


   // get the DCC header & trailer (or bail out)

   const HcalDCCHeader* dccHeader=(const HcalDCCHeader*)(raw.data());

   if(!dccHeader) return;

   unsigned char* trailer_ptr = (unsigned char*) (raw.data()+raw.size()-sizeof(uint64_t));

   FEDTrailer trailer = FEDTrailer(trailer_ptr);


   // FED id declared in the header

   int dccid=dccHeader->getSourceId();

   //Force 0<= dcc_ <= 31

   int dcc_=std::max(0,dccid-700);

   dcc_ = std::min(dcc_,31);

   if(debug_>1) std::cout << "DCC " << dccid << std::endl;

   uint64_t* dccfw= (uint64_t*) (raw.data()+(sizeof(uint64_t)*2)); //64-bit DAQ word number 2 (from 0)

   int dcc_fw =  ( ((*dccfw)>>(6*8))&0x00000000000000FF );         //Shift right 6 bytes, get that low byte.

   meDCCVersion_ -> Fill(dccid,dcc_fw);


   //Before all else, how much data are we dealing with here?

   uint64_t* lastDataWord = (uint64_t*) ( raw.data()+(raw.size())-(1*sizeof(uint64_t)) );

   int EvFragLength = (int) (*lastDataWord>>(4*8)) & 0x0000000000FFFFFF ; //Shift right 4 bytes, get low 3 bytes.

   meFEDRawDataSizes_->Fill(EvFragLength*8);      //# 64-bit DAQ words *8 = # bytes.

   meEvFragSize_ ->Fill(dccid, EvFragLength*8);   //# 64-bit DAQ words *8 = # bytes.

   meEvFragSize2_ ->Fill(dccid, EvFragLength*8);  //# 64-bit DAQ words *8 = # bytes.


   //Orbit, BunchCount, and Event Numbers

   unsigned long dccEvtNum = dccHeader->getDCCEventNumber();

   int dccBCN = dccHeader->getBunchId();

   //Mask down to 5 bits, since only used for comparison to HTR's five bit number...

   unsigned int dccOrN = (unsigned int) (dccHeader->getOrbitNumber() & 0x0000001F);

   medccBCN_ -> Fill(dccBCN);


   bool CDFProbThisDCC = false;

   /* 1 */ //There should always be a second CDF header word indicated.

   if (!dccHeader->thereIsASecondCDFHeaderWord()

       //TESTME_HCALRAWDATA//

       //|| ((dccid==702)&&(tevt_%2==0))

       ) {

     meCDFErrorFound_->Fill(dccid, 1);

     CDFProbThisDCC = true;

   }

   /* 2 */ //Make sure a reference CDF Version value has been recorded for this dccid

   CDFvers_it = CDFversionNumber_list.find(dccid);

   if (CDFvers_it  == CDFversionNumber_list.end()) {

     CDFversionNumber_list.insert(std::pair<int,short>

                  (dccid,dccHeader->getCDFversionNumber() ) );

     CDFvers_it = CDFversionNumber_list.find(dccid);

   } // then check against it.

   if (dccHeader->getCDFversionNumber()!= CDFvers_it->second) {

     meCDFErrorFound_->Fill(dccid,2);

     CDFProbThisDCC = true;

   }

   /* 3 */ //There should always be a '5' in CDF Header word 0, bits [63:60]

   if (dccHeader->BOEshouldBe5Always()!=5) {

     meCDFErrorFound_->Fill(dccid, 3);

     CDFProbThisDCC = true;

   }

   /* 4 */ //There should never be a third CDF Header word indicated.

   if (dccHeader->thereIsAThirdCDFHeaderWord()) {

     meCDFErrorFound_->Fill(dccid, 4);

     CDFProbThisDCC = true;

   }

   /* 5 */ //Make sure a reference value of Reserved Bits has been recorded for this dccid

   CDFReservedBits_it = CDFReservedBits_list.find(dccid);

   if (CDFReservedBits_it  == CDFReservedBits_list.end()) {

     CDFReservedBits_list.insert(std::pair<int,short>

                 (dccid,dccHeader->getSlink64ReservedBits() & 0x0000FFFF ) );

     CDFReservedBits_it = CDFReservedBits_list.find(dccid);

   } // then check against it.

   if (((int) dccHeader->getSlink64ReservedBits() & 0x0000FFFF ) != CDFReservedBits_it->second) {

     meCDFErrorFound_->Fill(dccid,5);

     //CDFProbThisDCC = true;

   }

   /* 6 */ //There should always be 0x0 in CDF Header word 1, bits [63:60]

   if (dccHeader->BOEshouldBeZeroAlways() !=0) {

     meCDFErrorFound_->Fill(dccid, 6);

     CDFProbThisDCC = true;

   }

   /* 7 */ //There should only be one trailer

   if (trailer.moreTrailers()) {

     meCDFErrorFound_->Fill(dccid, 7);

     CDFProbThisDCC = true;

   }

   //  if trailer.

   /* 8 */ //CDF Trailer [55:30] should be the # 64-bit words in the EvFragment

   if ((uint64_t) raw.size() != ( (uint64_t) trailer.lenght()*sizeof(uint64_t)) )  //The function name is a typo! Awesome.

     {

       meCDFErrorFound_->Fill(dccid, 8);

       CDFProbThisDCC = true;

     }

   /* 9 */ //There is a rudimentary sanity check built into the FEDTrailer class

   if (!trailer.check()) {

     meCDFErrorFound_->Fill(dccid, 9);

     CDFProbThisDCC = true;

   }

   if (CDFProbThisDCC) {

     //Set the problem flag for the ieta, iphi of any channel in this DCC

     mapDCCproblem(dcc_);

     if (debug_>0) std::cout <<"CDFProbThisDCC"<<std::endl;

   }


   mefedEntries_->Fill(dccid);


   CDFProbThisDCC = false;  // reset for the next go-round.


   char CRC_err;

   for(int i=0; i<HcalDCCHeader::SPIGOT_COUNT; i++) {

     CRC_err = ((dccHeader->getSpigotSummary(i) >> 10) & 0x00000001);

     if (CRC_err) {

       mapDCCproblem(dcc_);

       //Set the problem flag for the ieta, iphi of any channel in this DCC

       if (debug_>0) std::cout <<"HTR Problem: CRC_err"<<std::endl;

     }

   }


   // The DCC TTS state at event-sending time

   char TTS_state = (char)trailer.ttsBits();

   // The DCC TTS state at time L1A received (event enqueued to be built)

   char L1AtimeTTS_state=(char) dccHeader->getAcceptTimeTTS();

   if (TTS_state==L1AtimeTTS_state) ;//party


   /* 1 */ //Make sure a reference value of the DCC Event Format version has been noted for this dcc.

   DCCEvtFormat_it = DCCEvtFormat_list.find(dccid);

   if (DCCEvtFormat_it == DCCEvtFormat_list.end()) {

     DCCEvtFormat_list.insert(std::pair<int,short>

                  (dccid,dccHeader->getDCCDataFormatVersion() ) );

     DCCEvtFormat_it = DCCEvtFormat_list.find(dccid);

   } // then check against it.

   if (dccHeader->getDCCDataFormatVersion()!= DCCEvtFormat_it->second) {

     meDCCEventFormatError_->Fill(dccid,1);

     mapDCCproblem(dcc_);

     if (debug_>0)std::cout <<"DCC Error Type 1"<<std::endl;

   }

   /* 2 */ //Check for ones where there should always be zeros

   if (false) //dccHeader->getByte1Zeroes() || dccHeader->getByte3Zeroes() || dccHeader->getByte567Zeroes())

   {

     meDCCEventFormatError_->Fill(dccid,2);

     mapDCCproblem(dcc_);

     if (debug_>0)std::cout <<"DCC Error Type 2"<<std::endl;

   }

   /* 3 */ //Check that there are zeros following the HTR Status words.

   int SpigotPad = HcalDCCHeader::SPIGOT_COUNT;

   if (  (((uint64_t) dccHeader->getSpigotSummary(SpigotPad)  )

      | ((uint64_t) dccHeader->getSpigotSummary(SpigotPad+1))

      | ((uint64_t) dccHeader->getSpigotSummary(SpigotPad+2)))  != 0){

     meDCCEventFormatError_->Fill(dccid,3);

     mapDCCproblem(dcc_);

   if (debug_>0)std::cout <<"DCC Error Type 3"<<std::endl;

   }

   /* 4 */ //Check that there are zeros following the HTR Payloads, if needed.

   int nHTR32BitWords=0;

   // add up all the declared HTR Payload lengths

   for(int i=0; i<HcalDCCHeader::SPIGOT_COUNT; i++) {

     nHTR32BitWords += dccHeader->getSpigotDataLength(i);  }

   // if it's an odd number, check for the padding zeroes

   if (( nHTR32BitWords % 2) == 1) {

     uint64_t* lastDataWord = (uint64_t*) ( raw.data()+raw.size()-(2*sizeof(uint64_t)) );

     if ((*lastDataWord>>32) != 0x00000000){

       meDCCEventFormatError_->Fill(dccid, 4);

       mapDCCproblem(dcc_);

       if (debug_>0)std::cout <<"DCC Error Type 4"<<std::endl;

     }

   }


   //unsigned char HTRErrorList=0;

   //for(int j=0; j<HcalDCCHeader::SPIGOT_COUNT; j++) {

   //  HTRErrorList=dccHeader->getSpigotErrorBits(j);

   //}


   // These will be used in FED-vs-spigot 2D Histograms

   const int fed3offset = 1 + (4*dcc_); //3 bins, plus one of margin, each DCC

   const int fed2offset = 1 + (3*dcc_); //2 bins, plus one of margin, each DCC

   if (TTS_state & 0x8) /*RDY*/

     ;

   if (TTS_state & 0x2) /*SYN*/

     {

       mapDCCproblem(dcc_);

       if (debug_>0)std::cout <<"TTS_state Error:sync"<<std::endl;

     }

   //Histogram per-Spigot bits from the DCC Header

   int WholeErrorList=0;

   for(int spigot=0; spigot<HcalDCCHeader::SPIGOT_COUNT; spigot++) {

     if (!( dccHeader->getSpigotEnabled((unsigned int) spigot)) )

       continue; //skip when not enabled

     // This will be used in FED-vs-spigot 2D Histograms

     const int spg3offset = 1 + (4*spigot); //3 bins, plus one of margin, each spigot


     if (TTS_state & 0x4) /*BSY*/

       ++DataFlowInd_[fed2offset+1][spg3offset+1];

     if (TTS_state & 0x1) /*OFW*/

       ++DataFlowInd_[fed2offset+1][spg3offset+2];


     WholeErrorList=dccHeader->getLRBErrorBits((unsigned int) spigot);

     if (WholeErrorList!=0) {

       if ((WholeErrorList>>0)&0x01)  //HammingCode Corrected -- Not data corruption!

     DataFlowInd_[fed2offset-1][spg3offset-1]++;

       if (((WholeErrorList>>1)&0x01)!=0)  {//HammingCode Uncorrected Error

     LRBDataCorruptionIndicators_[fed3offset+1][spg3offset+2]++;

     mapHTRproblem(dcc_,spigot);

       }

       if (((WholeErrorList>>2)&0x01)!=0)  {//Truncated data coming into LRB

     LRBDataCorruptionIndicators_[fed3offset+2][spg3offset+2]++;

     mapHTRproblem(dcc_,spigot);

       }

       if (((WholeErrorList>>3)&0x01)!=0)  {//FIFO Overflow

     LRBDataCorruptionIndicators_[fed3offset+1][spg3offset+1]++;

     mapHTRproblem(dcc_,spigot);

       }

       if (((WholeErrorList>>4)&0x01)!=0)  {//ID (EvN Mismatch), htr payload metadeta

     LRBDataCorruptionIndicators_[fed3offset+2][spg3offset+1]++;

     mapHTRproblem(dcc_,spigot);

       }

       if (((WholeErrorList>>5)&0x01)!=0)  {//STatus: hdr/data/trlr error

     LRBDataCorruptionIndicators_[fed3offset+1][spg3offset+0]++;

     mapHTRproblem(dcc_,spigot);

       }

       if (((WholeErrorList>>6)&0x01)!=0)  {//ODD 16-bit word count from HTR

     LRBDataCorruptionIndicators_[fed3offset+2][spg3offset+0]++;

     mapHTRproblem(dcc_,spigot);

       }

     }

     if (!dccHeader->getSpigotPresent((unsigned int) spigot)){

       LRBDataCorruptionIndicators_[fed3offset+0][spg3offset+2]++;  //Enabled, but data not present!

       mapHTRproblem(dcc_,spigot);

       if (debug_>0)std::cout <<"HTR Problem: Spigot Not Present"<<std::endl;

     } else {

       if ( dccHeader->getSpigotDataTruncated((unsigned int) spigot)) {

         LRBDataCorruptionIndicators_[fed3offset-1][spg3offset+0]++;  // EventBuilder truncated babbling LRB

     mapHTRproblem(dcc_,spigot);

     if (debug_>0)std::cout <<"HTR Problem: Spigot Data Truncated"<<std::endl;

       }

       if ( dccHeader->getSpigotCRCError((unsigned int) spigot)) {

     LRBDataCorruptionIndicators_[fed3offset+0][spg3offset+0]++;

     mapHTRproblem(dcc_,spigot);

       }

     } //else spigot marked "Present"

     if (dccHeader->getSpigotDataLength(spigot) <(unsigned long)4) {

       LRBDataCorruptionIndicators_[fed3offset+0][spg3offset+1]++;  //Lost HTR Data for sure.

       mapHTRproblem(dcc_,spigot);

       if (debug_>0)std::cout <<"HTR Problem: Spigot Data Length too small"<<std::endl;

     }

   }


   // Walk through the HTR data...

   HcalHTRData htr;

   for (int spigot=0; spigot<HcalDCCHeader::SPIGOT_COUNT; spigot++) {

     const int spg3offset = 1 + (4*spigot); //3 bins, plus one of margin, each spigot

     const int spg2offset = 1 + (3*spigot); //3 bins, plus one of margin, each spigot

     if (!dccHeader->getSpigotPresent(spigot)) continue;


     // Load the given decoder with the pointer and length from this spigot.

     // i.e.     initialize htr, within dcc raw data size.

     dccHeader->getSpigotData(spigot,htr, raw.size());

     const unsigned short* HTRraw = htr.getRawData();


     // check min length, correct wordcount, empty event, or total length if histo event.

     if (!htr.check()) {

       meInvHTRData_ -> Fill(spigot,dccid);

       mapHTRproblem(dcc_,spigot);

       if (debug_>0)std::cout <<"HTR Problem: HTR check fails"<<std::endl;

     }


     unsigned short HTRwdcount = htr.getRawLength();


     // Size checks for internal consistency

     // getNTP(), get NDD() seems to be mismatched with format. Manually:

     int NTP = ((htr.getExtHdr6() >> 8) & 0x00FF);

     int NDAQ = (HTRraw[htr.getRawLength() - 4] & 0x7FF);


     if ( !  ((HTRwdcount != 8)               ||

          (HTRwdcount != 12 + NTP + NDAQ) ||

          (HTRwdcount != 20 + NTP + NDAQ)    )) {

       ++HalfHTRDataCorruptionIndicators_[fed3offset+2][spg3offset+0];

       mapHTRproblem(dcc_,spigot);

       if (debug_>0)std::cout <<"HTR Problem: NTP+NDAQ size consistency check fails"<<std::endl;

       //incompatible Sizes declared. Skip it.

       continue; }

     bool EE = ((dccHeader->getSpigotErrorBits(spigot) >> 2) & 0x01);

     if (EE) {

       if (HTRwdcount != 8) {    //incompatible Sizes declared. Skip it.

     ++HalfHTRDataCorruptionIndicators_[fed3offset+2][spg3offset+1];

     if (debug_>0)std::cout <<"HTR Problem: HTRwdcount !=8"<<std::endl;

       }

       DataFlowInd_[fed2offset+0][spg3offset+0]++;

       continue;}

     else{ //For non-EE, both CompactMode and !CompactMode

       bool CM = (htr.getExtHdr7() >> 14)&0x0001;

       int paddingsize = ((NDAQ+NTP)%2); //Extra padding to make HTRwdcount even

       if (( CM && ( (HTRwdcount-NDAQ-NTP-paddingsize) != 12) )

       ||

       (!CM && ( (HTRwdcount-NDAQ-NTP-paddingsize) != 20) )  ) { //incompatible Sizes declared. Skip it.

     ++HalfHTRDataCorruptionIndicators_[fed3offset+2][spg3offset+1];

     mapHTRproblem(dcc_,spigot);

     continue;} }


     if (htr.isHistogramEvent()) continue;


     //We trust the data now.  Finish with the check against DCCHeader

     unsigned int htrOrN = htr.getOrbitNumber();

     unsigned int htrBCN = htr.getBunchNumber();

     unsigned int htrEvtN = htr.getL1ANumber();

     meBCN_->Fill(htrBCN);  //The only periodic number for whole events.


     if (( (htrOrN  == dccOrN ) &&

       (htrBCN  == (unsigned int) dccBCN) )

     != (dccHeader->getBxMismatchWithDCC(spigot))  ){

       meDCCEventFormatError_->Fill(dccid,5);

       mapHTRproblem(dcc_,spigot);

       if (debug_>0)std::cout <<"Orbit or BCN  HTR/DCC mismatch"<<std::endl;

     }

     if ( (htrEvtN == dccEvtNum) !=

      dccHeader->getSpigotValid(spigot) ) {

       meDCCEventFormatError_->Fill(dccid,5);

       mapHTRproblem(dcc_,spigot);

       if (debug_>0)std::cout <<"DCC invalid spigot"<<std::endl;

     }

     int cratenum = htr.readoutVMECrateId();

     float slotnum = htr.htrSlot() + 0.5*htr.htrTopBottom();

     if (debug_ > 0) HTRPrint(htr,debug_);

     unsigned int htrFWVer = htr.getFirmwareRevision() & 0xFF;

     meHTRFWVersion_->Fill(cratenum,htrFWVer);


     int EvtNdiff = htrEvtN - dccEvtNum;

     if (EvtNdiff!=0) {

       meEvtNumberSynch_->Fill(dccid,spigot);

       mapHTRproblem(dcc_,spigot);

       meEvtNCheck_->Fill(EvtNdiff);

       if (debug_ == 1)std::cout << "++++ Evt # out of sync, ref, this HTR: "<< dccEvtNum << "  "<<htrEvtN <<std::endl;

     }


     int BCNdiff = htrBCN-dccBCN;

     if ((BCNdiff!=0)

     //TESTME_HCALRAWDATA//

     //|| ((dccid==727) && (spigot==8) && (dccEvtNum%3==0))

     ){

       meBCNSynch_->Fill(dccid,spigot);

       mapHTRproblem(dcc_,spigot);

       meBCNCheck_->Fill(BCNdiff);

       if (debug_==1)std::cout << "++++ BCN # out of sync, ref, this HTR: "<< dccBCN << "  "<<htrBCN <<std::endl;

     }


     int OrNdiff = htrOrN-dccOrN;

     if (OrNdiff!=0) {

       meOrNSynch_->Fill(dccid,spigot);

       mapHTRproblem(dcc_,spigot);

       meOrNCheck_->Fill(OrNdiff);

       meBCNwhenOrNDiff_->Fill(htrBCN); // Are there special BCN where OrN mismatched occur? Let's see.

       if (debug_==1)std::cout << "++++ OrN # out of sync, ref, this HTR: "<< dccOrN << "  "<<htrOrN <<std::endl;

     }


     bool htrUnSuppressed=(HTRraw[6]>>15 & 0x0001);

     if (htrUnSuppressed) {

       UScount[dcc_][spigot]++;

       int here=1+(HcalDCCHeader::SPIGOT_COUNT*(dcc_))+spigot;

       meUSFractSpigs_->Fill(here,

                 ((double)UScount[dcc_][spigot]));}


     MonitorElement* tmpErr = 0;

     HcalDetId HDI = hashedHcalDetId_[hashup(dcc_,spigot)];

     if (HDI != HcalDetId::Undefined) {

       switch (HDI.subdetId()) {

       case (HcalBarrel): {

     tmpErr = HTR_StatusWd_HBHE;

       } break;

       case (HcalEndcap): {

     tmpErr = HTR_StatusWd_HBHE;

       } break;

       case (HcalOuter): {

     tmpErr = HTR_StatusWd_HO;

       } break;

       case (HcalForward): {

     tmpErr = HTR_StatusWd_HF;

       } break;

       default: break;

       }

     }


     int errWord = htr.getErrorsWord() & 0xFFFF;

     if (  (((dccHeader->getSpigotSummary( spigot))>>24)&0x00FF)

       != (errWord&0x00FF) ){

       meDCCEventFormatError_->Fill(dccid,6);//Low 8 bits miscopied into DCCHeader

       mapHTRproblem(dcc_,spigot);

       if (debug_>0)std::cout <<"DCC spigot summary error or HTR error word"<<std::endl;

       //What other problems may lurk? Spooky.

     }

     if(tmpErr!=NULL){

       for(int i=0; i<16; i++){

     int errbit = errWord&(0x01<<i);

     // Bit 15 should always be 1; consider it an error if it isn't.

     if (i==15) errbit = errbit - 0x8000;

     if (errbit !=0) {

       tmpErr->Fill(i);

       //Only certain bits indicate corrupted data:

       switch (i) {

       case (14): //CT (obsolete Calibration Trigger scheme used)

         HalfHTRDataCorruptionIndicators_[fed3offset+0][spg3offset+2]++;

         mapHTRproblem(dcc_,spigot);

         if (debug_>0)std::cout <<"HTR Problem: Case 14"<<std::endl;

         break;

       case (13): //HM

         HalfHTRDataCorruptionIndicators_[fed3offset+0][spg3offset+1]++;

         mapHTRproblem(dcc_,spigot);

         if (debug_>0)std::cout <<"HTR Problem: Case 13"<<std::endl;

         break;

       case (12): //TM

         HalfHTRDataCorruptionIndicators_[fed3offset+0][spg3offset+0]++;

         mapHTRproblem(dcc_,spigot);

         if (debug_>0)std::cout <<"HTR Problem: Case 12"<<std::endl;

         break;

       case ( 8): //BE

         HalfHTRDataCorruptionIndicators_[fed3offset+1][spg3offset+2]++;

         mapHTRproblem(dcc_,spigot);

         if (debug_>0)std::cout <<"HTR Problem: Case 8"<<std::endl;

         break;

       case (15): //b15

         HalfHTRDataCorruptionIndicators_[fed3offset+1][spg3offset+1]++;

         mapHTRproblem(dcc_,spigot);

         break;

       case ( 7): //CK

         HalfHTRDataCorruptionIndicators_[fed3offset+1][spg3offset+0]++;

         mapHTRproblem(dcc_,spigot);

         if (debug_>0)std::cout <<"HTR Problem: Case 7"<<std::endl;

         break;

       //\\case ( 5): //LW removed 2010.02.16

       //\\  HalfHTRDataCorruptionIndicators_[fed3offset+2][spg3offset+2]++;

       //\\  //Sometimes set spuriously at startup, per-fiber, .: Leniency: 8

       //\\  if (HalfHTRDataCorruptionIndicators_[fed3offset+2][spg3offset+2] > 8) {

       //\\    if (debug_>0)std::cout <<"HTR Problem: Case 5"<<std::endl;

       //\\    break;

       //\\  }

       case ( 3): //L1 (previous L1A violated trigger rules)

         DataFlowInd_[fed2offset+1][spg3offset+0]++; break;

       case ( 1): //BZ

         DataFlowInd_[fed2offset+0][spg3offset+1]++; break;

       case ( 0): //OW

         DataFlowInd_[fed2offset+0][spg3offset+2]++;

       default: break;

       }

       meStatusWdCrate_->Fill(cratenum,i);

       if      (cratenum == 0) meCrate0HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum == 1) meCrate1HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum == 2) meCrate2HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum == 3) meCrate3HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum == 4) meCrate4HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum == 5) meCrate5HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum == 6) meCrate6HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum == 7) meCrate7HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum == 9) meCrate9HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum ==10)meCrate10HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum ==11)meCrate11HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum ==12)meCrate12HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum ==13)meCrate13HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum ==14)meCrate14HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum ==15)meCrate15HTRStatus_ -> Fill(slotnum,i);

       else if (cratenum ==17)meCrate17HTRStatus_ -> Fill(slotnum,i);

     }

       }

     }


     // Fish out Front-End Errors from the precision channels

     const short unsigned int* daq_first, *daq_last, *tp_first, *tp_last;

     const HcalQIESample* qie_begin, *qie_end, *qie_work;


     // get pointers

     htr.dataPointers(&daq_first,&daq_last,&tp_first,&tp_last);

     qie_begin=(HcalQIESample*)daq_first;

     qie_end=(HcalQIESample*)(daq_last+1); // one beyond last..


     //TESTME_HCALRAWDATA//if (dccid==715 && spigot==5 && tevt_%3==0)

     //TESTME_HCALRAWDATA//  Chann_DataIntegrityCheck_[dcc_][16][spg2offset]++;


     if (htr.getFormatVersion() < 6 ) { //HcalHTRData::FORMAT_VERSION_COMPACT_DATA is 6


       int lastcapid=-1;

       int samplecounter=-1;

       int htrchan=-1; // Valid: [1,24]

       int chn2offset=0;

       int NTS = htr.getNDD(); //number time slices, in precision channels


       ChannSumm_DataIntegrityCheck_  [fed2offset-1][spg2offset+0]=-NTS;//For normalization by client - NB! negative!

       // Run over DAQ words for this spigot

       for (qie_work=qie_begin; qie_work!=qie_end; qie_work++) {

     if (qie_work->raw()==0xFFFF)  // filler word

       continue;

     //Beginning a channel's samples?

     if (( 1 + ( 3* (qie_work->fiber()-1) ) + qie_work->fiberChan() )  != htrchan) { //new channel starting

       // A fiber [1..8] carries three fiber channels, each is [0..2]. Make htrchan [1..24]

       htrchan= (3* (qie_work->fiber()-1) ) + qie_work->fiberChan();

       chn2offset = (htrchan*3)+1;

       --ChannSumm_DataIntegrityCheck_  [fed2offset-1][spg2offset-1];//event tally -- NB! negative!

       --Chann_DataIntegrityCheck_[dcc_][chn2offset-1][spg2offset-1];//event tally -- NB! negative!

       if (samplecounter !=-1) { //Wrap up the previous channel if there is one

         //Check the previous digi for number of timeslices

         if (((samplecounter != NTS) &&

          (samplecounter != 1)             )

         //||

         //((htrchan==5) && (spigot==5) && (dcc_==5))

         )

           { //Wrong DigiSize

         ++ChannSumm_DataIntegrityCheck_  [fed2offset+0][spg2offset+0];

         ++Chann_DataIntegrityCheck_[dcc_][chn2offset+0][spg2offset+0];

         mapChannproblem(dcc_,spigot,htrchan);

         if (debug_)std::cout <<"mapChannelProblem:  Wrong Digi Size"<<std::endl;

           }

       }

       //set up for this new channel

       lastcapid=qie_work->capid();

       samplecounter=1;} // fi (qie_work->fiberAndChan() != lastfibchan)

     else { //precision samples not the first timeslice

       int hope = lastcapid +1;// What capid would we hope for here?

       if (hope==4) hope = 0;  // What capid would we hope for here?

       if (qie_work->capid() != hope){

         ++ChannSumm_DataIntegrityCheck_  [fed2offset+1][spg2offset+0];

         ++Chann_DataIntegrityCheck_[dcc_][chn2offset+1][spg2offset+0];

         mapChannproblem(dcc_,spigot,htrchan);

         if (debug_)std::cout <<"mapChannelProblem:  Wrong Cap ID"<<std::endl;

       }

       lastcapid=qie_work->capid();

       samplecounter++;}

     //For every sample, whether the first of the channel or not, !DV, Er

     if (!(qie_work->dv())){

       ++ChannSumm_DataIntegrityCheck_  [fed2offset+0][spg2offset+1];

       ++Chann_DataIntegrityCheck_[dcc_][chn2offset+0][spg2offset+1];

     }

     if (qie_work->er()) {      // FEE - Front End Error

       ++ChannSumm_DataIntegrityCheck_  [fed2offset+1][spg2offset+1];

       ++Chann_DataIntegrityCheck_[dcc_][chn2offset+1][spg2offset+1];

       mapChannproblem(dcc_,spigot,htrchan);

       if (debug_)std::cout <<"mapChannelProblem:  FE Error"<<std::endl;

     }

       } // for (qie_work = qie_begin;...)  end loop over all timesamples in this spigot

       //Wrap up the last channel

       //Check the last digi for number of timeslices

       if ((samplecounter != NTS) &&

       (samplecounter != 1)            &&

       (samplecounter !=-1)             ) { //Wrong DigiSize (unexpected num. timesamples)

     ++ChannSumm_DataIntegrityCheck_  [fed2offset+0][spg2offset+0];

     ++Chann_DataIntegrityCheck_[dcc_][chn2offset+0][spg2offset+0];

     mapChannproblem(dcc_,spigot,htrchan);

     if (debug_)std::cout <<"mapChannelProblem:  Wrong Digi Size (last digi)"<<std::endl;

       }

     } else { // this is the branch for unpacking the compact data format with per-channel headers

       const unsigned short* ptr_header=daq_first;

       const unsigned short* ptr_end=daq_last+1;

       int flavor, error_flags, capid0, channelid;

       // int samplecounter=-1;  // for a digisize check

       int htrchan=-1; // Valid: [1,24]

       int chn2offset=0;

       int NTS = htr.getNDD(); //number time slices, in precision channels

       int Nchan = 3; // 3 channels per fiber

       while (ptr_header!=ptr_end) {

         if (*ptr_header==0xFFFF) { // impossible filler word

           ptr_header++;

           continue;

         }

     error_flags = capid0 = channelid = 0;

     // unpack the header word

     bool isheader=HcalHTRData::unpack_per_channel_header(*ptr_header,flavor,error_flags,capid0,channelid);

     if (!isheader) {

       ptr_header++;

       continue;

     }

     // A fiber [1..8] carries three fiber channels, each is [0..2]. Make htrchan [1..24]

     int fiber = 1 + ((channelid & 0x1C) >> 2); //Mask and shift to get bits [2:4]

     int chan = channelid & 0x3; //bits [0:1]

     htrchan = ((fiber -1) * Nchan) + chan + 1;  //ta-dah! I really wish everything counted from zero...

     chn2offset = ((htrchan-1)*3)+1; //For placing the errors on the histogram. Also very tidy. Sorry.

     //debug// if (error_flags) std::cout<<fiber<<","<<chan<<" = "<<htrchan<<"   @"<<chn2offset<<std::endl;

     ChannSumm_DataIntegrityCheck_  [fed2offset-1][spg2offset-1] -= NTS;//event tally -- NB: negative!

     Chann_DataIntegrityCheck_[dcc_][chn2offset-1][spg2offset-1] -= NTS;//event tally -- NB: negative!

     if (error_flags & 2) { //a CapId violation (non correct rotation)

       ++ChannSumm_DataIntegrityCheck_  [fed2offset+1][spg2offset+0];

       ++Chann_DataIntegrityCheck_[dcc_][chn2offset+1][spg2offset+0];

       mapChannproblem(dcc_,spigot,htrchan);

     }

     if (error_flags & 1) { //an asserted Link-Error (Er)

       ++ChannSumm_DataIntegrityCheck_  [fed2offset+1][spg2offset+1];

       ++Chann_DataIntegrityCheck_[dcc_][chn2offset+1][spg2offset+1];

       mapChannproblem(dcc_,spigot,htrchan);

     }


     for (ptr_header++;

          ptr_header!=ptr_end && !HcalHTRData::is_channel_header(*ptr_header);

          ptr_header++);

       }

     }

     unsigned int fib1BCN = htr.getFib1OrbMsgBCN();

     unsigned int fib2BCN = htr.getFib2OrbMsgBCN();

     unsigned int fib3BCN = htr.getFib3OrbMsgBCN();

     unsigned int fib4BCN = htr.getFib4OrbMsgBCN();

     unsigned int fib5BCN = htr.getFib5OrbMsgBCN();

     unsigned int fib6BCN = htr.getFib6OrbMsgBCN();

     unsigned int fib7BCN = htr.getFib7OrbMsgBCN();

     unsigned int fib8BCN = htr.getFib8OrbMsgBCN();

     meFibBCN_->Fill(fib1BCN);

     meFibBCN_->Fill(fib2BCN);

     meFibBCN_->Fill(fib3BCN);

     meFibBCN_->Fill(fib4BCN);

     meFibBCN_->Fill(fib5BCN);

     meFibBCN_->Fill(fib6BCN);

     meFibBCN_->Fill(fib7BCN);

     meFibBCN_->Fill(fib8BCN);

     // Disable for now?

     meFib1OrbMsgBCN_->Fill(slotnum, cratenum, fib1BCN);

     meFib2OrbMsgBCN_->Fill(slotnum, cratenum, fib2BCN);

     meFib3OrbMsgBCN_->Fill(slotnum, cratenum, fib3BCN);

     meFib4OrbMsgBCN_->Fill(slotnum, cratenum, fib4BCN);

     meFib5OrbMsgBCN_->Fill(slotnum, cratenum, fib5BCN);

     meFib6OrbMsgBCN_->Fill(slotnum, cratenum, fib6BCN);

     meFib7OrbMsgBCN_->Fill(slotnum, cratenum, fib7BCN);

     meFib8OrbMsgBCN_->Fill(slotnum, cratenum, fib8BCN);


   } //  loop over spigots

   return;

 } // loop over DCCs void HcalRawDataMonitor::unpack(


 // End LumiBlock

 void HcalRawDataMonitor::endLuminosityBlock(const edm::LuminosityBlock& lumiSeg,

                         const edm::EventSetup& c){


   ProblemsVsLB_HB->Fill(lumiSeg.luminosityBlock(),NumBadHB);

   ProblemsVsLB_HE->Fill(lumiSeg.luminosityBlock(),NumBadHE);

   ProblemsVsLB_HO->Fill(lumiSeg.luminosityBlock(),NumBadHO);

   ProblemsVsLB_HF->Fill(lumiSeg.luminosityBlock(),NumBadHF);

   ProblemsVsLB_HBHEHF->Fill(lumiSeg.luminosityBlock(),NumBadHB+NumBadHE+NumBadHF);

   ProblemsVsLB->Fill(lumiSeg.luminosityBlock(),NumBadHB+NumBadHE+NumBadHO+NumBadHF);


   // Reset current LS histogram, if it exists

   if (ProblemsCurrentLB)

     ProblemsCurrentLB->Reset();

   if (ProblemsCurrentLB)

     {


       ProblemsCurrentLB->setBinContent(0,0, levt_);  // underflow bin contains number of events

       ProblemsCurrentLB->setBinContent(1,1, NumBadHB*levt_);

       ProblemsCurrentLB->setBinContent(2,1, NumBadHE*levt_);

       ProblemsCurrentLB->setBinContent(3,1, NumBadHO*levt_);

       ProblemsCurrentLB->setBinContent(4,1, NumBadHF*levt_);

       ProblemsCurrentLB->setBinContent(5,1, NumBadHO0*levt_);

       ProblemsCurrentLB->setBinContent(6,1, NumBadHO12*levt_);

       ProblemsCurrentLB->setBinContent(7,1, NumBadHFLUMI*levt_);


     }


   for (int d=0; d<DEPTHBINS; d++) {

     for (int eta=0; eta<ETABINS; eta++) {

       for (int phi=0; phi<PHIBINS; phi++){

     uniqcounter[eta][phi][d] = 0.0;

       }

     }

   }


   UpdateMEs();

 }

 // EndRun -- Anything to do here?

 void HcalRawDataMonitor::endRun(const edm::Run& run, const edm::EventSetup& c){}


 // EndJob

 void HcalRawDataMonitor::endJob(void){

   if (debug_>0) std::cout <<"HcalRawDataMonitor::endJob()"<<std::endl;

   if (enableCleanup_) cleanup(); // when do we force cleanup?

 }


 //No size checking; better have enough y-axis bins!

 void HcalRawDataMonitor::label_ySpigots(MonitorElement* me_ptr, int ybins) {

   char label[32];

   for (int spig=0; spig<HcalDCCHeader::SPIGOT_COUNT; spig++) {

     snprintf(label, 32, "Spgt %02d", spig);

     me_ptr->setBinLabel((2+(spig*ybins)), label, 2); //margin of 1 at low value

   }

 }


 //No size checking; better have enough x-axis bins!

 void HcalRawDataMonitor::label_xChanns(MonitorElement* me_ptr, int xbins) {

   char label[32];

   for (int ch=0; ch<HcalHTRData::CHANNELS_PER_SPIGOT; ch++) {

     snprintf(label, 32, "Ch %02d", ch+1);

     me_ptr->setBinLabel((2+(ch*xbins)), label, 1); //margin of 3 at low value

   }

 }


 //No size checking; better have enough x-axis bins!

 void HcalRawDataMonitor::label_xFEDs(MonitorElement* me_ptr, int xbins) {

   char label[32];

   for (int thfed=0; thfed<NUMDCCS; thfed++) {

     snprintf(label, 32, "%03d", thfed+700);

     me_ptr->setBinLabel((2+(thfed*xbins)), label, 1); //margin of 1 at low value

   }

 }


 void HcalRawDataMonitor::labelHTRBits(MonitorElement* mePlot,unsigned int axisType) {


   if (axisType !=1 && axisType != 2) return;


   mePlot -> setBinLabel(1,"Overflow Warn",axisType);

   mePlot -> setBinLabel(2,"Buffer Busy",axisType);

   mePlot -> setBinLabel(3,"Empty Event",axisType);

   mePlot -> setBinLabel(4,"Rejected L1A",axisType);

   mePlot -> setBinLabel(5,"Invalid Stream",axisType);

   mePlot -> setBinLabel(6,"Latency Warn",axisType);

   mePlot -> setBinLabel(7,"OptDat Err",axisType);

   mePlot -> setBinLabel(8,"Clock Err",axisType);

   mePlot -> setBinLabel(9,"Bunch Err",axisType);

   mePlot -> setBinLabel(10,"b9",axisType);

   mePlot -> setBinLabel(11,"b10",axisType);

   mePlot -> setBinLabel(12,"b11",axisType);

   mePlot -> setBinLabel(13,"Test Mode",axisType);

   mePlot -> setBinLabel(14,"Histo Mode",axisType);

   mePlot -> setBinLabel(15,"Calib Trig",axisType);

   mePlot -> setBinLabel(16,"Bit15 Err",axisType);


   return;

 }


 void HcalRawDataMonitor::stashHDI(int thehash, HcalDetId thehcaldetid) {

   //Let's not allow indexing off the array...

   if ((thehash<0)||(thehash>(NUMDCCS*NUMSPIGS*HTRCHANMAX)))return;

   //...but still do the job requested.

   hashedHcalDetId_[thehash] = thehcaldetid;

 }


 //Debugging output for single half-HTRs (single spigot)

 //-->Class member debug_ usually passed for prtlvl argument.<--

 void HcalRawDataMonitor::HTRPrint(const HcalHTRData& htr,int prtlvl){

   if (prtlvl == 1){

     int cratenum = htr.readoutVMECrateId();

     float slotnum = htr.htrSlot() + 0.5*htr.htrTopBottom();

     printf("Crate,Slot,ErrWord,Evt#,BCN:  %3i %4.1f %6X %7i %4X \n", cratenum,slotnum,htr.getErrorsWord(),htr.getL1ANumber(),htr.getBunchNumber());

     //    printf(" DLLunlk,TTCrdy:%2i %2i \n",htr.getDLLunlock(),htr.getTTCready());

   }

   // This one needs new version of HcalHTRData.h to activate

   else if (prtlvl == 2){

     int cratenum = htr.readoutVMECrateId();

     float slotnum = htr.htrSlot() + 0.5*htr.htrTopBottom();

     printf("Crate, Slot:%3i %4.1f \n", cratenum,slotnum);

     //    printf("  Ext Hdr: %4X %4X %4X %4X %4X %4X %4X %4X \n",htr.getExtHdr1(),htr.getExtHdr2(),htr.getExtHdr3(),htr.getExtHdr4(),htr.getExtHdr5(),htr.getExtHdr6(),htr.getExtHdr7(),htr.getExtHdr8());

   }


   else if (prtlvl == 3){

     int cratenum = htr.readoutVMECrateId();

     float slotnum = htr.htrSlot() + 0.5*htr.htrTopBottom();

     printf("Crate, Slot:%3i %4.1f", cratenum,slotnum);

     printf(" FibOrbMsgBCNs: %4X %4X %4X %4X %4X %4X %4X %4X \n",htr.getFib1OrbMsgBCN(),htr.getFib2OrbMsgBCN(),htr.getFib3OrbMsgBCN(),htr.getFib4OrbMsgBCN(),htr.getFib5OrbMsgBCN(),htr.getFib6OrbMsgBCN(),htr.getFib7OrbMsgBCN(),htr.getFib8OrbMsgBCN());

   }


   return;

 }


 void HcalRawDataMonitor::UpdateMEs (void ) {

   tevt_=0;

   if (meTevtHist_) tevt_= (int)meTevtHist_->getBinContent(1);

   NumBadHB=0;

   NumBadHE=0;

   NumBadHO=0;

   NumBadHF=0;

   NumBadHFLUMI=0;

   NumBadHO0=0;

   NumBadHO12=0;


   meLRBDataCorruptionIndicators_->setBinContent(0,0,tevt_);

   for (int x=0; x<THREE_FED; x++)

     for (int y=0; y<THREE_SPG; y++)

       if (LRBDataCorruptionIndicators_  [x][y])

     meLRBDataCorruptionIndicators_->setBinContent(x+1,y+1,LRBDataCorruptionIndicators_[x][y]);


   meHalfHTRDataCorruptionIndicators_->setBinContent(0,0,tevt_);

   for (int x=0; x<THREE_FED; x++)

     for (int y=0; y<THREE_SPG; y++)

       if (HalfHTRDataCorruptionIndicators_  [x][y])

     meHalfHTRDataCorruptionIndicators_->setBinContent(x+1,y+1,HalfHTRDataCorruptionIndicators_[x][y]);


   meChannSumm_DataIntegrityCheck_->setBinContent(0,0,tevt_);

   for (int x=0; x<TWO___FED; x++)

     for (int y=0; y<TWO__SPGT; y++)

       if (ChannSumm_DataIntegrityCheck_[x][y])

     meChannSumm_DataIntegrityCheck_->setBinContent(x+1,y+1,ChannSumm_DataIntegrityCheck_[x][y]);


   for (int f=0; f<NUMDCCS; f++){

     meChann_DataIntegrityCheck_[f]->setBinContent(0,0,tevt_);

     for (int x=0; x<TWO_CHANN; x++)

       for (int y=0; y<TWO__SPGT; y++)

     if (Chann_DataIntegrityCheck_[f][x][y])

       meChann_DataIntegrityCheck_[f]->setBinContent(x+1,y+1,Chann_DataIntegrityCheck_ [f][x][y]);

   }


   meDataFlowInd_->setBinContent(0,0,tevt_);

   for (int x=0; x<TWO___FED; x++)

     for (int y=0; y<THREE_SPG; y++)

       if (DataFlowInd_[x][y])

     meDataFlowInd_->setBinContent(x+1,y+1,DataFlowInd_[x][y]);

 } //UpdateMEs


 //Increment the NumBad counter for this LS, for this Hcal subdet

 void HcalRawDataMonitor::whosebad(int subdet) {

 //  if (subdet==HcalBarrel)       ++NumBadHB;

 //  else if (subdet==HcalEndcap)  ++NumBadHE;

 //  else if (subdet==HcalOuter)

 //    {

 //      ++NumBadHO;

 //      if (abs(ieta)<5) ++NumBadHO0;

 //      else ++NumBadHO12;

 //    }

 //  else if (subdet==HcalForward)

 //    {

 //      ++NumBadHF;

 //      if (depth==1 && (abs(ieta)==33 || abs(ieta)==34))

 //  ++NumBadHFLUMI;

 //      else if (depth==2 && (abs(ieta)==35 || abs(ieta)==36))

 //  ++NumBadHFLUMI;

 //    }

 }


 void HcalRawDataMonitor::mapDCCproblem(int dcc) {

   int myeta   = 0;

   int myphi   =-1;

   int mydepth = 0;

   HcalDetId HDI;

   //Light up all affected cells.

   for (int i=hashup(dcc);

        i<hashup(dcc)+(NUMSPIGS*HTRCHANMAX);

        i++) {

     HDI = hashedHcalDetId_[i];

     if (HDI==HcalDetId::Undefined)

       continue;

     mydepth = HDI.depth();

     myphi   = HDI.iphi();

     myeta = CalcEtaBin(HDI.subdet(),

                HDI.ieta(),

                mydepth);

     //Protect against indexing off array

     if (myeta>=0 && myeta<85 &&

     (myphi-1)>=0 && (myphi-1)<72 &&

     (mydepth-1)>=0 && (mydepth-1)<4){

       problemfound[myeta][myphi-1][mydepth-1] = true;


       //exlcude the decommissioned HO ring2, except SiPMs

       if(mydepth==4 && excludeHORing2_==true)

     if (abs(HDI.ieta())>=11 && abs(HDI.ieta())<=15  && !isSiPM(HDI.ieta(),HDI.iphi(),mydepth))

       problemfound[myeta][myphi-1][mydepth-1] = false;


       if (debug_>0)

     std::cout<<" mapDCCproblem found error! "<<HDI.subdet()<<"("<<HDI.ieta()<<", "<<HDI.iphi()<<", "<<HDI.depth()<<")"<<std::endl;

     }

   }

 }

 void HcalRawDataMonitor::mapHTRproblem(int dcc, int spigot) {

   int myeta = 0;

   int myphi   =-1;

   int mydepth = 0;

   HcalDetId HDI;

   //Light up all affected cells.

   for (int i=hashup(dcc,spigot);

        i<hashup(dcc,spigot)+(HTRCHANMAX); //nice, linear hash....

        i++) {

     HDI = hashedHcalDetId_[i];

     if (HDI==HcalDetId::Undefined) {

       continue;

     }

     mydepth = HDI.depth();

     myphi   = HDI.iphi();

     myeta = CalcEtaBin(HDI.subdet(),

                HDI.ieta(),

                mydepth);

     //Protect against indexing off array

     if (myeta>=0 && myeta<85 &&

     (myphi-1)>=0 && (myphi-1)<72 &&

     (mydepth-1)>=0 && (mydepth-1)<4){

       problemfound[myeta][myphi-1][mydepth-1] = true;


       //exlcude the decommissioned HO ring2, except SiPMs

       if(mydepth==4 && excludeHORing2_==true)

     if (abs(HDI.ieta())>=11 && abs(HDI.ieta())<=15  && !isSiPM(HDI.ieta(),HDI.iphi(),mydepth))

       problemfound[myeta][myphi-1][mydepth-1] = false;


       if (debug_>0)

     std::cout<<" mapDCCproblem found error! "<<HDI.subdet()<<"("<<HDI.ieta()<<", "<<HDI.iphi()<<", "<<HDI.depth()<<")"<<std::endl;

     }


   }

 }   // void HcalRawDataMonitor::mapHTRproblem(...)


 void HcalRawDataMonitor::mapChannproblem(int dcc, int spigot, int htrchan) {

   int myeta = 0;

   int myphi   =-1;

   int mydepth = 0;

   HcalDetId HDI;

   //Light up the affected cell.

   int i=hashup(dcc,spigot,htrchan);

   HDI = HashToHDI(i);

   if (HDI==HcalDetId::Undefined) {

     return; // Do nothing at all, instead.

   }

   mydepth = HDI.depth();

   myphi   = HDI.iphi();

   myeta = CalcEtaBin(HDI.subdet(),

              HDI.ieta(),

              mydepth);

   //Protect against indexing off array

   if (myeta>=0 && myeta<85 &&

       (myphi-1)>=0 && (myphi-1)<72 &&

       (mydepth-1)>=0 && (mydepth-1)<4){

     problemfound[myeta][myphi-1][mydepth-1] = true;


     //exlcude the decommissioned HO ring2, except SiPMs

     if(mydepth==4 && excludeHORing2_==true)

       if (abs(HDI.ieta())>=11 && abs(HDI.ieta())<=15  && !isSiPM(HDI.ieta(),HDI.iphi(),mydepth))

       problemfound[myeta][myphi-1][mydepth-1] = false;


     if (debug_>0)

       std::cout<<" mapDCCproblem found error! "<<HDI.subdet()<<"("<<HDI.ieta()<<", "<<HDI.iphi()<<", "<<HDI.depth()<<")"<<std::endl;

   }

 }   // void HcalRawDataMonitor::mapChannproblem(...)


 DEFINE_FWK_MODULE(HcalRawDataMonitor);

HcalRawDataMonitor::meCh_DataIntegrityFED04_
MonitorElement * meCh_DataIntegrityFED04_
Definition: HcalRawDataMonitor.h:87

isHO
bool isHO(int etabin, int depth)
Definition: HcalEtaPhiHists.h:479

diffTwoXMLs.label
list label
Definition: diffTwoXMLs.py:42

type
type
Definition: HCALResponse.h:21

HcalDCCHeader
Definition: HcalDCCHeader.h:17

HcalRawDataMonitor::meCh_DataIntegrityFED27_
MonitorElement * meCh_DataIntegrityFED27_
Definition: HcalRawDataMonitor.h:110

edm::ParameterSet::getParameter
T getParameter(std::string const &) const

HcalHTRData::getFib6OrbMsgBCN
unsigned int getFib6OrbMsgBCN() const
Definition: HcalHTRData.h:201

HcalDetId::Undefined
static const HcalDetId Undefined
Definition: HcalDetId.h:50

edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const

HcalRawDataMonitor::meUSFractSpigs_
MonitorElement * meUSFractSpigs_
Definition: HcalRawDataMonitor.h:199

HcalRawDataMonitor::meCh_DataIntegrityFED23_
MonitorElement * meCh_DataIntegrityFED23_
Definition: HcalRawDataMonitor.h:106

i
int i
Definition: DBlmapReader.cc:9

HcalRawDataMonitor::meBCN_
MonitorElement * meBCN_
Definition: HcalRawDataMonitor.h:154

HcalBaseDQMonitor::LumiInOrder
bool LumiInOrder(int lumisec)
Definition: HcalBaseDQMonitor.cc:183

HcalDCCHeader::getSpigotSummary
int getSpigotSummary(int nspigot) const
Definition: HcalDCCHeader.h:82

HcalRawDataMonitor::meCDFErrorFound_
MonitorElement * meCDFErrorFound_
Definition: HcalRawDataMonitor.h:150

HcalHTRData::getNDD
int getNDD() const
Get the number of daq data samples per channel when not zero-suppressed.
Definition: HcalHTRData.cc:388

HcalHTRData::getFib1OrbMsgBCN
unsigned int getFib1OrbMsgBCN() const
Get the BCN of the Fiber Orbit Messages.
Definition: HcalHTRData.h:182

HcalRawDataMonitor::meCrate7HTRStatus_
MonitorElement * meCrate7HTRStatus_
Definition: HcalRawDataMonitor.h:189

HcalRawDataMonitor::label_xFEDs
void label_xFEDs(MonitorElement *me_ptr, int xbins)
Definition: HcalRawDataMonitor.cc:1323

MonitorElement::setBinContent
void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:866

HcalRawDataMonitor::meCrate4HTRStatus_
MonitorElement * meCrate4HTRStatus_
Definition: HcalRawDataMonitor.h:186

FEDTrailer::check
bool check()
Definition: FEDTrailer.cc:64

HcalDCCHeader::getSlink64ReservedBits
unsigned int getSlink64ReservedBits() const
Definition: HcalDCCHeader.h:48

HcalBaseDQMonitor::ProblemsCurrentLB
MonitorElement * ProblemsCurrentLB
Definition: HcalBaseDQMonitor.h:115

HcalRawDataMonitor::HalfHTRDataCorruptionIndicators_
float HalfHTRDataCorruptionIndicators_[(1+((3+1)*32))][(1+((3+1)*15))]
Definition: HcalRawDataMonitor.h:119

HcalRawDataMonitor::beginLuminosityBlock
void beginLuminosityBlock(const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)
Definition: HcalRawDataMonitor.cc:172

HcalBaseDQMonitor::dbe_
DQMStore * dbe_
Definition: HcalBaseDQMonitor.h:95

HcalDCCHeader::getSpigotErrorBits
unsigned char getSpigotErrorBits(unsigned int nspigot) const
Access the HTR error bits (decoding tbd)
Definition: HcalDCCHeader.h:111

HcalRawDataMonitor::meCh_DataIntegrityFED25_
MonitorElement * meCh_DataIntegrityFED25_
Definition: HcalRawDataMonitor.h:108

HcalRawDataMonitor::meCh_DataIntegrityFED13_
MonitorElement * meCh_DataIntegrityFED13_
Definition: HcalRawDataMonitor.h:96

HcalElectronicsMap::allElectronicsIdPrecision
std::vector< HcalElectronicsId > allElectronicsIdPrecision() const
Definition: HcalElectronicsMap.cc:153

HcalDCCHeader::getSpigotDataLength
unsigned int getSpigotDataLength(int nspigot) const
Definition: HcalDCCHeader.h:96

HcalRawDataMonitor::whosebad
void whosebad(int subdet)
Definition: HcalRawDataMonitor.cc:1436

HcalQIESample::raw
uint16_t raw() const
get the raw word
Definition: HcalQIESample.h:20

HcalRawDataMonitor::problemfound
bool problemfound[85][72][4]
Definition: HcalRawDataMonitor.h:76

HcalDetId::subdet
HcalSubdetector subdet() const
get the subdetector
Definition: HcalDetId.h:30

HcalHTRData::check
bool check() const
Check for a good event Requires a minimum length, matching wordcount and length, not an empty event...
Definition: HcalHTRData.cc:62

HcalBaseDQMonitor::prefixME_
std::string prefixME_
Definition: HcalBaseDQMonitor.h:91

HcalBaseDQMonitor::analyze
virtual void analyze(const edm::Event &e, const edm::EventSetup &c)
Definition: HcalBaseDQMonitor.cc:229

fw3dlego::xbins
const double xbins[]
Definition: fw3dlego_xbins.cc:17

HcalRawDataMonitor::meEvtNumberSynch_
MonitorElement * meEvtNumberSynch_
Definition: HcalRawDataMonitor.h:160

TWO_CHANN
#define TWO_CHANN
Definition: HcalRawDataMonitor.h:13

DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:954

HcalRawDataMonitor::meCrate3HTRStatus_
MonitorElement * meCrate3HTRStatus_
Definition: HcalRawDataMonitor.h:185

HcalHTRData::htrTopBottom
unsigned int htrTopBottom() const
HcalElectronicsId-style HTR top/bottom (1=top/0=bottom)
Definition: HcalHTRData.cc:342

HcalRawDataMonitor::mapDCCproblem
void mapDCCproblem(int dcc)
Definition: HcalRawDataMonitor.cc:1455

FEDTrailer
Definition: FEDTrailer.h:13

HcalRawDataMonitor::meCh_DataIntegrityFED02_
MonitorElement * meCh_DataIntegrityFED02_
Definition: HcalRawDataMonitor.h:85

HcalRawDataMonitor::meCh_DataIntegrityFED05_
MonitorElement * meCh_DataIntegrityFED05_
Definition: HcalRawDataMonitor.h:88

HcalRawDataMonitor::meFib5OrbMsgBCN_
MonitorElement * meFib5OrbMsgBCN_
Definition: HcalRawDataMonitor.h:205

HcalRawDataMonitor::ChannSumm_DataIntegrityCheck_
float ChannSumm_DataIntegrityCheck_[(1+((2+1)*32))][(1+((2+1)*15))]
Definition: HcalRawDataMonitor.h:121

THREE_FED
#define THREE_FED
Definition: HcalRawDataMonitor.h:10

edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434

HcalRawDataMonitor::meCh_DataIntegrityFED09_
MonitorElement * meCh_DataIntegrityFED09_
Definition: HcalRawDataMonitor.h:92

HcalDCCHeader::getAcceptTimeTTS
int getAcceptTimeTTS() const
Definition: HcalDCCHeader.h:58

HcalBaseDQMonitor::subdir_
std::string subdir_
Definition: HcalBaseDQMonitor.h:92

HTRCHANMAX
#define HTRCHANMAX
Definition: HcalRawDataClient.h:5

HcalBaseDQMonitor::ProblemsVsLB_HF
MonitorElement * ProblemsVsLB_HF
Definition: HcalBaseDQMonitor.h:114

HcalDbRecord.h

HcalQIESample::fiberChan
int fiberChan() const
get the fiber channel number
Definition: HcalQIESample.h:34

DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17

HWWFunctions::EE
Definition: wwtypes.h:16

HcalRawDataMonitor::meBCNCheck_
MonitorElement * meBCNCheck_
Definition: HcalRawDataMonitor.h:156

NUMDCCS
#define NUMDCCS
Definition: HcalRawDataClient.h:3

HcalBaseDQMonitor::AllowedCalibTypes_
std::vector< int > AllowedCalibTypes_
Definition: HcalBaseDQMonitor.h:86

HcalRawDataMonitor::meCrate17HTRStatus_
MonitorElement * meCrate17HTRStatus_
Definition: HcalRawDataMonitor.h:197

HcalDCCHeader::getSpigotCRCError
bool getSpigotCRCError(unsigned int nspigot) const
Read the &quot;CRC-Mismatch&quot; bit for this spigot.
Definition: HcalDCCHeader.h:109

edm::LuminosityBlock
Definition: LuminosityBlock.h:47

HcalRawDataMonitor::meChannSumm_DataIntegrityCheck_
MonitorElement * meChannSumm_DataIntegrityCheck_
Definition: HcalRawDataMonitor.h:127

FEDNumbering::MINHCALFEDID
Definition: FEDNumbering.h:47

HcalRawDataMonitor::stashHDI
void stashHDI(int thehash, HcalDetId thehcaldetid)
Definition: HcalRawDataMonitor.cc:1355

HcalBaseDQMonitor::cleanup
virtual void cleanup(void)
Definition: HcalBaseDQMonitor.cc:126

edm::LogWarning
Definition: MessageLogger.h:140

HcalRawDataMonitor::processEvent
void processEvent(const FEDRawDataCollection &rawraw, const HcalUnpackerReport &report)
Definition: HcalRawDataMonitor.cc:599

FEDTrailer::moreTrailers
bool moreTrailers()
Definition: FEDTrailer.cc:37

HcalQIESample
Definition: HcalQIESample.h:13

HcalRawDataMonitor::meCrate13HTRStatus_
MonitorElement * meCrate13HTRStatus_
Definition: HcalRawDataMonitor.h:194

MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:942

HcalQIESample::dv
bool dv() const
is the Data Valid bit set?
Definition: HcalQIESample.h:28

edm::EventBase::luminosityBlock
edm::LuminosityBlockNumber_t luminosityBlock() const
Definition: EventBase.h:59

HcalRawDataMonitor::CDFversionNumber_list
std::map< int, short > CDFversionNumber_list
Definition: HcalRawDataMonitor.h:141

HcalRawDataMonitor::meOrNCheck_
MonitorElement * meOrNCheck_
Definition: HcalRawDataMonitor.h:162

HcalHTRData::getExtHdr6
unsigned int getExtHdr6() const
Definition: HcalHTRData.h:226

hitfit::char
char
Definition: Lepjets_Event_Jet.cc:254

NULL
#define NULL
Definition: scimark2.h:8

HcalHTRData
Definition: HcalHTRData.h:16

HcalHTRData::getFib8OrbMsgBCN
unsigned int getFib8OrbMsgBCN() const
Definition: HcalHTRData.h:209

HcalRawDataMonitor::meCrate2HTRStatus_
MonitorElement * meCrate2HTRStatus_
Definition: HcalRawDataMonitor.h:184

HcalRawDataMonitor::CDFReservedBits_list
std::map< int, short > CDFReservedBits_list
Definition: HcalRawDataMonitor.h:143

HcalRawDataMonitor::label_xChanns
void label_xChanns(MonitorElement *me_ptr, int xbins)
Definition: HcalRawDataMonitor.cc:1314

MonitorElement::update
void update(void)
Mark the object updated.
Definition: MonitorElement.h:137

HcalRawDataMonitor::meBCNSynch_
MonitorElement * meBCNSynch_
Definition: HcalRawDataMonitor.h:157

isHE
bool isHE(int etabin, int depth)
Definition: HcalEtaPhiHists.h:429

HcalHTRData::CHANNELS_PER_SPIGOT
static const int CHANNELS_PER_SPIGOT
Definition: HcalHTRData.h:18

HcalDCCHeader::thereIsAThirdCDFHeaderWord
bool thereIsAThirdCDFHeaderWord() const
Definition: HcalDCCHeader.h:44

eta
T eta() const
Definition: Basic3DVectorLD.h:177

edm::Handle
Definition: AssociativeIterator.h:47

HcalHTRData::unpack_per_channel_header
static bool unpack_per_channel_header(unsigned short, int &flav, int &error_flags, int &capid0, int &channelid)
Unpack a per-channel header word (compact format)
Definition: HcalHTRData.cc:433

HcalRawDataMonitor::reset
void reset(void)
Definition: HcalRawDataMonitor.cc:78

HcalRawDataMonitor::meCrate14HTRStatus_
MonitorElement * meCrate14HTRStatus_
Definition: HcalRawDataMonitor.h:195

HcalDCCHeader::getSpigotData
int getSpigotData(int nspigot, HcalHTRData &decodeTool, int validSize) const
Definition: HcalDCCHeader.cc:27

HcalRawDataMonitor::meCh_DataIntegrityFED03_
MonitorElement * meCh_DataIntegrityFED03_
Definition: HcalRawDataMonitor.h:86

HcalRawDataMonitor::analyze
void analyze(const edm::Event &e, const edm::EventSetup &c)
Definition: HcalRawDataMonitor.cc:528

HcalDCCHeader::getLRBErrorBits
unsigned char getLRBErrorBits(unsigned int nspigot) const
Access the Link Receiver Board error bits (decoding tbd)
Definition: HcalDCCHeader.h:113

NUMSPIGS
#define NUMSPIGS
Definition: HcalEEUSMonitor.h:4

HcalHTRData::getOrbitNumber
unsigned int getOrbitNumber() const
Get the HTR orbit number.
Definition: HcalHTRData.cc:324

HcalRawDataMonitor::labelHTRBits
void labelHTRBits(MonitorElement *mePlot, unsigned int axisType)
Definition: HcalRawDataMonitor.cc:1331

HcalHTRData::getFormatVersion
int getFormatVersion() const
Get the version number of this event.
Definition: HcalHTRData.h:33

detailsBasic3DVector::z
float float float z
Definition: extBasic3DVector.h:15

FEDRawData::size
size_t size() const
Lenght of the data buffer in bytes.
Definition: FEDRawData.h:47

HcalRawDataMonitor::meCrate15HTRStatus_
MonitorElement * meCrate15HTRStatus_
Definition: HcalRawDataMonitor.h:196

AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

HcalRawDataMonitor::beginRun
void beginRun(const edm::Run &run, const edm::EventSetup &c)
Definition: HcalRawDataMonitor.cc:131

HcalRawDataMonitor::problemcount
uint64_t problemcount[85][72][4]
Definition: HcalRawDataMonitor.h:75

HcalRawDataMonitor::meDataFlowInd_
MonitorElement * meDataFlowInd_
Definition: HcalRawDataMonitor.h:128

MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:166

HcalBaseDQMonitor::ievt_
int ievt_
Definition: HcalBaseDQMonitor.h:96

HcalRawDataMonitor::meCh_DataIntegrityFED14_
MonitorElement * meCh_DataIntegrityFED14_
Definition: HcalRawDataMonitor.h:97

HcalRawDataMonitor::CDFReservedBits_it
std::map< int, short >::iterator CDFReservedBits_it
Definition: HcalRawDataMonitor.h:144

edm::LuminosityBlockBase::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockBase.h:45

DEPTHBINS
#define DEPTHBINS
Definition: HcalDigiMonitor.h:25

HcalBaseDQMonitor::mergeRuns_
bool mergeRuns_
Definition: HcalBaseDQMonitor.h:88

zeeHLT_cff.report
tuple report
Definition: zeeHLT_cff.py:9

HcalDCCHeader::getOrbitNumber
unsigned int getOrbitNumber() const
Definition: HcalDCCHeader.h:46

TWO__SPGT
#define TWO__SPGT
Definition: HcalRawDataMonitor.h:11

HcalDCCHeader::getBunchId
int getBunchId() const
Definition: HcalDCCHeader.h:34

isSiPM
bool isSiPM(int ieta, int iphi, int depth)
Definition: HcalEtaPhiHists.h:489

HcalHTRData::htrSlot
unsigned int htrSlot() const
HcalElectronicsId-style HTR slot.
Definition: HcalHTRData.cc:338

HcalDetId::depth
int depth() const
get the tower depth
Definition: HcalDetId.h:40

HcalRawDataMonitor::meCrate6HTRStatus_
MonitorElement * meCrate6HTRStatus_
Definition: HcalRawDataMonitor.h:188

HcalRawDataMonitor::setup
void setup(void)
Definition: HcalRawDataMonitor.cc:181

HcalBaseDQMonitor::beginRun
virtual void beginRun(const edm::Run &run, const edm::EventSetup &c)
Definition: HcalBaseDQMonitor.cc:87

HcalBaseDQMonitor::meTevtHist_
MonitorElement * meTevtHist_
Definition: HcalBaseDQMonitor.h:102

FEDRawDataCollection::FEDData
const FEDRawData & FEDData(int fedid) const
retrieve data for fed
Definition: FEDRawDataCollection.cc:28

HcalRawDataMonitor::FEDRawDataCollection_
edm::InputTag FEDRawDataCollection_
Definition: HcalRawDataMonitor.h:57

HcalObjRepresent::CalcIeta
int CalcIeta(int subdet, int eta, int depth)
Definition: HcalObjRepresent.h:200

HcalRawDataMonitor::meCh_DataIntegrityFED24_
MonitorElement * meCh_DataIntegrityFED24_
Definition: HcalRawDataMonitor.h:107

HcalRawDataMonitor::DCCEvtFormat_it
std::map< int, short >::iterator DCCEvtFormat_it
Definition: HcalRawDataMonitor.h:146

HcalRawDataMonitor::tok_raw_
edm::EDGetTokenT< FEDRawDataCollection > tok_raw_
Definition: HcalRawDataMonitor.h:60

HcalHTRData::is_channel_header
static bool is_channel_header(unsigned short value)
check top bit to see if this is a compact format channel header word
Definition: HcalHTRData.h:90

HcalBaseDQMonitor::IsAllowedCalibType
bool IsAllowedCalibType()
Definition: HcalBaseDQMonitor.cc:192

HcalRawDataMonitor::meCh_DataIntegrityFED06_
MonitorElement * meCh_DataIntegrityFED06_
Definition: HcalRawDataMonitor.h:89

HcalDCCHeader::getBxMismatchWithDCC
bool getBxMismatchWithDCC(unsigned int nspigot) const
Read the &quot;BxID FAILS TO MATCH WITH DCC&quot; bit for this spigot.
Definition: HcalDCCHeader.h:103

HcalRawDataMonitor::hashedHcalDetId_
HcalDetId hashedHcalDetId_[32 *15 *24]
Definition: HcalRawDataMonitor.h:135

HcalHTRData::getFib7OrbMsgBCN
unsigned int getFib7OrbMsgBCN() const
Definition: HcalHTRData.h:205

HcalBaseDQMonitor::ProblemsVsLB_HBHEHF
MonitorElement * ProblemsVsLB_HBHEHF
Definition: HcalBaseDQMonitor.h:114

HcalBaseDQMonitor::enableCleanup_
bool enableCleanup_
Definition: HcalBaseDQMonitor.h:89

HcalEndcap
Definition: HcalAssistant.h:31

HcalRawDataMonitor::readoutMap_
const HcalElectronicsMap * readoutMap_
Definition: HcalRawDataMonitor.h:63

FEDRawData
Definition: FEDRawData.h:20

HcalBaseDQMonitor::ProblemsVsLB_HB
MonitorElement * ProblemsVsLB_HB
Definition: HcalBaseDQMonitor.h:113

HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611

HcalRawDataMonitor::HTR_StatusWd_HO
MonitorElement * HTR_StatusWd_HO
Definition: HcalRawDataMonitor.h:175

HcalDetId
Definition: HcalDetId.h:16

HcalRawDataMonitor::NumBadHB
int NumBadHB
Definition: HcalRawDataMonitor.h:210

HcalRawDataMonitor::meCrate5HTRStatus_
MonitorElement * meCrate5HTRStatus_
Definition: HcalRawDataMonitor.h:187

edm::ESHandle< HcalDbService >

HcalRawDataMonitor::unpack
void unpack(const FEDRawData &raw)
Definition: HcalRawDataMonitor.cc:633

HcalRawDataMonitor::NumBadHFLUMI
int NumBadHFLUMI
Definition: HcalRawDataMonitor.h:210

HcalRawDataMonitor::meCrate0HTRStatus_
MonitorElement * meCrate0HTRStatus_
Definition: HcalRawDataMonitor.h:182

HcalHTRData::getRawLength
const int getRawLength() const
Get the length of the raw data.
Definition: HcalHTRData.h:39

HcalRawDataMonitor::NumBadHO0
int NumBadHO0
Definition: HcalRawDataMonitor.h:210

HcalDetId::ieta
int ieta() const
get the cell ieta
Definition: HcalDetId.h:36

HcalBaseDQMonitor::beginLuminosityBlock
virtual void beginLuminosityBlock(const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)
Definition: HcalBaseDQMonitor.cc:164

HcalSubdetector
HcalSubdetector
Definition: HcalAssistant.h:31

HcalUnpackerReport
Definition: HcalUnpackerReport.h:14

funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22

HcalBarrel
Definition: HcalAssistant.h:31

HcalRawDataMonitor::meOrNSynch_
MonitorElement * meOrNSynch_
Definition: HcalRawDataMonitor.h:163

HcalRawDataMonitor::NumBadHO12
int NumBadHO12
Definition: HcalRawDataMonitor.h:210

HcalRawDataMonitor::endRun
void endRun(const edm::Run &run, const edm::EventSetup &c)
Definition: HcalRawDataMonitor.cc:1296

f
double f[11][100]
Definition: MuScleFitUtils.cc:78

HcalBaseDQMonitor::makeDiagnostics_
bool makeDiagnostics_
Definition: HcalBaseDQMonitor.h:106

edm::EventSetup
Definition: EventSetup.h:44

HcalRawDataMonitor::label_ySpigots
void label_ySpigots(MonitorElement *me_ptr, int ybins)
Definition: HcalRawDataMonitor.cc:1305

HcalQIESample::fiber
int fiber() const
get the fiber number
Definition: HcalQIESample.h:32

HcalForward
Definition: HcalAssistant.h:31

HcalDCCHeader::getSpigotPresent
bool getSpigotPresent(unsigned int nspigot) const
Read the &quot;PRESENT&quot; bit for this spigot.
Definition: HcalDCCHeader.h:101

HcalRawDataMonitor::meCh_DataIntegrityFED11_
MonitorElement * meCh_DataIntegrityFED11_
Definition: HcalRawDataMonitor.h:94

DQMStore::bookProfile
MonitorElement * bookProfile(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, const char *option="s")
Definition: DQMStore.cc:1268

HcalRawDataMonitor::meCrate12HTRStatus_
MonitorElement * meCrate12HTRStatus_
Definition: HcalRawDataMonitor.h:193

HcalRawDataMonitor::uniqcounter
uint64_t uniqcounter[85][72][4]
Definition: HcalRawDataMonitor.h:73

HcalRawDataMonitor::CDFvers_it
std::map< int, short >::iterator CDFvers_it
Definition: HcalRawDataMonitor.h:142

HcalRawDataMonitor::meCh_DataIntegrityFED17_
MonitorElement * meCh_DataIntegrityFED17_
Definition: HcalRawDataMonitor.h:100

min
T min(T a, T b)
Definition: MathUtil.h:58

isHB
bool isHB(int etabin, int depth)
Definition: HcalEtaPhiHists.h:407

HcalRawDataMonitor::meFibBCN_
MonitorElement * meFibBCN_
Definition: HcalRawDataMonitor.h:178

HcalRawDataMonitor::~HcalRawDataMonitor
~HcalRawDataMonitor()
Definition: HcalRawDataMonitor.cc:75

DetId::subdetId
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37

HcalRawDataMonitor::UScount
uint64_t UScount[32][15]
Definition: HcalRawDataMonitor.h:118

HcalBaseDQMonitor::tevt_
int tevt_
Definition: HcalBaseDQMonitor.h:98

HcalRawDataMonitor::meDCCEventFormatError_
MonitorElement * meDCCEventFormatError_
Definition: HcalRawDataMonitor.h:151

DTTTrigCorrFirst.run
run
Definition: DTTTrigCorrFirst.py:63

HcalRawDataMonitor::meCh_DataIntegrityFED30_
MonitorElement * meCh_DataIntegrityFED30_
Definition: HcalRawDataMonitor.h:113

HcalRawDataMonitor::medccBCN_
MonitorElement * medccBCN_
Definition: HcalRawDataMonitor.h:155

HcalRawDataMonitor::meCh_DataIntegrityFED12_
MonitorElement * meCh_DataIntegrityFED12_
Definition: HcalRawDataMonitor.h:95

HcalHTRData::getFib3OrbMsgBCN
unsigned int getFib3OrbMsgBCN() const
Definition: HcalHTRData.h:189

HcalRawDataMonitor::Chann_DataIntegrityCheck_
float Chann_DataIntegrityCheck_[32][(1+((2+1)*24))][(1+((2+1)*15))]
Definition: HcalRawDataMonitor.h:122

TWO___FED
#define TWO___FED
Definition: HcalRawDataMonitor.h:9

HcalRawDataMonitor::HTR_StatusWd_HBHE
MonitorElement * HTR_StatusWd_HBHE
Definition: HcalRawDataMonitor.h:173

HcalDCCHeader::getSpigotEnabled
bool getSpigotEnabled(unsigned int nspigot) const
Read the &quot;ENABLED&quot; bit for this spigot.
Definition: HcalDCCHeader.h:99

HcalRawDataMonitor::meCh_DataIntegrityFED10_
MonitorElement * meCh_DataIntegrityFED10_
Definition: HcalRawDataMonitor.h:93

HcalRawDataMonitor::meFib4OrbMsgBCN_
MonitorElement * meFib4OrbMsgBCN_
Definition: HcalRawDataMonitor.h:204

HcalRawDataMonitor::excludeHORing2_
bool excludeHORing2_
Definition: HcalRawDataMonitor.h:214

FEDTrailer::ttsBits
int ttsBits()
Current value of the Trigger Throttling System bitsAQ).
Definition: FEDTrailer.cc:32

HcalRawDataMonitor::meInvHTRData_
MonitorElement * meInvHTRData_
Definition: HcalRawDataMonitor.h:177

HcalDCCHeader::getSourceId
int getSourceId() const
Definition: HcalDCCHeader.h:32

HcalRawDataMonitor::meCh_DataIntegrityFED19_
MonitorElement * meCh_DataIntegrityFED19_
Definition: HcalRawDataMonitor.h:102

HcalDetId::iphi
int iphi() const
get the cell iphi
Definition: HcalDetId.h:38

MonitorElement
Definition: MonitorElement.h:34

HcalRawDataMonitor::mapHTRproblem
void mapHTRproblem(int dcc, int spigot)
Definition: HcalRawDataMonitor.cc:1488

HcalRawDataMonitor.h

DetId
Definition: DetId.h:18

HcalRawDataMonitor::meEvtNCheck_
MonitorElement * meEvtNCheck_
Definition: HcalRawDataMonitor.h:159

HcalRawDataMonitor::meBCNwhenOrNDiff_
MonitorElement * meBCNwhenOrNDiff_
Definition: HcalRawDataMonitor.h:164

HcalRawDataMonitor::UpdateMEs
void UpdateMEs(void)
Definition: HcalRawDataMonitor.cc:1390

isHF
bool isHF(int etabin, int depth)
Definition: HcalEtaPhiHists.h:455

HcalOuter
Definition: HcalAssistant.h:31

HcalRawDataMonitor::meFib1OrbMsgBCN_
MonitorElement * meFib1OrbMsgBCN_
Definition: HcalRawDataMonitor.h:201

HcalRawDataMonitor::HTRPrint
void HTRPrint(const HcalHTRData &htr, int prtlvl)
Definition: HcalRawDataMonitor.cc:1364

cond::uint64_t
unsigned long long uint64_t
Definition: Time.h:15

HcalRawDataMonitor::meCrate11HTRStatus_
MonitorElement * meCrate11HTRStatus_
Definition: HcalRawDataMonitor.h:192

HcalQIESample::capid
int capid() const
get the Capacitor id
Definition: HcalQIESample.h:26

HcalRawDataMonitor::meFib8OrbMsgBCN_
MonitorElement * meFib8OrbMsgBCN_
Definition: HcalRawDataMonitor.h:208

detailsBasic3DVector::y
float float y
Definition: extBasic3DVector.h:15

HcalHTRData::getFib5OrbMsgBCN
unsigned int getFib5OrbMsgBCN() const
Definition: HcalHTRData.h:197

HcalHTRData::getRawData
const unsigned short * getRawData() const
Get a pointer to the raw data.
Definition: HcalHTRData.h:36

FEDTrailer::lenght
int lenght()
The length of the event fragment counted in 64-bit words including header and trailer.
Definition: FEDTrailer.cc:17

HcalRawDataMonitor::meLRBDataCorruptionIndicators_
MonitorElement * meLRBDataCorruptionIndicators_
Definition: HcalRawDataMonitor.h:126

HcalHTRData::dataPointers
void dataPointers(const unsigned short **daq_first, const unsigned short **daq_last, const unsigned short **tp_first, const unsigned short **tp_last) const
Obtain the starting and ending pointers for external unpacking of the data.
Definition: HcalHTRData.cc:153

HcalRawDataMonitor::meCh_DataIntegrityFED08_
MonitorElement * meCh_DataIntegrityFED08_
Definition: HcalRawDataMonitor.h:91

HcalRawDataMonitor::tok_unpack_
edm::EDGetTokenT< HcalUnpackerReport > tok_unpack_
Definition: HcalRawDataMonitor.h:61

HcalHTRData::getErrorsWord
unsigned int getErrorsWord() const
Get the errors word.
Definition: HcalHTRData.h:156

HcalRawDataMonitor::meCh_DataIntegrityFED29_
MonitorElement * meCh_DataIntegrityFED29_
Definition: HcalRawDataMonitor.h:112

HcalRawDataMonitor::meCh_DataIntegrityFED00_
MonitorElement * meCh_DataIntegrityFED00_
Definition: HcalRawDataMonitor.h:83

edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55

ETABINS
#define ETABINS
Definition: HcalBaseMonitor.h:5

DetId::null
bool null() const
is this a null id ?
Definition: DetId.h:45

HcalRawDataMonitor::meCh_DataIntegrityFED26_
MonitorElement * meCh_DataIntegrityFED26_
Definition: HcalRawDataMonitor.h:109

alignCSCRings.s
list s
Definition: alignCSCRings.py:91

HcalRawDataMonitor::meCrate1HTRStatus_
MonitorElement * meCrate1HTRStatus_
Definition: HcalRawDataMonitor.h:183

HcalHTRData::getExtHdr7
unsigned int getExtHdr7() const
Definition: HcalHTRData.h:228

HcalBaseDQMonitor::levt_
int levt_
Definition: HcalBaseDQMonitor.h:97

trackerHits.c
tuple c
Definition: trackerHits.py:26

HcalDbRecord
Definition: HcalDbRecord.h:29

HcalRawDataMonitor::meStatusWdCrate_
MonitorElement * meStatusWdCrate_
Definition: HcalRawDataMonitor.h:176

HcalRawDataMonitor::meFib7OrbMsgBCN_
MonitorElement * meFib7OrbMsgBCN_
Definition: HcalRawDataMonitor.h:207

HcalBaseDQMonitor::ProblemsVsLB_HE
MonitorElement * ProblemsVsLB_HE
Definition: HcalBaseDQMonitor.h:113

HcalRawDataMonitor::LRBDataCorruptionIndicators_
float LRBDataCorruptionIndicators_[(1+((3+1)*32))][(1+((3+1)*15))]
Definition: HcalRawDataMonitor.h:120

HcalDCCHeader::BOEshouldBeZeroAlways
short BOEshouldBeZeroAlways() const
Definition: HcalDCCHeader.h:50

HcalRawDataMonitor::endLuminosityBlock
void endLuminosityBlock(const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)
Definition: HcalRawDataMonitor.cc:1257

HcalRawDataMonitor::mapChannproblem
void mapChannproblem(int dcc, int spigot, int htrchan)
Definition: HcalRawDataMonitor.cc:1524

CalcEtaBin
int CalcEtaBin(int subdet, int ieta, int depth)
Definition: HcalEtaPhiHists.h:202

FEDRawDataCollection
Definition: FEDRawDataCollection.h:19

HcalHTRData::readoutVMECrateId
unsigned int readoutVMECrateId() const
HcalElectronicsId-style VME crate number.
Definition: HcalHTRData.cc:346

HcalDCCHeader::getSpigotValid
bool getSpigotValid(unsigned int nspigot) const
Read the &quot;VALID&quot; bit for this spigot; TTC EvN matched HTR EvN.
Definition: HcalDCCHeader.h:105

alignCSCRings.e
list e
Definition: alignCSCRings.py:90

HcalRawDataMonitor::meCh_DataIntegrityFED16_
MonitorElement * meCh_DataIntegrityFED16_
Definition: HcalRawDataMonitor.h:99

THREE_SPG
#define THREE_SPG
Definition: HcalRawDataMonitor.h:12

HcalHTRData::getFib4OrbMsgBCN
unsigned int getFib4OrbMsgBCN() const
Definition: HcalHTRData.h:193

HcalDCCHeader.h

HcalRawDataMonitor::meCh_DataIntegrityFED07_
MonitorElement * meCh_DataIntegrityFED07_
Definition: HcalRawDataMonitor.h:90

HcalBaseDQMonitor::Online_
bool Online_
Definition: HcalBaseDQMonitor.h:87

bookConverter.max
max
Definition: bookConverter.py:166

HcalDCCHeader::SPIGOT_COUNT
static const int SPIGOT_COUNT
Definition: HcalDCCHeader.h:19

MonitorElement::getBinContent
double getBinContent(int binx) const
get content of bin (1-D)
Definition: MonitorElement.cc:765

HcalBaseDQMonitor::NLumiBlocks_
int NLumiBlocks_
Definition: HcalBaseDQMonitor.h:117

LuminosityBlock.h

HcalRawDataMonitor::meEvFragSize_
MonitorElement * meEvFragSize_
Definition: HcalRawDataMonitor.h:168

HcalRawDataMonitor::HTR_StatusWd_HF
MonitorElement * HTR_StatusWd_HF
Definition: HcalRawDataMonitor.h:174

edm::InputTag
Definition: InputTag.h:17

HcalRawDataMonitor::meCh_DataIntegrityFED28_
MonitorElement * meCh_DataIntegrityFED28_
Definition: HcalRawDataMonitor.h:111

update
#define update(a, b)
Definition: TrackClassifier.cc:10

MonitorElement::getTProfile
TProfile * getTProfile(void) const
Definition: MonitorElement.cc:1595

HcalHTRData::getBunchNumber
unsigned int getBunchNumber() const
Get the HTR bunch number.
Definition: HcalHTRData.h:114

HcalHTRData::getFib2OrbMsgBCN
unsigned int getFib2OrbMsgBCN() const
Definition: HcalHTRData.h:185

FEDRawData::data
const unsigned char * data() const
Return a const pointer to the beginning of the data buffer.
Definition: FEDRawData.cc:28

HcalRawDataMonitor::meFib2OrbMsgBCN_
MonitorElement * meFib2OrbMsgBCN_
Definition: HcalRawDataMonitor.h:202

PHIBINS
#define PHIBINS
Definition: HcalBaseMonitor.h:6

HcalRawDataMonitor::meEvFragSize2_
MonitorElement * meEvFragSize2_
Definition: HcalRawDataMonitor.h:169

HcalRawDataMonitor::NumBadHO
int NumBadHO
Definition: HcalRawDataMonitor.h:210

HcalDCCHeader::getSpigotDataTruncated
bool getSpigotDataTruncated(unsigned int nspigot) const
Read the &quot;TRUNCATED&quot; bit for this spigot; LRB truncated data (took too long)
Definition: HcalDCCHeader.h:107

FEDNumbering::MAXHCALFEDID
Definition: FEDNumbering.h:48

HcalRawDataMonitor::DataFlowInd_
float DataFlowInd_[(1+((2+1)*32))][(1+((3+1)*15))]
Definition: HcalRawDataMonitor.h:123

edm::ParameterSet
Definition: ParameterSet.h:35

gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121

HcalDCCHeader::getCDFversionNumber
short getCDFversionNumber() const
Definition: HcalDCCHeader.h:30

HcalDCCHeader::getDCCDataFormatVersion
short getDCCDataFormatVersion() const
Definition: HcalDCCHeader.h:57

HcalRawDataMonitor::meDCCVersion_
MonitorElement * meDCCVersion_
Definition: HcalRawDataMonitor.h:170

HcalRawDataMonitor::meCh_DataIntegrityFED20_
MonitorElement * meCh_DataIntegrityFED20_
Definition: HcalRawDataMonitor.h:103

HcalRawDataMonitor::DCCEvtFormat_list
std::map< int, short > DCCEvtFormat_list
Definition: HcalRawDataMonitor.h:145

HcalBaseDQMonitor::ProblemsVsLB_HO
MonitorElement * ProblemsVsLB_HO
Definition: HcalBaseDQMonitor.h:114

HcalBaseDQMonitor::debug_
int debug_
Definition: HcalBaseDQMonitor.h:90

HcalRawDataMonitor::meCrate10HTRStatus_
MonitorElement * meCrate10HTRStatus_
Definition: HcalRawDataMonitor.h:191

HcalHTRData::getFirmwareRevision
unsigned int getFirmwareRevision() const
Get the HTR firmware version.
Definition: HcalHTRData.cc:406

x
Definition: DDAxes.h:10

HcalBaseDQMonitor::ProblemsVsLB
MonitorElement * ProblemsVsLB
Definition: HcalBaseDQMonitor.h:112

HcalRawDataMonitor::meHTRFWVersion_
MonitorElement * meHTRFWVersion_
Definition: HcalRawDataMonitor.h:200

HcalRawDataMonitor::meFEDRawDataSizes_
MonitorElement * meFEDRawDataSizes_
Definition: HcalRawDataMonitor.h:167

edm::Event
Definition: Event.h:62

DQMStore::bookInt
MonitorElement * bookInt(const char *name)
Book int.
Definition: DQMStore.cc:861

HcalDCCHeader::BOEshouldBe5Always
unsigned short BOEshouldBe5Always() const
Definition: HcalDCCHeader.h:40

DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:1082

HcalRawDataMonitor::meCh_DataIntegrityFED01_
MonitorElement * meCh_DataIntegrityFED01_
Definition: HcalRawDataMonitor.h:84

HcalRawDataMonitor::mefedEntries_
MonitorElement * mefedEntries_
Definition: HcalRawDataMonitor.h:166

HcalBaseDQMonitor::setup
virtual void setup(void)
Definition: HcalBaseDQMonitor.cc:131

HcalRawDataMonitor::meCh_DataIntegrityFED15_
MonitorElement * meCh_DataIntegrityFED15_
Definition: HcalRawDataMonitor.h:98

DetId::det
Detector det() const
get the detector field from this detid
Definition: DetId.h:35

HcalHTRData::getL1ANumber
unsigned int getL1ANumber() const
Get the HTR event number.
Definition: HcalHTRData.h:110

HcalRawDataMonitor::HcalRawDataMonitor
HcalRawDataMonitor()
Definition: HcalRawDataMonitor.h:36

MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:969

HcalRawDataMonitor::meCh_DataIntegrityFED31_
MonitorElement * meCh_DataIntegrityFED31_
Definition: HcalRawDataMonitor.h:114

HcalDCCHeader::thereIsASecondCDFHeaderWord
bool thereIsASecondCDFHeaderWord() const
Definition: HcalDCCHeader.h:28

HcalRawDataMonitor::HashToHDI
HcalDetId HashToHDI(int thehash)
Definition: HcalRawDataMonitor.h:69

MonitorElement::Reset
void Reset(void)
reset ME (ie. contents, errors, etc)
Definition: MonitorElement.cc:475

HcalDCCHeader::getDCCEventNumber
unsigned long getDCCEventNumber() const
Definition: HcalDCCHeader.h:36

HcalBaseDQMonitor::skipOutOfOrderLS_
bool skipOutOfOrderLS_
Definition: HcalBaseDQMonitor.h:105

HcalRawDataMonitor::endJob
void endJob(void)
Definition: HcalRawDataMonitor.cc:1299

HcalRawDataMonitor::meHalfHTRDataCorruptionIndicators_
MonitorElement * meHalfHTRDataCorruptionIndicators_
Definition: HcalRawDataMonitor.h:125

HcalRawDataMonitor::digiLabel_
edm::InputTag digiLabel_
Definition: HcalRawDataMonitor.h:58

HcalRawDataMonitor::hashup
int hashup(uint32_t d=0, uint32_t s=0, uint32_t c=1)
Definition: HcalRawDataMonitor.h:65

HcalRawDataMonitor::meFib3OrbMsgBCN_
MonitorElement * meFib3OrbMsgBCN_
Definition: HcalRawDataMonitor.h:203

HcalElectronicsMap::lookup
const DetId lookup(HcalElectronicsId fId) const
lookup the logical detid associated with the given electronics id
Definition: HcalElectronicsMap.cc:104

HcalRawDataMonitor
Definition: HcalRawDataMonitor.h:32

HcalRawDataMonitor::meChann_DataIntegrityCheck_
MonitorElement * meChann_DataIntegrityCheck_[32]
Definition: HcalRawDataMonitor.h:116

HcalQIESample::er
bool er() const
is the error bit set?
Definition: HcalQIESample.h:30

HcalRawDataMonitor::NumBadHE
int NumBadHE
Definition: HcalRawDataMonitor.h:210

HcalRawDataMonitor::meCh_DataIntegrityFED21_
MonitorElement * meCh_DataIntegrityFED21_
Definition: HcalRawDataMonitor.h:104

HcalRawDataMonitor::NumBadHF
int NumBadHF
Definition: HcalRawDataMonitor.h:210

HcalRawDataMonitor::meFib6OrbMsgBCN_
MonitorElement * meFib6OrbMsgBCN_
Definition: HcalRawDataMonitor.h:206

DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:667

HcalHTRData::isHistogramEvent
bool isHistogramEvent() const
Is this event a histogram event? (do not call standard unpack in this case!!!!!)
Definition: HcalHTRData.cc:385

edm::Run
Definition: Run.h:41

HcalDbService.h

HcalRawDataMonitor::meCh_DataIntegrityFED18_
MonitorElement * meCh_DataIntegrityFED18_
Definition: HcalRawDataMonitor.h:101

HcalEmpty
Definition: HcalAssistant.h:31

HcalRawDataMonitor::meCrate9HTRStatus_
MonitorElement * meCrate9HTRStatus_
Definition: HcalRawDataMonitor.h:190

HcalRawDataMonitor::meCh_DataIntegrityFED22_
MonitorElement * meCh_DataIntegrityFED22_
Definition: HcalRawDataMonitor.h:105

phi
Definition: DDAxes.h:10