Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:07:35 

0001 #include "DQM/HcalTasks/interface/RawTask.h"
0002 
0003 using namespace hcaldqm;
0004 using namespace hcaldqm::constants;
0005 
0006 RawTask::RawTask(edm::ParameterSet const& ps)
0007     : DQTask(ps), hcalDbServiceToken_(esConsumes<HcalDbService, HcalDbRecord, edm::Transition::BeginRun>()) {
0008   _tagFEDs = ps.getUntrackedParameter<edm::InputTag>("tagFEDs", edm::InputTag("rawDataCollector"));
0009   _tagReport = ps.getUntrackedParameter<edm::InputTag>("tagReport", edm::InputTag("hcalDigis"));
0010   _calibProcessing = ps.getUntrackedParameter<bool>("calibProcessing", false);
0011   _thresh_calib_nbadq = ps.getUntrackedParameter<int>("thresh_calib_nbadq", 5000);
0012 
0013   _tokFEDs = consumes<FEDRawDataCollection>(_tagFEDs);
0014   _tokReport = consumes<HcalUnpackerReport>(_tagReport);
0015 
0016   _vflags.resize(nRawFlag);
0017   _vflags[fEvnMsm] = flag::Flag("EvnMsm");
0018   _vflags[fBcnMsm] = flag::Flag("BcnMsm");
0019   _vflags[fBadQ] = flag::Flag("BadQ");
0020   _vflags[fOrnMsm] = flag::Flag("OrnMsm");
0021 }
0022 
0023 /* virtual */ void RawTask::bookHistograms(DQMStore::IBooker& ib, edm::Run const& r, edm::EventSetup const& es) {
0024   DQTask::bookHistograms(ib, r, es);
0025 
0026   //    GET WHAT YOU NEED
0027   edm::ESHandle<HcalDbService> dbs = es.getHandle(hcalDbServiceToken_);
0028   _emap = dbs->getHcalMapping();
0029   std::vector<uint32_t> vVME;
0030   std::vector<uint32_t> vuTCA;
0031   vVME.push_back(
0032       HcalElectronicsId(constants::FIBERCH_MIN, constants::FIBER_VME_MIN, SPIGOT_MIN, CRATE_VME_MIN).rawId());
0033   vuTCA.push_back(HcalElectronicsId(CRATE_uTCA_MIN, SLOT_uTCA_MIN, FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
0034   _filter_VME.initialize(filter::fFilter, hcaldqm::hashfunctions::fElectronics, vVME);
0035   _filter_uTCA.initialize(filter::fFilter, hcaldqm::hashfunctions::fElectronics, vuTCA);
0036 
0037   _cBadQualityvsLS.initialize(_name,
0038                               "BadQualityvsLS",
0039                               new hcaldqm::quantity::LumiSection(_maxLS),
0040                               new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fN_m0to10000),
0041                               0);
0042   _cBadQualityvsBX.initialize(_name,
0043                               "BadQualityvsBX",
0044                               new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fBX),
0045                               new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fN_m0to10000),
0046                               0);
0047   _cBadQuality_depth.initialize(_name,
0048                                 "BadQuality",
0049                                 hcaldqm::hashfunctions::fdepth,
0050                                 new hcaldqm::quantity::DetectorQuantity(hcaldqm::quantity::fieta),
0051                                 new hcaldqm::quantity::DetectorQuantity(hcaldqm::quantity::fiphi),
0052                                 new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fN),
0053                                 0);
0054 
0055   // FED-based plots
0056   if (_ptype != fOffline) {  // hidefed2crate
0057     std::vector<int> vFEDs = hcaldqm::utilities::getFEDList(_emap);
0058     std::vector<int> vFEDsVME = hcaldqm::utilities::getFEDVMEList(_emap);
0059     std::vector<int> vFEDsuTCA = hcaldqm::utilities::getFEDuTCAList(_emap);
0060 
0061     std::vector<uint32_t> vhashFEDsVME;
0062     std::vector<uint32_t> vhashFEDsuTCA;
0063 
0064     for (std::vector<int>::const_iterator it = vFEDsVME.begin(); it != vFEDsVME.end(); ++it) {
0065       vhashFEDsVME.push_back(
0066           HcalElectronicsId(
0067               constants::FIBERCH_MIN, constants::FIBER_VME_MIN, SPIGOT_MIN, (*it) - constants::FED_VME_MIN)
0068               .rawId());
0069       _vhashFEDs.push_back(
0070           HcalElectronicsId(
0071               constants::FIBERCH_MIN, constants::FIBER_VME_MIN, SPIGOT_MIN, (*it) - constants::FED_VME_MIN)
0072               .rawId());
0073     }
0074     for (std::vector<int>::const_iterator it = vFEDsuTCA.begin(); it != vFEDsuTCA.end(); ++it) {
0075       std::pair<uint16_t, uint16_t> cspair = utilities::fed2crate(*it);
0076       vhashFEDsuTCA.push_back(
0077           HcalElectronicsId(cspair.first, cspair.second, FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
0078       _vhashFEDs.push_back(HcalElectronicsId(cspair.first, cspair.second, FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
0079     }
0080     _filter_FEDsVME.initialize(filter::fPreserver, hcaldqm::hashfunctions::fFED, vhashFEDsVME);
0081     _filter_FEDsuTCA.initialize(filter::fPreserver, hcaldqm::hashfunctions::fFED, vhashFEDsuTCA);
0082 
0083     //  INITIALIZE FIRST
0084     _cEvnMsm_ElectronicsuTCA.initialize(_name,
0085                                         "EvnMsm",
0086                                         hcaldqm::hashfunctions::fElectronics,
0087                                         new hcaldqm::quantity::FEDQuantity(vFEDsuTCA),
0088                                         new hcaldqm::quantity::ElectronicsQuantity(hcaldqm::quantity::fSlotuTCA),
0089                                         new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fN),
0090                                         0);
0091     _cBcnMsm_ElectronicsuTCA.initialize(_name,
0092                                         "BcnMsm",
0093                                         hcaldqm::hashfunctions::fElectronics,
0094                                         new hcaldqm::quantity::FEDQuantity(vFEDsuTCA),
0095                                         new hcaldqm::quantity::ElectronicsQuantity(hcaldqm::quantity::fSlotuTCA),
0096                                         new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fN),
0097                                         0);
0098     _cOrnMsm_ElectronicsuTCA.initialize(_name,
0099                                         "OrnMsm",
0100                                         hcaldqm::hashfunctions::fElectronics,
0101                                         new hcaldqm::quantity::FEDQuantity(vFEDsuTCA),
0102                                         new hcaldqm::quantity::ElectronicsQuantity(hcaldqm::quantity::fSlotuTCA),
0103                                         new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fN),
0104                                         0);
0105 
0106     //  Bad Quality
0107     _cBadQuality_FEDuTCA.initialize(_name,
0108                                     "BadQuality",
0109                                     hcaldqm::hashfunctions::fCrate,
0110                                     new hcaldqm::quantity::ElectronicsQuantity(hcaldqm::quantity::fSlotuTCA),
0111                                     new hcaldqm::quantity::ElectronicsQuantity(hcaldqm::quantity::fFiberuTCA),
0112                                     new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fN),
0113                                     0);
0114 
0115     //  Online only
0116     if (_ptype == fOnline) {
0117       _xEvnMsmLS.initialize(hcaldqm::hashfunctions::fFED);
0118       _xBcnMsmLS.initialize(hcaldqm::hashfunctions::fFED);
0119       _xOrnMsmLS.initialize(hcaldqm::hashfunctions::fFED);
0120       _xBadQLS.initialize(hcaldqm::hashfunctions::fFED);
0121       _cSummaryvsLS_FED.initialize(_name,
0122                                    "SummaryvsLS",
0123                                    hcaldqm::hashfunctions::fFED,
0124                                    new hcaldqm::quantity::LumiSection(_maxLS),
0125                                    new hcaldqm::quantity::FlagQuantity(_vflags),
0126                                    new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fState),
0127                                    0);
0128       _cSummaryvsLS.initialize(_name,
0129                                "SummaryvsLS",
0130                                new hcaldqm::quantity::LumiSection(_maxLS),
0131                                new hcaldqm::quantity::FEDQuantity(vFEDs),
0132                                new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fState),
0133                                0);
0134       //    FED Size vs LS
0135       _cDataSizevsLS_FED.initialize(_name,
0136                                     "DataSizevsLS",
0137                                     hcaldqm::hashfunctions::fFED,
0138                                     new hcaldqm::quantity::LumiSection(_maxLS),
0139                                     new hcaldqm::quantity::ValueQuantity(hcaldqm::quantity::fDataSize),
0140                                     0);
0141     }
0142   }
0143 
0144   //    BOOK HISTOGRAMS
0145   if (_ptype != fOffline) {
0146     _cEvnMsm_ElectronicsuTCA.book(ib, _emap, _filter_VME, _subsystem);
0147     _cBcnMsm_ElectronicsuTCA.book(ib, _emap, _filter_VME, _subsystem);
0148     _cOrnMsm_ElectronicsuTCA.book(ib, _emap, _filter_VME, _subsystem);
0149 
0150     _cBadQuality_FEDuTCA.book(ib, _emap, _filter_VME, _subsystem);
0151   }
0152   if (_ptype == fOffline) {
0153     auto scope = DQMStore::IBooker::UseLumiScope(ib);
0154     _cBadQuality_depth.book(ib, _emap, _subsystem);
0155   } else {
0156     _cBadQuality_depth.book(ib, _emap, _subsystem);
0157   }
0158   _cBadQualityvsLS.book(ib, _subsystem);
0159   _cBadQualityvsBX.book(ib, _subsystem);
0160 
0161   // BOOK HISTOGRAMS to be used in ONLINE ONLY!
0162   if (_ptype == fOnline) {
0163     _xEvnMsmLS.book(_emap);
0164     _xBcnMsmLS.book(_emap);
0165     _xOrnMsmLS.book(_emap);
0166     _xBadQLS.book(_emap);
0167     _cSummaryvsLS_FED.book(ib, _emap, _subsystem);
0168     _cSummaryvsLS.book(ib, _subsystem);
0169     _cDataSizevsLS_FED.book(ib, _emap, _subsystem);
0170   }
0171 
0172   //    FOR OFFLINE PROCESSING MARK THESE HISTOGRAMS AS LUMI BASED
0173   //if (_ptype == fOffline) {
0174   //if (_ptype != fOffline) {  // hidefed2crate
0175   // Note that this is deliberately contradictory for the fed2crate fix, so it can be reversed if fed2crate is ever fixed properly,
0176   // TODO: set LUMI scope while booking.
0177   // _cEvnMsm_ElectronicsVME.setLumiFlag();
0178   // _cBcnMsm_ElectronicsVME.setLumiFlag();
0179   // _cEvnMsm_ElectronicsuTCA.setLumiFlag();
0180   // _cBcnMsm_ElectronicsuTCA.setLumiFlag();
0181   //}
0182   //}
0183 
0184   //    initialize hash map
0185   _ehashmap.initialize(_emap, hcaldqm::electronicsmap::fD2EHashMap);
0186 }
0187 
0188 /* virtual */ void RawTask::_resetMonitors(hcaldqm::UpdateFreq uf) {
0189   //    base reset
0190   DQTask::_resetMonitors(uf);
0191 }
0192 
0193 /* virtual */ void RawTask::_process(edm::Event const& e, edm::EventSetup const&) {
0194   edm::Handle<FEDRawDataCollection> craw;
0195   edm::Handle<HcalUnpackerReport> creport;
0196   if (!e.getByToken(_tokFEDs, craw))
0197     _logger.dqmthrow("Collection FEDRawDataCollection isn't available" + _tagFEDs.label() + " " + _tagFEDs.instance());
0198   if (!e.getByToken(_tokReport, creport))
0199     _logger.dqmthrow("Collection HcalUnpackerReport isn't available" + _tagReport.label() + " " +
0200                      _tagReport.instance());
0201 
0202   //    extract some info
0203   int bx = e.bunchCrossing();
0204 
0205   auto lumiCache = luminosityBlockCache(e.getLuminosityBlock().index());
0206   _currentLS = lumiCache->currentLS;
0207   _xQuality.reset();
0208   _xQuality = lumiCache->xQuality;
0209 
0210   /*
0211      *  For Calibration/Abort Gap Processing
0212      *  check if the #channels taht are bad from the unpacker 
0213      *  is > 5000. If it is skip...
0214      */
0215   if (_calibProcessing) {
0216     int nbadq = creport->badQualityDigis();
0217     if (nbadq >= _thresh_calib_nbadq)
0218       return;
0219   }
0220 
0221   int nn = 0;
0222   //    loop thru and fill the detIds with bad quality
0223   //    NOTE: Calibration Channels are skipped!
0224   //    TODO: Include for Online Calibration Channels marked as bad
0225   //    a comment below is left on purpose!
0226   //_cBadQualityvsBX.fill(bx, creport->badQualityDigis());
0227   for (std::vector<DetId>::const_iterator it = creport->bad_quality_begin(); it != creport->bad_quality_end(); ++it) {
0228     //  skip non HCAL det ids
0229     if (!HcalGenericDetId(*it).isHcalDetId())
0230       continue;
0231 
0232     //  skip those that are of bad quality from conditions
0233     //  Masked or Dead
0234     if (_xQuality.exists(HcalDetId(*it))) {
0235       HcalChannelStatus cs(it->rawId(), _xQuality.get(HcalDetId(*it)));
0236       if (cs.isBitSet(HcalChannelStatus::HcalCellMask) || cs.isBitSet(HcalChannelStatus::HcalCellDead))
0237         continue;
0238     }
0239 
0240     nn++;
0241     HcalElectronicsId eid = HcalElectronicsId(_ehashmap.lookup(*it));
0242     _cBadQuality_depth.fill(HcalDetId(*it));
0243     //  ONLINE ONLY!
0244     if (_ptype == fOnline)
0245       _xBadQLS.get(eid)++;
0246     if (_ptype != fOffline) {  // hidefed2crate
0247       if (!eid.isVMEid()) {
0248         if (_filter_FEDsuTCA.filter(eid))
0249           continue;
0250         _cBadQuality_FEDuTCA.fill(eid);
0251       }
0252     }
0253   }
0254   _cBadQualityvsLS.fill(_currentLS, nn);
0255   _cBadQualityvsBX.fill(bx, nn);
0256 
0257   if (_ptype != fOffline) {  // hidefed2crate
0258     for (int fed = FEDNumbering::MINHCALFEDID; fed <= FEDNumbering::MAXHCALuTCAFEDID; fed++) {
0259       //    skip nonHCAL FEDs
0260       if ((fed > FEDNumbering::MAXHCALFEDID && fed < FEDNumbering::MINHCALuTCAFEDID) ||
0261           fed > FEDNumbering::MAXHCALuTCAFEDID)
0262         continue;
0263       FEDRawData const& raw = craw->FEDData(fed);
0264       if (raw.size() < constants::RAW_EMPTY)
0265         continue;
0266 
0267       if (fed <= FEDNumbering::MAXHCALFEDID)  // VME
0268       {
0269         HcalDCCHeader const* hdcc = (HcalDCCHeader const*)(raw.data());
0270         if (!hdcc)
0271           continue;
0272 
0273         uint32_t bcn = hdcc->getBunchId();
0274         uint32_t orn = hdcc->getOrbitNumber() & 0x1F;  // LS 5 bits only
0275         uint32_t evn = hdcc->getDCCEventNumber();
0276         int dccId = hdcc->getSourceId() - constants::FED_VME_MIN;
0277 
0278         /* online only */
0279         if (_ptype == fOnline) {
0280           HcalElectronicsId eid =
0281               HcalElectronicsId(constants::FIBERCH_MIN, constants::FIBER_VME_MIN, constants::SPIGOT_MIN, dccId);
0282           if (_filter_FEDsVME.filter(eid))
0283             continue;
0284           _cDataSizevsLS_FED.fill(eid, _currentLS, double(raw.size()) / 1024.);
0285         }
0286 
0287         //  iterate over spigots
0288         HcalHTRData htr;
0289         for (int is = 0; is < HcalDCCHeader::SPIGOT_COUNT; is++) {
0290           int r = hdcc->getSpigotData(is, htr, raw.size());
0291           if (r != 0 || !htr.check())
0292             continue;
0293           HcalElectronicsId eid = HcalElectronicsId(constants::FIBERCH_MIN, constants::FIBER_VME_MIN, is, dccId);
0294           if (_filter_FEDsVME.filter(eid))
0295             continue;
0296 
0297           uint32_t htr_evn = htr.getL1ANumber();
0298           uint32_t htr_orn = htr.getOrbitNumber();
0299           uint32_t htr_bcn = htr.getBunchNumber();
0300           bool qevn = (htr_evn != evn);
0301           bool qbcn = (htr_bcn != bcn);
0302           bool qorn = (htr_orn != orn);
0303           if (qevn) {
0304             if (_ptype == fOnline && is <= constants::SPIGOT_MAX)
0305               _xEvnMsmLS.get(eid)++;
0306           }
0307           if (qorn) {
0308             if (_ptype == fOnline && is <= constants::SPIGOT_MAX)
0309               _xOrnMsmLS.get(eid)++;
0310           }
0311           if (qbcn) {
0312             if (_ptype == fOnline && is <= constants::SPIGOT_MAX)
0313               _xBcnMsmLS.get(eid)++;
0314           }
0315         }
0316       } else  // uTCA
0317       {
0318         hcal::AMC13Header const* hamc13 = (hcal::AMC13Header const*)raw.data();
0319         if (!hamc13)
0320           continue;
0321 
0322         /* online only */
0323         if (_ptype == fOnline) {
0324           std::pair<uint16_t, uint16_t> cspair = utilities::fed2crate(fed);
0325           HcalElectronicsId eid = HcalElectronicsId(cspair.first, cspair.second, FIBER_uTCA_MIN1, FIBERCH_MIN, false);
0326           if (_filter_FEDsuTCA.filter(eid))
0327             continue;
0328           _cDataSizevsLS_FED.fill(eid, _currentLS, double(raw.size()) / 1024.);
0329         }
0330 
0331         uint32_t bcn = hamc13->bunchId();
0332         uint32_t orn = hamc13->orbitNumber() & 0xFFFF;  // LS 16bits only
0333         uint32_t evn = hamc13->l1aNumber();
0334         int namc = hamc13->NAMC();
0335 
0336         for (int iamc = 0; iamc < namc; iamc++) {
0337           int slot = hamc13->AMCSlot(iamc);
0338           int crate = hamc13->AMCId(iamc) & 0xFF;
0339           HcalElectronicsId eid(crate, slot, FIBER_uTCA_MIN1, FIBERCH_MIN, false);
0340           if (_filter_FEDsuTCA.filter(eid))
0341             continue;
0342           HcalUHTRData uhtr(hamc13->AMCPayload(iamc), hamc13->AMCSize(iamc));
0343 
0344           uint32_t uhtr_evn = uhtr.l1ANumber();
0345           uint32_t uhtr_bcn = uhtr.bunchNumber();
0346           uint32_t uhtr_orn = uhtr.orbitNumber();
0347           bool qevn = (uhtr_evn != evn);
0348           bool qbcn = (uhtr_bcn != bcn);
0349           bool qorn = (uhtr_orn != orn);
0350           if (qevn) {
0351             _cEvnMsm_ElectronicsuTCA.fill(eid);
0352 
0353             if (_ptype == fOnline)
0354               _xEvnMsmLS.get(eid)++;
0355           }
0356           if (qorn) {
0357             _cOrnMsm_ElectronicsuTCA.fill(eid);
0358 
0359             if (_ptype == fOnline)
0360               _xOrnMsmLS.get(eid)++;
0361           }
0362           if (qbcn) {
0363             _cBcnMsm_ElectronicsuTCA.fill(eid);
0364 
0365             if (_ptype == fOnline)
0366               _xBcnMsmLS.get(eid)++;
0367           }
0368         }
0369       }
0370     }
0371   }
0372 }
0373 
0374 std::shared_ptr<hcaldqm::Cache> RawTask::globalBeginLuminosityBlock(edm::LuminosityBlock const& lb,
0375                                                                     edm::EventSetup const& es) const {
0376   return DQTask::globalBeginLuminosityBlock(lb, es);
0377   //    _cBadQualityvsLS.extendAxisRange(_currentLS);
0378   //    _cSummaryvsLS_FED.extendAxisRange(_currentLS);
0379   //    _cSummaryvsLS.extendAxisRange(_currentLS);
0380 }
0381 
0382 /* virtual */ void RawTask::globalEndLuminosityBlock(edm::LuminosityBlock const& lb, edm::EventSetup const& es) {
0383   auto lumiCache = luminosityBlockCache(lb.index());
0384   _currentLS = lumiCache->currentLS;
0385   _evsPerLS = lumiCache->EvtCntLS;
0386 
0387   if (_ptype != fOnline)
0388     return;
0389 
0390   //
0391   //    GENERATE STATUS ONLY FOR ONLINE!
0392   //
0393   for (std::vector<uint32_t>::const_iterator it = _vhashFEDs.begin(); it != _vhashFEDs.end(); ++it) {
0394     flag::Flag fSum("RAW");
0395     HcalElectronicsId eid = HcalElectronicsId(*it);
0396 
0397     std::vector<uint32_t>::const_iterator cit = std::find(_vcdaqEids.begin(), _vcdaqEids.end(), *it);
0398     if (cit == _vcdaqEids.end()) {
0399       // not @cDAQ
0400       for (uint32_t iflag = 0; iflag < _vflags.size(); iflag++)
0401         _cSummaryvsLS_FED.setBinContent(eid, _currentLS, int(iflag), int(flag::fNCDAQ));
0402       _cSummaryvsLS.setBinContent(eid, _currentLS, int(flag::fNCDAQ));
0403       continue;
0404     }
0405 
0406     //  FED is @cDAQ
0407     if (hcaldqm::utilities::isFEDHBHE(eid) || hcaldqm::utilities::isFEDHF(eid) || hcaldqm::utilities::isFEDHO(eid)) {
0408       if (_xEvnMsmLS.get(eid) > 0)
0409         _vflags[fEvnMsm]._state = flag::fBAD;
0410       else
0411         _vflags[fEvnMsm]._state = flag::fGOOD;
0412       if (_xBcnMsmLS.get(eid) > 0)
0413         _vflags[fBcnMsm]._state = flag::fBAD;
0414       else
0415         _vflags[fBcnMsm]._state = flag::fGOOD;
0416       if (_xOrnMsmLS.get(eid) > 0)
0417         _vflags[fOrnMsm]._state = flag::fBAD;
0418       else
0419         _vflags[fOrnMsm]._state = flag::fGOOD;
0420       if (double(_xBadQLS.get(eid)) > double(12 * _evsPerLS))
0421         _vflags[fBadQ]._state = flag::fBAD;
0422       else if (_xBadQLS.get(eid) > 0)
0423         _vflags[fBadQ]._state = flag::fPROBLEMATIC;
0424       else
0425         _vflags[fBadQ]._state = flag::fGOOD;
0426     }
0427 
0428     int iflag = 0;
0429     //  iterate over all flags:
0430     //  - sum them all up in summary flag for this FED
0431     //  - reset each flag right after using it
0432     for (std::vector<flag::Flag>::iterator ft = _vflags.begin(); ft != _vflags.end(); ++ft) {
0433       _cSummaryvsLS_FED.setBinContent(eid, _currentLS, int(iflag), ft->_state);
0434       fSum += (*ft);
0435       iflag++;
0436 
0437       //    this is the MUST! We don't keep flags per FED, reset
0438       //    each one of them after using
0439       ft->reset();
0440     }
0441     _cSummaryvsLS.setBinContent(eid, _currentLS, fSum._state);
0442   }
0443 
0444   //    reset...
0445   _xOrnMsmLS.reset();
0446   _xEvnMsmLS.reset();
0447   _xBcnMsmLS.reset();
0448   _xBadQLS.reset();
0449 
0450   //    in the end always do the DQTask::endLumi
0451   DQTask::globalEndLuminosityBlock(lb, es);
0452 }
0453 
0454 DEFINE_FWK_MODULE(RawTask);
[ 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!