|
|
|
#include <RawDataTask.h>
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 Member Functions | |
| void | analyze (const void *, Collections) |
| void | beginEvent (const edm::Event &, const edm::EventSetup &) |
| void | beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) |
| void | bookMEs () |
| RawDataTask (const edm::ParameterSet &, const edm::ParameterSet &) | |
| void | runOnRawData (const EcalRawDataCollection &, Collections) |
| void | runOnSource (const FEDRawDataCollection &, Collections) |
| ~RawDataTask () | |
Static Public Member Functions | |
| 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_ |
Definition at line 11 of file RawDataTask.h.
Reimplemented from ecaldqm::DQWorker.
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
};
| data refman pasoursint CMSSW_6_1_2_SLHC2_patch1 src DQM EcalBarrelMonitorTasks src RawDataTask cc ecaldqm::RawDataTask::RawDataTask | ( | const edm::ParameterSet & | _params, |
| const edm::ParameterSet & | _paths | ||
| ) |
Definition at line 13 of file RawDataTask.cc.
References edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSet(), ecaldqm::kEcalRawData, ecaldqm::kLumiSection, ecaldqm::kSource, and AlCaHLTBitMon_QueryRunRegistry::string.
{
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 48 of file RawDataTask.cc.
{
}
| void ecaldqm::RawDataTask::analyze | ( | const void * | _p, |
| Collections | _collection | ||
| ) | [inline, virtual] |
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 & | |||
| ) | [virtual] |
Reimplemented from ecaldqm::DQWorkerTask.
Definition at line 131 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 & | |||
| ) | [virtual] |
Reimplemented from ecaldqm::DQWorker.
Definition at line 124 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 | ( | ) | [virtual] |
Reimplemented from ecaldqm::DQWorker.
Definition at line 53 of file RawDataTask.cc.
References EcalDCCHeaderBlock::BEAMH2, EcalDCCHeaderBlock::BEAMH4, ecaldqm::BlockSize, ecaldqm::BXDesync, EcalDCCHeaderBlock::CALIB_LOCAL, ecaldqm::ChannelId, EcalDCCHeaderBlock::COSMIC, EcalDCCHeaderBlock::COSMICS_GLOBAL, EcalDCCHeaderBlock::COSMICS_LOCAL, ecaldqm::Disabled, ecaldqm::Enabled, ecaldqm::FIFOFull, ecaldqm::FIFOFullL1ADesync, ecaldqm::ForcedZS, EcalDCCHeaderBlock::HALO_GLOBAL, EcalDCCHeaderBlock::HALO_LOCAL, ecaldqm::HeaderError, hltTaskMode_, ecaldqm::HParity, i, kEventTypeCalib, kEventTypePostCalib, kEventTypePreCalib, kFEByLumi, kFEDEntries, kFEDFatal, kFEStatus, ecaldqm::L1ABXDesync, ecaldqm::L1ADesync, EcalDCCHeaderBlock::LASER_DELAY_SCAN, EcalDCCHeaderBlock::LASER_GAP, EcalDCCHeaderBlock::LASER_POWER_SCAN, EcalDCCHeaderBlock::LASER_STD, EcalDCCHeaderBlock::LED_GAP, EcalDCCHeaderBlock::LED_STD, ecaldqm::LinkError, ecaldqm::DQWorker::MEs_, EcalDCCHeaderBlock::MTCC, nEventTypes, ecaldqm::nFEFlags, EcalDCCHeaderBlock::PEDESTAL_25NS_SCAN, EcalDCCHeaderBlock::PEDESTAL_GAP, EcalDCCHeaderBlock::PEDESTAL_OFFSET_SCAN, EcalDCCHeaderBlock::PEDESTAL_STD, EcalDCCHeaderBlock::PHYSICS_GLOBAL, EcalDCCHeaderBlock::PHYSICS_LOCAL, AlCaHLTBitMon_QueryRunRegistry::string, ecaldqm::Suppressed, EcalDCCHeaderBlock::TESTPULSE_GAP, EcalDCCHeaderBlock::TESTPULSE_MGPA, EcalDCCHeaderBlock::TESTPULSE_SCAN_MEM, ecaldqm::Timeout, and ecaldqm::VParity.
{
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 167 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 142 of file RawDataTask.cc.
References FEDRawDataCollection::FEDData(), kCRC, kFEDEntries, kFEDFatal, l1A_, and ecaldqm::DQWorker::MEs_.
Referenced by analyze().
{
// Get GT L1 info
const FEDRawData >FED(_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] |
Reimplemented from ecaldqm::DQWorker.
Definition at line 301 of file RawDataTask.cc.
References MonitorElement::DQM_KIND_TH1F, MonitorElement::DQM_KIND_TH2F, EcalDQMBinningService::AxisSpecs::high, kBXDCC, kBXFE, kBXSRP, kBXTCC, kCRC, EcalDQMBinningService::kDCC, kDesyncByLumi, kDesyncTotal, EcalDQMBinningService::kEcal, EcalDQMBinningService::kEcal2P, kEventTypeCalib, kEventTypePostCalib, kEventTypePreCalib, kFEByLumi, kFEDEntries, kFEDFatal, kFEStatus, kL1ADCC, kL1AFE, kL1ASRP, kL1ATCC, kOrbit, kRunNumber, EcalDQMBinningService::kSM, EcalDQMBinningService::kSuperCrystal, kTriggerType, EcalDQMBinningService::kUser, EcalDQMBinningService::AxisSpecs::low, EcalDQMBinningService::AxisSpecs::nbins, nEventTypes, and ecaldqm::nFEFlags.
{
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);
}
int ecaldqm::RawDataTask::bx_ [private] |
Definition at line 64 of file RawDataTask.h.
Referenced by beginEvent(), and runOnRawData().
int ecaldqm::RawDataTask::feL1Offset_ [private] |
Definition at line 66 of file RawDataTask.h.
Referenced by beginEvent(), and runOnRawData().
std::string ecaldqm::RawDataTask::hltTaskFolder_ [private] |
Definition at line 60 of file RawDataTask.h.
int ecaldqm::RawDataTask::hltTaskMode_ [private] |
Definition at line 59 of file RawDataTask.h.
Referenced by bookMEs(), and runOnRawData().
int ecaldqm::RawDataTask::l1A_ [private] |
Definition at line 62 of file RawDataTask.h.
Referenced by beginEvent(), runOnRawData(), and runOnSource().
int ecaldqm::RawDataTask::orbit_ [private] |
Definition at line 63 of file RawDataTask.h.
Referenced by beginEvent(), and runOnRawData().
int ecaldqm::RawDataTask::run_ [private] |
Definition at line 61 of file RawDataTask.h.
Referenced by beginEvent(), and runOnRawData().
short ecaldqm::RawDataTask::triggerType_ [private] |
Definition at line 65 of file RawDataTask.h.
Referenced by beginEvent(), and runOnRawData().
1.7.3