Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-09-07 04:36:01 

0001 #include "DQM/EcalMonitorTasks/interface/RawDataTask.h"
0002 
0003 #include "FWCore/Framework/interface/Event.h"
0004 #include "FWCore/Framework/interface/Run.h"
0005 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0006 
0007 #include "DQM/EcalCommon/interface/EcalDQMCommonUtils.h"
0008 #include "DQM/EcalCommon/interface/FEFlags.h"
0009 
0010 #include "DataFormats/EcalDetId/interface/EcalElectronicsId.h"
0011 #include "DataFormats/Luminosity/interface/LumiConstants.h"
0012 
0013 namespace ecaldqm {
0014 
0015   RawDataTask::RawDataTask()
0016       : DQWorkerTask(), runNumber_(0), l1A_(0), orbit_(0), bx_(0), triggerType_(0), feL1Offset_(0) {}
0017 
0018   void RawDataTask::addDependencies(DependencySet& _dependencies) {
0019     _dependencies.push_back(Dependency(kEcalRawData, kSource));
0020   }
0021 
0022   void RawDataTask::beginRun(edm::Run const& _run, edm::EventSetup const&) { runNumber_ = _run.run(); }
0023 
0024   void RawDataTask::beginEvent(edm::Event const& _evt, edm::EventSetup const&, bool const& ByLumiResetSwitch, bool&) {
0025     orbit_ = _evt.orbitNumber() & 0xffffffff;
0026 
0027     bx_ = _evt.bunchCrossing() & 0xfff;
0028     // There's no agreement in CMS on how to label the last/first BX
0029     // TCDS calls it always 3564, but some subsystems call it 0.
0030     // From testing: bx_ is labeled 0, dccBX and FEBxs[iFE] labeled 3564
0031     // Setting bx_ to 0 to match the other two
0032     if (bx_ == LumiConstants::numBX)  // 3564
0033       bx_ = 0;
0034 
0035     triggerType_ = _evt.experimentType() & 0xf;
0036     l1A_ = 0;
0037     feL1Offset_ = _evt.isRealData() ? 1 : 0;
0038     if (ByLumiResetSwitch) {
0039       MEs_.at("DesyncByLumi").reset(GetElectronicsMap());
0040       MEs_.at("FEByLumi").reset(GetElectronicsMap());
0041       MEs_.at("FEStatusErrMapByLumi").reset(GetElectronicsMap());
0042     }
0043   }
0044 
0045   void RawDataTask::runOnSource(FEDRawDataCollection const& _fedRaw) {
0046     MESet& meCRC(MEs_.at("CRC"));
0047 
0048     // Get GT L1 info
0049     const FEDRawData& gtFED(_fedRaw.FEDData(812));
0050     if (gtFED.size() > sizeof(uint64_t)) {  // FED header is one 64 bit word
0051       const uint32_t* halfHeader = reinterpret_cast<const uint32_t*>(gtFED.data());
0052       l1A_ = *(halfHeader + 1) & 0xffffff;
0053     }
0054 
0055     for (int iFED(601); iFED <= 654; iFED++) {
0056       const FEDRawData& fedData(_fedRaw.FEDData(iFED));
0057       unsigned length(fedData.size() / sizeof(uint64_t));
0058       if (length > 1) {  // FED header is one 64 bit word
0059         const uint64_t* pData(reinterpret_cast<uint64_t const*>(fedData.data()));
0060         if ((pData[length - 1] & 0x4) != 0)
0061           meCRC.fill(getEcalDQMSetupObjects(), iFED - 600);
0062       }
0063     }
0064   }
0065 
0066   void RawDataTask::runOnRawData(EcalRawDataCollection const& _dcchs) {
0067     using namespace std;
0068 
0069     MESet& meRunNumber(MEs_.at("RunNumber"));
0070     MESet& meOrbit(MEs_.at("Orbit"));
0071     MESet& meOrbitDiff(MEs_.at("OrbitDiff"));
0072     MESet& meTriggerType(MEs_.at("TriggerType"));
0073     MESet& meL1ADCC(MEs_.at("L1ADCC"));
0074     MESet& meBXDCC(MEs_.at("BXDCC"));
0075     MESet& meBXDCCDiff(MEs_.at("BXDCCDiff"));
0076     MESet& meBXFE(MEs_.at("BXFE"));
0077     MESet& meBXFEDiff(MEs_.at("BXFEDiff"));
0078     MESet& meBXFEInvalid(MEs_.at("BXFEInvalid"));
0079     MESet& meL1AFE(MEs_.at("L1AFE"));
0080     MESet& meFEStatus(MEs_.at("FEStatus"));
0081     MESet& meFEStatusErrMapByLumi(MEs_.at("FEStatusErrMapByLumi"));
0082     MESet& meFEStatusMEM(MEs_.at("FEStatusMEM"));
0083     MESet& meDesyncByLumi(MEs_.at("DesyncByLumi"));
0084     MESet& meDesyncTotal(MEs_.at("DesyncTotal"));
0085     MESet& meFEByLumi(MEs_.at("FEByLumi"));
0086     MESet& meBXTCC(MEs_.at("BXTCC"));
0087     MESet& meL1ATCC(MEs_.at("L1ATCC"));
0088     MESet& meBXSRP(MEs_.at("BXSRP"));
0089     MESet& meL1ASRP(MEs_.at("L1ASRP"));
0090     MESet& meTrendNSyncErrors(MEs_.at("L1ATCC"));
0091     MESet& meTrendBXTCC(MEs_.at("TrendBXTCC"));
0092     MESet& meTrendL1ATCC(MEs_.at("TrendL1ATCC"));
0093     MESet& meTrendBXSRP(MEs_.at("TrendBXSRP"));
0094     MESet& meTrendL1ASRP(MEs_.at("TrendL1ASRP"));
0095     MESet& meEventTypePreCalib(MEs_.at("EventTypePreCalib"));
0096     MESet& meEventTypeCalib(MEs_.at("EventTypeCalib"));
0097     MESet& meEventTypePostCalib(MEs_.at("EventTypePostCalib"));
0098 
0099     if (!l1A_) {
0100       // majority vote on L1A.. is there no better implementation?
0101       map<int, int> l1aCounts;
0102       for (EcalRawDataCollection::const_iterator dcchItr(_dcchs.begin()); dcchItr != _dcchs.end(); ++dcchItr) {
0103         l1aCounts[dcchItr->getLV1()]++;
0104       }
0105       int maxVote(0);
0106       for (map<int, int>::iterator l1aItr(l1aCounts.begin()); l1aItr != l1aCounts.end(); ++l1aItr) {
0107         if (l1aItr->second > maxVote) {
0108           maxVote = l1aItr->second;
0109           l1A_ = l1aItr->first;
0110         }
0111       }
0112     }
0113 
0114     for (EcalRawDataCollection::const_iterator dcchItr(_dcchs.begin()); dcchItr != _dcchs.end(); ++dcchItr) {
0115       int dccId(dcchItr->id());
0116 
0117       int dccL1A(dcchItr->getLV1());
0118       short dccL1AShort(dccL1A & 0xfff);
0119       int dccBX(dcchItr->getBX());
0120 
0121       meOrbitDiff.fill(getEcalDQMSetupObjects(), dccId, dcchItr->getOrbit() - orbit_);
0122       meBXDCCDiff.fill(getEcalDQMSetupObjects(), dccId, dccBX - bx_);
0123       if (dccBX == -1)
0124         meBXFEInvalid.fill(getEcalDQMSetupObjects(), dccId, 68.5);
0125 
0126       if (dcchItr->getRunNumber() != int(runNumber_))
0127         meRunNumber.fill(getEcalDQMSetupObjects(), dccId);
0128       if (dcchItr->getOrbit() != orbit_)
0129         meOrbit.fill(getEcalDQMSetupObjects(), dccId);
0130       if (dcchItr->getBasicTriggerType() != triggerType_)
0131         meTriggerType.fill(getEcalDQMSetupObjects(), dccId);
0132       if (dccL1A != l1A_)
0133         meL1ADCC.fill(getEcalDQMSetupObjects(), dccId);
0134       if (dccBX != bx_)
0135         meBXDCC.fill(getEcalDQMSetupObjects(), dccId);
0136 
0137       const vector<short>& feStatus(dcchItr->getFEStatus());
0138       const vector<short>& feBxs(dcchItr->getFEBxs());
0139       const vector<short>& feL1s(dcchItr->getFELv1());
0140 
0141       double feDesync(0.);
0142       double statusError(0.);
0143 
0144       for (unsigned iFE(0); iFE < feStatus.size(); iFE++) {
0145         if (!ccuExists(dccId, iFE + 1))
0146           continue;
0147 
0148         short status(feStatus[iFE]);
0149 
0150         if (feBxs[iFE] != -1 && dccBX != -1) {
0151           meBXFEDiff.fill(getEcalDQMSetupObjects(), dccId, feBxs[iFE] - dccBX);
0152         }
0153         if (feBxs[iFE] == -1)
0154           meBXFEInvalid.fill(getEcalDQMSetupObjects(), dccId, iFE + 0.5);
0155 
0156         if (status != BXDesync && status != L1ABXDesync) {  // BX desync not detected in the DCC
0157           if (feBxs[iFE] != dccBX && feBxs[iFE] != -1 && dccBX != -1) {
0158             meBXFE.fill(getEcalDQMSetupObjects(), dccId, iFE + 0.5);
0159             feDesync += 1.;
0160           }
0161         }
0162 
0163         if (status != L1ADesync && status != L1ABXDesync) {
0164           if (feL1s[iFE] + feL1Offset_ != dccL1AShort && feL1s[iFE] != -1 && dccL1AShort != 0) {
0165             meL1AFE.fill(getEcalDQMSetupObjects(), dccId, iFE + 0.5);
0166             feDesync += 1.;
0167           }
0168         }
0169 
0170         if (iFE >= 68) {
0171           // FE Status for MEM boxes (towerIds 69 and 70)
0172           // Plot contains two bins per dccId. Integer number
0173           // bins correspond to towerId 69 and half integer
0174           // number bins correspond to towerId 70.
0175           if (iFE + 1 == 69)
0176             meFEStatusMEM.fill(getEcalDQMSetupObjects(), dccId + 0.0, status);
0177           else if (iFE + 1 == 70)
0178             meFEStatusMEM.fill(getEcalDQMSetupObjects(), dccId + 0.5, status);
0179           continue;
0180         }
0181 
0182         DetId id(GetElectronicsMap()->dccTowerConstituents(dccId, iFE + 1).at(0));
0183         meFEStatus.fill(getEcalDQMSetupObjects(), id, status);
0184         // Fill FE Status Error Map with error states only
0185         if (status != Enabled && status != Suppressed && status != ForcedFullSupp && status != FIFOFull &&
0186             status != ForcedZS)
0187           meFEStatusErrMapByLumi.fill(getEcalDQMSetupObjects(), id, status);
0188 
0189         switch (status) {
0190           case Timeout:
0191           case HeaderError:
0192           case ChannelId:
0193           case LinkError:
0194           case BlockSize:
0195           case L1ADesync:
0196           case BXDesync:
0197           case L1ABXDesync:
0198           case HParity:
0199           case VParity:
0200             statusError += 1.;
0201             break;
0202           default:
0203             continue;
0204         }
0205       }
0206 
0207       if (feDesync > 0.) {
0208         meDesyncByLumi.fill(getEcalDQMSetupObjects(), dccId, feDesync);
0209         meDesyncTotal.fill(getEcalDQMSetupObjects(), dccId, feDesync);
0210         meTrendNSyncErrors.fill(getEcalDQMSetupObjects(), double(timestamp_.iLumi), feDesync);
0211       }
0212       if (statusError > 0.)
0213         meFEByLumi.fill(getEcalDQMSetupObjects(), dccId, statusError);
0214 
0215       const vector<short>& tccBx(dcchItr->getTCCBx());
0216       const vector<short>& tccL1(dcchItr->getTCCLv1());
0217 
0218       if (tccBx.size() == 4) {  // EB uses tccBx[0]; EE uses all
0219         if (dccId <= kEEmHigh + 1 || dccId >= kEEpLow + 1) {
0220           for (int iTCC(0); iTCC < 4; iTCC++) {
0221             if (tccBx[iTCC] != dccBX && tccBx[iTCC] != -1 && dccBX != -1) {
0222               meBXTCC.fill(getEcalDQMSetupObjects(), dccId);
0223               meTrendBXTCC.fill(getEcalDQMSetupObjects(), EcalEndcap, double(timestamp_.iLumi), 1);
0224             }
0225 
0226             if (tccL1[iTCC] != dccL1AShort && tccL1[iTCC] != -1 && dccL1AShort != 0) {
0227               meL1ATCC.fill(getEcalDQMSetupObjects(), dccId);
0228               meTrendL1ATCC.fill(getEcalDQMSetupObjects(), EcalEndcap, double(timestamp_.iLumi), 1);
0229             }
0230           }
0231         } else {
0232           if (tccBx[0] != dccBX && tccBx[0] != -1 && dccBX != -1) {
0233             meBXTCC.fill(getEcalDQMSetupObjects(), dccId);
0234             meTrendBXTCC.fill(getEcalDQMSetupObjects(), EcalBarrel, double(timestamp_.iLumi), 1);
0235           }
0236 
0237           if (tccL1[0] != dccL1AShort && tccL1[0] != -1 && dccL1AShort != 0) {
0238             meL1ATCC.fill(getEcalDQMSetupObjects(), dccId);
0239             meTrendL1ATCC.fill(getEcalDQMSetupObjects(), EcalBarrel, double(timestamp_.iLumi), 1);
0240           }
0241         }
0242       }
0243 
0244       short srpBx(dcchItr->getSRPBx());
0245       short srpL1(dcchItr->getSRPLv1());
0246 
0247       if (srpBx != dccBX && srpBx != -1 && dccBX != -1) {
0248         meBXSRP.fill(getEcalDQMSetupObjects(), dccId);
0249 
0250         if (dccId <= kEEmHigh + 1 || dccId >= kEEpLow + 1) {  // EE
0251           meTrendBXSRP.fill(getEcalDQMSetupObjects(), EcalEndcap, double(timestamp_.iLumi), 1);
0252         } else {  // EB
0253           meTrendBXSRP.fill(getEcalDQMSetupObjects(), EcalBarrel, double(timestamp_.iLumi), 1);
0254         }
0255       }
0256 
0257       if (srpL1 != dccL1AShort && srpL1 != -1 && dccL1AShort != 0) {
0258         meL1ASRP.fill(getEcalDQMSetupObjects(), dccId);
0259 
0260         if (dccId <= kEEmHigh + 1 || dccId >= kEEpLow + 1) {  // EE
0261           meTrendL1ASRP.fill(getEcalDQMSetupObjects(), EcalEndcap, double(timestamp_.iLumi), 1);
0262         } else {  // EB
0263           meTrendL1ASRP.fill(getEcalDQMSetupObjects(), EcalBarrel, double(timestamp_.iLumi), 1);
0264         }
0265       }
0266 
0267       const int calibBX(3490);
0268 
0269       short runType(dcchItr->getRunType() + 1);
0270       if (runType < 0 || runType > 22)
0271         runType = 0;
0272       if (dccBX < calibBX)
0273         meEventTypePreCalib.fill(getEcalDQMSetupObjects(), dccId, runType, 1. / 54.);
0274       else if (dccBX == calibBX)
0275         meEventTypeCalib.fill(getEcalDQMSetupObjects(), dccId, runType, 1. / 54.);
0276       else
0277         meEventTypePostCalib.fill(getEcalDQMSetupObjects(), dccId, runType, 1. / 54.);
0278     }
0279   }
0280 
0281   DEFINE_ECALDQM_WORKER(RawDataTask);
0282 }  // namespace ecaldqm
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!