#include <RawDataTask.h>

Inheritance diagram for ecaldqm::RawDataTask:

Public Types
enum	Constants { nEventTypes = 25 }

enum	MESets { kEventTypePreCalib, kEventTypeCalib, kEventTypePostCalib, kCRC, kRunNumber, kOrbit, kTriggerType, kL1ADCC, kL1AFE, kL1ATCC, kL1ASRP, kBXDCC, kBXFE, kBXTCC, kBXSRP, kDesyncByLumi, kDesyncTotal, kFEStatus, kFEByLumi, kFEDEntries, kFEDFatal, nMESets }

Public Types inherited from ecaldqm::DQWorker
enum	MESets { nMESets }

Public Member Functions
void	analyze (const void *, Collections) override

void	beginEvent (const edm::Event &, const edm::EventSetup &) override

void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) override

void	bookMEs () override

	RawDataTask (const edm::ParameterSet &, const edm::ParameterSet &)

void	runOnRawData (const EcalRawDataCollection &, Collections)

void	runOnSource (const FEDRawDataCollection &, Collections)

	~RawDataTask ()

Public Member Functions inherited from ecaldqm::DQWorkerTask
	DQWorkerTask (const edm::ParameterSet &, const edm::ParameterSet &, std::string const &)

virtual void	endEvent (const edm::Event &, const edm::EventSetup &)

virtual bool	filterRunType (const std::vector< short > &)

virtual bool	filterTrigger (const edm::TriggerResultsByName &)

virtual const std::vector < std::pair< Collections, Collections > > &	getDependencies ()

virtual bool	runsOn (unsigned)

virtual	~DQWorkerTask ()

Public Member Functions inherited from ecaldqm::DQWorker
virtual void	beginRun (const edm::Run &, const edm::EventSetup &)

	DQWorker (const edm::ParameterSet &, const edm::ParameterSet &, std::string const &)

virtual void	endLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &)

virtual void	endRun (const edm::Run &, const edm::EventSetup &)

const std::vector< MESet * > &	getMEs ()

virtual std::string const &	getName ()

virtual bool	isInitialized ()

virtual void	reset ()

virtual void	setInitialized (bool _init)

virtual void	setVerbosity (int _verbosity)

virtual	~DQWorker ()

Static Public Member Functions
static void	setMEData (std::vector< MEData > &)

Static Public Member Functions inherited from ecaldqm::DQWorker
static void	setMEData (std::vector< MEData > &)

Private Attributes
int	bx_

int	feL1Offset_

std::string	hltTaskFolder_

int	hltTaskMode_

int	l1A_

int	orbit_

int	run_

short	triggerType_

Additional Inherited Members
Static Public Attributes inherited from ecaldqm::DQWorker
static std::map< std::string, std::vector< MEData > >	meData

Protected Member Functions inherited from ecaldqm::DQWorker
MESet *	createMESet_ (std::string const &, MEData const &, bool _readOnly=false) const

void	meSet_ (unsigned, edm::ParameterSet const &)

Protected Attributes inherited from ecaldqm::DQWorkerTask
uint32_t	collectionMask_

std::vector< std::pair < Collections, Collections > >	dependencies_

Protected Attributes inherited from ecaldqm::DQWorker
bool	initialized_

std::vector< MESet * >	MEs_

std::string	name_

int	verbosity_

Detailed Description

Definition at line 11 of file RawDataTask.h.

Member Enumeration Documentation

enum ecaldqm::RawDataTask::Constants

Enumerator
nEventTypes

Definition at line 52 of file RawDataTask.h.

                    {
       nEventTypes = 25
     };

enum ecaldqm::RawDataTask::MESets

Enumerator
kEventTypePreCalib
kEventTypeCalib
kEventTypePostCalib
kCRC
kRunNumber
kOrbit
kTriggerType
kL1ADCC
kL1AFE
kL1ATCC
kL1ASRP
kBXDCC
kBXFE
kBXTCC
kBXSRP
kDesyncByLumi
kDesyncTotal
kFEStatus
kFEByLumi
kFEDEntries
kFEDFatal
nMESets

Definition at line 26 of file RawDataTask.h.

                 {
       kEventTypePreCalib, // h1f
       kEventTypeCalib, // h1f
       kEventTypePostCalib, // h1f
       kCRC, // h1f
       kRunNumber, // h1f
       kOrbit, // h1f
       kTriggerType, // h1f
       kL1ADCC, // h1f
       kL1AFE, // h1f
       //      kL1AFEMap, // h2f
       kL1ATCC, // h1f
       kL1ASRP, // h1f
       kBXDCC, // h1f
       kBXFE, // h1f
       kBXTCC, // h1f
       kBXSRP, // h1f
       kDesyncByLumi, // h1f
       kDesyncTotal, // h1f
       kFEStatus, // h1f
       kFEByLumi, // h1f
       kFEDEntries,
       kFEDFatal,
       nMESets
     };

Constructor & Destructor Documentation

ecaldqm::RawDataTask::RawDataTask	(	const edm::ParameterSet &	_params,
		const edm::ParameterSet &	_paths
	)

Definition at line 12 of file RawDataTask.cc.

References ecaldqm::DQWorkerTask::collectionMask_, ecaldqm::DQWorkerTask::dependencies_, edm::ParameterSet::getUntrackedParameterSet(), hltTaskFolder_, hltTaskMode_, ecaldqm::kEcalRawData, kFEDEntries, kFEDFatal, ecaldqm::kLumiSection, ecaldqm::kSource, ecaldqm::DQWorker::MEs_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                         :
     DQWorkerTask(_params, _paths, "RawDataTask"),
     hltTaskMode_(0),
     hltTaskFolder_(""),
     run_(0),
     l1A_(0),
     orbit_(0),
     bx_(0),
     triggerType_(0),
     feL1Offset_(0)
   {
     collectionMask_ = 
       (0x1 << kLumiSection) |
       (0x1 << kSource) |
       (0x1 << kEcalRawData);
 
     dependencies_.push_back(std::pair<Collections, Collections>(kEcalRawData, kSource));
 
     edm::ParameterSet const& commonParams(_params.getUntrackedParameterSet("Common"));
 
     hltTaskMode_ = commonParams.getUntrackedParameter<int>("hltTaskMode");
     hltTaskFolder_ = commonParams.getUntrackedParameter<std::string>("hltTaskFolder");
 
     if(hltTaskMode_ != 0 && hltTaskFolder_.size() == 0)
     throw cms::Exception("InvalidConfiguration") << "HLTTask mode needs a folder name";
 
     if(hltTaskMode_ != 0){
       std::map<std::string, std::string> replacements;
       replacements["hlttask"] = hltTaskFolder_;
 
       MEs_[kFEDEntries]->name(replacements);
       MEs_[kFEDFatal]->name(replacements);
     }
   }

ecaldqm::RawDataTask::~RawDataTask ( )

Definition at line 47 of file RawDataTask.cc.

48 {

49 }

Member Function Documentation

void ecaldqm::RawDataTask::analyze	(	const void *	_p,
		Collections	_collection
	)

inlineoverridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 70 of file RawDataTask.h.

References ecaldqm::kEcalRawData, ecaldqm::kSource, runOnRawData(), and runOnSource().

                                                                          {
     switch(_collection){
     case kSource:
       runOnSource(*static_cast<const FEDRawDataCollection*>(_p), _collection);
       break;
     case kEcalRawData:
       runOnRawData(*static_cast<const EcalRawDataCollection*>(_p), _collection);
       break;
     default:
       break;
     }
   }

void ecaldqm::RawDataTask::beginEvent	(	const edm::Event &	_evt,
		const edm::EventSetup &
	)

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 130 of file RawDataTask.cc.

References edm::EventBase::bunchCrossing(), bx_, edm::EventBase::experimentType(), feL1Offset_, edm::EventBase::isRealData(), l1A_, orbit_, edm::EventBase::orbitNumber(), edm::Event::run(), run_, and triggerType_.

   {
     run_ = _evt.run();
     orbit_ = _evt.orbitNumber() & 0xffffff;
     bx_ = _evt.bunchCrossing() & 0xfff;
     triggerType_ = _evt.experimentType() & 0xf;
     l1A_ = 0;
     feL1Offset_ = _evt.isRealData() ? 1 : 0;
   }

void ecaldqm::RawDataTask::beginLuminosityBlock	(	const edm::LuminosityBlock &	,
		const edm::EventSetup &
	)

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 123 of file RawDataTask.cc.

References kDesyncByLumi, kFEByLumi, and ecaldqm::DQWorker::MEs_.

   {
     if(MEs_[kDesyncByLumi]->isActive()) MEs_[kDesyncByLumi]->reset();
     if(MEs_[kFEByLumi]->isActive()) MEs_[kFEByLumi]->reset();
   }

void ecaldqm::RawDataTask::bookMEs ( )

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 52 of file RawDataTask.cc.

   {
     DQWorker::bookMEs();
 
     if(hltTaskMode_ != 1){
       std::string eventTypes[nEventTypes];
       eventTypes[0] = "UNKNOWN";
       // From DataFormats/EcalRawData/interface/EcalDCCHeaderBlock.h; should move to reflex
       eventTypes[EcalDCCHeaderBlock::COSMIC + 1] = "COSMIC";
       eventTypes[EcalDCCHeaderBlock::BEAMH4 + 1] = "BEAMH4";
       eventTypes[EcalDCCHeaderBlock::BEAMH2 + 1] = "BEAMH2";
       eventTypes[EcalDCCHeaderBlock::MTCC + 1] = "MTCC";
       eventTypes[EcalDCCHeaderBlock::LASER_STD + 1] = "LASER_STD";
       eventTypes[EcalDCCHeaderBlock::LASER_POWER_SCAN + 1] = "LASER_POWER_SCAN";
       eventTypes[EcalDCCHeaderBlock::LASER_DELAY_SCAN + 1] = "LASER_DELAY_SCAN";
       eventTypes[EcalDCCHeaderBlock::TESTPULSE_SCAN_MEM + 1] = "TESTPULSE_SCAN_MEM";
       eventTypes[EcalDCCHeaderBlock::TESTPULSE_MGPA + 1] = "TESTPULSE_MGPA";
       eventTypes[EcalDCCHeaderBlock::PEDESTAL_STD + 1] = "PEDESTAL_STD";
       eventTypes[EcalDCCHeaderBlock::PEDESTAL_OFFSET_SCAN + 1] = "PEDESTAL_OFFSET_SCAN";
       eventTypes[EcalDCCHeaderBlock::PEDESTAL_25NS_SCAN + 1] = "PEDESTAL_25NS_SCAN";
       eventTypes[EcalDCCHeaderBlock::LED_STD + 1] = "LED_STD";
       eventTypes[EcalDCCHeaderBlock::PHYSICS_GLOBAL + 1] = "PHYSICS_GLOBAL";
       eventTypes[EcalDCCHeaderBlock::COSMICS_GLOBAL + 1] = "COSMICS_GLOBAL";
       eventTypes[EcalDCCHeaderBlock::HALO_GLOBAL + 1] = "HALO_GLOBAL";
       eventTypes[EcalDCCHeaderBlock::LASER_GAP + 1] = "LASER_GAP";
       eventTypes[EcalDCCHeaderBlock::TESTPULSE_GAP + 1] = "TESTPULSE_GAP";
       eventTypes[EcalDCCHeaderBlock::PEDESTAL_GAP + 1] = "PEDESTAL_GAP";
       eventTypes[EcalDCCHeaderBlock::LED_GAP + 1] = "LED_GAP";
       eventTypes[EcalDCCHeaderBlock::PHYSICS_LOCAL + 1] = "PHYSICS_LOCAL";
       eventTypes[EcalDCCHeaderBlock::COSMICS_LOCAL + 1] = "COSMICS_LOCAL";
       eventTypes[EcalDCCHeaderBlock::HALO_LOCAL + 1] = "HALO_LOCAL";
       eventTypes[EcalDCCHeaderBlock::CALIB_LOCAL + 1] = "CALIB_LOCAL";
 
       std::string statuses[nFEFlags];
       statuses[Enabled] = "ENABLED";
       statuses[Disabled] = "DISABLED";
       statuses[Timeout] = "TIMEOUT";
       statuses[HeaderError] = "HEADERERROR";
       statuses[ChannelId] = "CHANNELID";
       statuses[LinkError] = "LINKERROR";
       statuses[BlockSize] = "BLOCKSIZE";
       statuses[Suppressed] = "SUPPRESSED";
       statuses[FIFOFull] = "FIFOFULL";
       statuses[L1ADesync] = "L1ADESYNC";
       statuses[BXDesync] = "BXDESYNC";
       statuses[L1ABXDesync] = "L1ABXDESYNC";
       statuses[FIFOFullL1ADesync] = "FIFOFULLL1ADESYNC";
       statuses[HParity] = "HPARITY";
       statuses[VParity] = "VPARITY";
       statuses[ForcedZS] = "FORCEDZS";
 
       for(unsigned iME(kEventTypePreCalib); iME < kFEByLumi; iME++)
     MEs_[iME]->book();
 
       for(int i(1); i <= nEventTypes; i++){
     MEs_[kEventTypePreCalib]->setBinLabel(0, i, eventTypes[i - 1], 1);
     MEs_[kEventTypeCalib]->setBinLabel(0, i, eventTypes[i - 1], 1);
     MEs_[kEventTypePostCalib]->setBinLabel(0, i, eventTypes[i - 1], 1);
       }
 
       for(int i(1); i <= nFEFlags; i++)
     MEs_[kFEStatus]->setBinLabel(-1, i, statuses[i - 1], 2);
     }
 
     if(hltTaskMode_ != 0){
       MEs_[kFEDEntries]->book();
       MEs_[kFEDFatal]->book();
     }
   }

void ecaldqm::RawDataTask::runOnRawData	(	const EcalRawDataCollection &	_dcchs,
		Collections
	)

Definition at line 166 of file RawDataTask.cc.

References asciidump::at, edm::SortedCollection< T, SORT >::begin(), ecaldqm::BlockSize, bx_, ecaldqm::BXDesync, ecaldqm::ccuExists(), ecaldqm::ChannelId, ecaldqm::dccId(), edm::SortedCollection< T, SORT >::end(), feL1Offset_, lumiContext::fill, ecaldqm::getElectronicsMap(), ecaldqm::HeaderError, hltTaskMode_, ecaldqm::HParity, kBXDCC, kBXFE, kBXSRP, kBXTCC, kDesyncByLumi, kDesyncTotal, ecaldqm::kEEpLow, kEventTypeCalib, kEventTypePostCalib, kEventTypePreCalib, kFEByLumi, kFEStatus, kL1ADCC, kL1AFE, kL1ASRP, kL1ATCC, kOrbit, kRunNumber, kTriggerType, l1A_, ecaldqm::L1ABXDesync, ecaldqm::L1ADesync, ecaldqm::LinkError, ecaldqm::DQWorker::MEs_, orbit_, run_, environment_file_cff::runType, ntuplemaker::status, ecaldqm::Timeout, triggerType_, and ecaldqm::VParity.

Referenced by analyze().

   {
     using namespace std;
 
     if(hltTaskMode_ == 1) return;
 
     if(!l1A_){
       // majority vote on L1A.. is there no better implementation?
       map<int, int> l1aCounts;
       for(EcalRawDataCollection::const_iterator dcchItr(_dcchs.begin()); dcchItr != _dcchs.end(); ++dcchItr){
     l1aCounts[dcchItr->getLV1()]++;
       }
       int maxVote(0);
       for(map<int, int>::iterator l1aItr(l1aCounts.begin()); l1aItr != l1aCounts.end(); ++l1aItr){
     if(l1aItr->second > maxVote){
       maxVote = l1aItr->second;
       l1A_ = l1aItr->first;
     }
       }
     }
 
     for(EcalRawDataCollection::const_iterator dcchItr(_dcchs.begin()); dcchItr != _dcchs.end(); ++dcchItr){
       unsigned dccId(dcchItr->id());
 
       int dccL1A(dcchItr->getLV1());
       short dccL1AShort(dccL1A & 0xfff);
       int dccBX(dcchItr->getBX());
 
       if(dcchItr->getRunNumber() != run_) MEs_[kRunNumber]->fill(dccId);
       if(dcchItr->getOrbit() != orbit_) MEs_[kOrbit]->fill(dccId);
       if(dcchItr->getBasicTriggerType() != triggerType_) MEs_[kTriggerType]->fill(dccId);
       if(dccL1A != l1A_) MEs_[kL1ADCC]->fill(dccId);
       if(dccBX != bx_) MEs_[kBXDCC]->fill(dccId);
 
       const vector<short> &feStatus(dcchItr->getFEStatus());
       const vector<short> &feBxs(dcchItr->getFEBxs());
       const vector<short> &feL1s(dcchItr->getFELv1());
 
       bool feDesync(false);
       bool statusError(false);
 
       for(unsigned iFE(0); iFE < feStatus.size(); iFE++){
     if(!ccuExists(dccId, iFE + 1)) continue;
 
     short status(feStatus[iFE]);
 
     if(status != BXDesync && status != L1ABXDesync){ // BX desync not detected in the DCC
       if(feBxs[iFE] != dccBX && feBxs[iFE] != -1 && dccBX != -1){
         MEs_[kBXFE]->fill(dccId);
         feDesync = true;
       }
     }
 
     if(status != L1ADesync && status != L1ABXDesync){
       if(feL1s[iFE] + feL1Offset_ != dccL1AShort && feL1s[iFE] != -1 && dccL1AShort != 0){
         MEs_[kL1AFE]->fill(dccId);
         feDesync = true;
       }
     }
 
     if(iFE >= 68) continue;
 
     DetId id(getElectronicsMap()->dccTowerConstituents(dccId, iFE + 1).at(0));
     MEs_[kFEStatus]->fill(id, status + 0.5);
 
     switch(status){
     case Timeout:
     case HeaderError:
     case ChannelId:
     case LinkError:
     case BlockSize:
     case L1ADesync:
     case BXDesync:
     case L1ABXDesync:
     case HParity:
     case VParity:
       statusError = true;
       break;
     default:
       continue;
     }
       }
 
       if(feDesync) MEs_[kDesyncByLumi]->fill(dccId);
       if(feDesync) MEs_[kDesyncTotal]->fill(dccId);
       if(statusError) MEs_[kFEByLumi]->fill(dccId);
 
       const vector<short> &tccBx(dcchItr->getTCCBx());
       const vector<short> &tccL1(dcchItr->getTCCLv1());
 
       if(tccBx.size() == 4){ // EB uses tccBx[0]; EE uses all
     if(dccId <= kEEmHigh + 1 || dccId >= kEEpLow + 1){
       for(int iTCC(0); iTCC < 4; iTCC++){
 
         if(tccBx[iTCC] != dccBX && tccBx[iTCC] != -1 && dccBX != -1)
           MEs_[kBXTCC]->fill(dccId);
 
         if(tccL1[iTCC] != dccL1AShort && tccL1[iTCC] != -1 && dccL1AShort != 0)
           MEs_[kL1ATCC]->fill(dccId);
 
       }
     }else{
 
       if(tccBx[0] != dccBX && tccBx[0] != -1 && dccBX != -1)
         MEs_[kBXTCC]->fill(dccId);
 
       if(tccL1[0] != dccL1AShort && tccL1[0] != -1 && dccL1AShort != 0)
         MEs_[kL1ATCC]->fill(dccId);
 
     }
       }
 
       short srpBx(dcchItr->getSRPBx());
       short srpL1(dcchItr->getSRPLv1());
 
       if(srpBx != dccBX && srpBx != -1 && dccBX != -1)
     MEs_[kBXSRP]->fill(dccId);
 
       if(srpL1 != dccL1AShort && srpL1 != -1 && dccL1AShort != 0)
     MEs_[kL1ASRP]->fill(dccId);
 
       const int calibBX(3490);
 
       short runType(dcchItr->getRunType() + 1);
       if(runType < 0 || runType > 22) runType = 0;
       if(dccBX < calibBX) MEs_[kEventTypePreCalib]->fill(dccId, runType + 0.5, 1. / 54.);
       else if(dccBX == calibBX) MEs_[kEventTypeCalib]->fill(dccId, runType + 0.5, 1. / 54.);
       else MEs_[kEventTypePostCalib]->fill(dccId, runType + 0.5, 1. / 54.);
 
     }
   }

void ecaldqm::RawDataTask::runOnSource	(	const FEDRawDataCollection &	_fedRaw,
		Collections
	)

Definition at line 141 of file RawDataTask.cc.

References FEDRawDataCollection::FEDData(), kCRC, kFEDEntries, kFEDFatal, l1A_, and ecaldqm::DQWorker::MEs_.

Referenced by analyze().

   {
     // Get GT L1 info
     const FEDRawData &gtFED(_fedRaw.FEDData(812));
     if(gtFED.size() > sizeof(uint64_t)){ // FED header is one 64 bit word
       uint32_t *halfHeader((uint32_t *)gtFED.data());
       l1A_ = *(halfHeader + 1) & 0xffffff;
     }
 
     for(unsigned iFED(601); iFED <= 654; iFED++){
       const FEDRawData& fedData(_fedRaw.FEDData(iFED));
       unsigned length(fedData.size() / sizeof(uint64_t));
       if(length > 1){ // FED header is one 64 bit word
     if(MEs_[kFEDEntries]->isActive()) MEs_[kFEDEntries]->fill(iFED - 600);
 
     const uint64_t* pData(reinterpret_cast<const uint64_t*>(fedData.data()));
     bool crcError((pData[length - 1] >> 2) & 0x1);
 
     if(crcError && MEs_[kFEDFatal]->isActive()) MEs_[kFEDFatal]->fill(iFED - 600);
     if(crcError && MEs_[kCRC]->isActive()) MEs_[kCRC]->fill(iFED - 600);
       }
     }
   }

void ecaldqm::RawDataTask::setMEData ( std::vector< MEData > & _data )

static

Definition at line 300 of file RawDataTask.cc.

   {
     BinService::AxisSpecs eventTypeAxis;
     eventTypeAxis.nbins = nEventTypes;
     eventTypeAxis.low = 0.;
     eventTypeAxis.high = nEventTypes;
 
     BinService::AxisSpecs feStatusAxis;
     feStatusAxis.nbins = nFEFlags;
     feStatusAxis.low = 0.;
     feStatusAxis.high = nFEFlags;
 
     _data[kEventTypePreCalib] = MEData("EventTypePreCalib", BinService::kEcal, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &eventTypeAxis);
     _data[kEventTypeCalib] = MEData("EventTypeCalib", BinService::kEcal, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &eventTypeAxis);
     _data[kEventTypePostCalib] = MEData("EventTypePostCalib", BinService::kEcal, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &eventTypeAxis);
     _data[kCRC] = MEData("CRC", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kRunNumber] = MEData("RunNumber", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kOrbit] = MEData("Orbit", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kTriggerType] = MEData("TriggerType", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kL1ADCC] = MEData("L1ADCC", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kL1AFE] = MEData("L1AFE", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kL1ATCC] = MEData("L1ATCC", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kL1ASRP] = MEData("L1ASRP", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kBXDCC] = MEData("BXDCC", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kBXFE] = MEData("BXFE", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kBXTCC] = MEData("BXTCC", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kBXSRP] = MEData("BXSRP", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kDesyncByLumi] = MEData("DesyncByLumi", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kDesyncTotal] = MEData("DesyncTotal", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kFEStatus] = MEData("FEStatus", BinService::kSM, BinService::kSuperCrystal, MonitorElement::DQM_KIND_TH2F, 0, &feStatusAxis);
     _data[kFEByLumi] = MEData("FEByLumi", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kFEDEntries] = MEData("FEDEntries", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
     _data[kFEDFatal] = MEData("FEDFatal", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TH1F);
   }