CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
DBWriterWorkers.cc
Go to the documentation of this file.
1 #include "../interface/DBWriterWorkers.h"
2 #include "../interface/LogicIDTranslation.h"
3 
4 #include "DQM/EcalCommon/interface/EcalDQMCommonUtils.h"
5 
6 #include "DQM/EcalCommon/interface/MESetMulti.h"
7 #include "DQM/EcalCommon/interface/MESetUtils.h"
8 
9 #include "OnlineDB/EcalCondDB/interface/EcalLogicID.h"
10 #include "OnlineDB/EcalCondDB/interface/MonCrystalConsistencyDat.h"
11 #include "OnlineDB/EcalCondDB/interface/MonTTConsistencyDat.h"
12 #include "OnlineDB/EcalCondDB/interface/MonMemChConsistencyDat.h"
13 #include "OnlineDB/EcalCondDB/interface/MonMemTTConsistencyDat.h"
14 #include "OnlineDB/EcalCondDB/interface/MonLaserBlueDat.h"
15 #include "OnlineDB/EcalCondDB/interface/MonLaserGreenDat.h"
16 #include "OnlineDB/EcalCondDB/interface/MonLaserIRedDat.h"
17 #include "OnlineDB/EcalCondDB/interface/MonLaserRedDat.h"
18 #include "OnlineDB/EcalCondDB/interface/MonPNBlueDat.h"
19 #include "OnlineDB/EcalCondDB/interface/MonPNGreenDat.h"
20 #include "OnlineDB/EcalCondDB/interface/MonPNIRedDat.h"
21 #include "OnlineDB/EcalCondDB/interface/MonPNRedDat.h"
22 #include "OnlineDB/EcalCondDB/interface/MonTimingLaserBlueCrystalDat.h"
23 #include "OnlineDB/EcalCondDB/interface/MonTimingLaserGreenCrystalDat.h"
24 #include "OnlineDB/EcalCondDB/interface/MonTimingLaserIRedCrystalDat.h"
25 #include "OnlineDB/EcalCondDB/interface/MonTimingLaserRedCrystalDat.h"
26 #include "OnlineDB/EcalCondDB/interface/MonPedestalsDat.h"
27 #include "OnlineDB/EcalCondDB/interface/MonPNPedDat.h"
28 #include "OnlineDB/EcalCondDB/interface/MonPedestalsOnlineDat.h"
29 #include "OnlineDB/EcalCondDB/interface/MonTestPulseDat.h"
30 #include "OnlineDB/EcalCondDB/interface/MonPulseShapeDat.h"
31 #include "OnlineDB/EcalCondDB/interface/MonPNMGPADat.h"
32 #include "OnlineDB/EcalCondDB/interface/MonTimingCrystalDat.h"
33 #include "OnlineDB/EcalCondDB/interface/MonLed1Dat.h"
34 #include "OnlineDB/EcalCondDB/interface/MonLed2Dat.h"
35 // #include "OnlineDB/EcalCondDB/interface/MonPNLed1Dat.h"
36 // #include "OnlineDB/EcalCondDB/interface/MonPNLed2Dat.h"
37 #include "OnlineDB/EcalCondDB/interface/MonTimingLed1CrystalDat.h"
38 #include "OnlineDB/EcalCondDB/interface/MonTimingLed2CrystalDat.h"
39 #include "OnlineDB/EcalCondDB/interface/MonOccupancyDat.h"
40 #include "OnlineDB/EcalCondDB/interface/MonRunDat.h"
41 
42 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
43 #include "DataFormats/EcalDetId/interface/EBDetId.h"
44 #include "DataFormats/EcalDetId/interface/EEDetId.h"
45 #include "DataFormats/EcalDetId/interface/EcalTrigTowerDetId.h"
46 #include "DataFormats/EcalDetId/interface/EcalScDetId.h"
47 #include "DataFormats/EcalDetId/interface/EcalElectronicsId.h"
48 #include "DataFormats/EcalDetId/interface/EcalPnDiodeDetId.h"
49 
50 #include "FWCore/Utilities/interface/Exception.h"
51 #include "FWCore/MessageLogger/interface/MessageLogger.h"
52 
53 namespace ecaldqm {
54  enum Quality {
55  kBad = 0,
56  kGood = 1,
57  kUnknown = 2,
58  kMBad = 3,
59  kMGood = 4,
60  kMUnknown = 5
61  };
62 
63  bool
64  qualityOK(int _quality)
65  {
66  return (_quality != kBad && _quality != kUnknown);
67  }
68 
69  DBWriterWorker::DBWriterWorker(std::string const& _name, edm::ParameterSet const& _ps) :
70  name_(_name),
71  runTypes_(),
72  source_(),
73  active_(false)
74  {
75  edm::ParameterSet const& params(_ps.getUntrackedParameterSet(name_));
76 
77  std::vector<std::string> runTypes(params.getUntrackedParameter<std::vector<std::string> >("runTypes"));
78  for(unsigned iT(0); iT < runTypes.size(); ++iT)
79  runTypes_.insert(runTypes[iT]);
80 
81  if(!params.existsAs<edm::ParameterSet>("source", false)) return;
82 
83  edm::ParameterSet const& sourceParams(params.getUntrackedParameterSet("source"));
84  std::vector<std::string> const& meNames(sourceParams.getParameterNames());
85  for(unsigned iP(0); iP < meNames.size(); ++iP){
86  std::string meName(meNames[iP]);
87  edm::ParameterSet const& meParam(sourceParams.getUntrackedParameterSet(meName));
88  source_.insert(meName, createMESet(meParam));
89  }
90  }
91 
92  void
93  DBWriterWorker::retrieveSource(DQMStore const& _store)
94  {
95  std::string failedPath;
96  for(MESetCollection::iterator sItr(source_.begin()); sItr != source_.end(); ++sItr){
97  if(!sItr->second->retrieve(_store, &failedPath)){
98  edm::LogError("EcalDQM") << name_ << ": MESet " << sItr->first << "@" << failedPath << " not found";
99  active_ = false;
100  return;
101  }
102  }
103 
104  active_ = true;
105  }
106 
107  bool
108  IntegrityWriter::run(EcalCondDBInterface* _db, MonRunIOV& _iov)
109  {
110  /*
111  uses
112  OccupancyTask.Digi (h_)
113  PNDiodeTask.Occupancy (hmem_)
114  IntegrityTask.Gain (h01_)
115  IntegrityTask.ChId (h02_)
116  IntegrityTask.GainSwitch (h03_)
117  IntegrityTask.TowerId (h04_)
118  IntegrityTask.BlockSize (h05_)
119  RawDataTask.L1AFE
120  RawDataTask.BXFE
121  PNDiodeTask.MemChId (h06_)
122  PNDiodeTask.MemGain (h07_)
123  PNDiodeTask.MemTowerId (h08_)
124  PNDiodeTask.MomBlockSize (h09_)
125  IntegrityClient.Quality
126  PNIntegrityClient.QualitySummary
127  */
128 
129  bool result(true);
130 
131  std::map<EcalLogicID, MonCrystalConsistencyDat> crystalConsistencies;
132  std::map<EcalLogicID, MonTTConsistencyDat> towerConsistencies;
133  std::map<EcalLogicID, MonMemChConsistencyDat> memChannelConsistencies;
134  std::map<EcalLogicID, MonMemTTConsistencyDat> memTowerConsistencies;
135 
136  MESet const& digiME(source_.at("Digi"));
137  MESet const& gainME(source_.at("Gain"));
138  MESet const& chidME(source_.at("ChId"));
139  MESet const& gainswitchME(source_.at("GainSwitch"));
140  MESet const& qualityME(source_.at("Quality"));
141 
142  MESet const& toweridME(source_.at("TowerId"));
143  MESet const& blocksizeME(source_.at("BlockSize"));
144  MESet const& l1aME(source_.at("L1AFE"));
145  MESet const& bxME(source_.at("BXFE"));
146 
147  MESet const& memdigiME(source_.at("MEMDigi"));
148  MESet const& memchidME(source_.at("MEMChId"));
149  MESet const& memgainME(source_.at("MEMGain"));
150  MESet const& pnqualityME(source_.at("PNQuality"));
151 
152  MESet const& memtoweridME(source_.at("MEMTowerId"));
153  MESet const& memblocksizeME(source_.at("MEMBlockSize"));
154 
155  if(verbosity_ > 1) edm::LogInfo("EcalDQM") << " Looping over crystals";
156 
157  MESet::const_iterator dEnd(digiME.end());
158  MESet::const_iterator qItr(qualityME);
159  for(MESet::const_iterator dItr(digiME.beginChannel()); dItr != dEnd; dItr.toNextChannel()){
160  DetId id(dItr->getId());
161 
162  int nDigis(dItr->getBinContent());
163  int gain(gainME.getBinContent(id));
164  int chid(chidME.getBinContent(id));
165  int gainswitch(gainswitchME.getBinContent(id));
166  qItr = dItr;
167 
168  if(gain > 0 || chid > 0 || gainswitch > 0){
169  MonCrystalConsistencyDat& data(crystalConsistencies[crystalID(id)]);
170  data.setProcessedEvents(nDigis);
171  data.setProblematicEvents(gain + chid + gainswitch);
172  data.setProblemsGainZero(gain);
173  data.setProblemsID(chid);
174  data.setProblemsGainSwitch(gainswitch);
175 
176  int channelStatus(qItr->getBinContent());
177  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
178  data.setTaskStatus(channelBad);
179 
180  result &= qualityOK(channelStatus);
181  }
182  }
183 
184  if(verbosity_ > 1) edm::LogInfo("EcalDQM") << " Looping over towers";
185 
186  for(unsigned iDCC(kEEmLow); iDCC <= kEBpHigh; ++iDCC){
187  for(unsigned iTower(1); iTower <= 68; ++iTower){
188  if(!ccuExists(iDCC + 1, iTower)) continue;
189 
190  EcalElectronicsId eid(iDCC + 1, iTower, 1, 1);
191  std::vector<DetId> channels(getElectronicsMap()->dccTowerConstituents(iDCC + 1, iTower));
192  int nDigis(0);
193  bool towerBad(false);
194  for(unsigned iD(0); iD < channels.size(); ++iD){
195  int n(digiME.getBinContent(channels[iD]));
196  if(n > nDigis) nDigis = n;
197  int channelStatus(qualityME.getBinContent(channels[iD]));
198  if(channelStatus == kBad || channelStatus == kMBad) towerBad = true;
199  }
200 
201  int towerid(toweridME.getBinContent(eid));
202  int blocksize(blocksizeME.getBinContent(eid));
203  int l1a(l1aME.getBinContent(iDCC + 1, iTower));
204  int bx(bxME.getBinContent(iDCC + 1, iTower));
205 
206  if(towerid > 0 || blocksize > 0 || l1a > 0 || bx > 0){
207  MonTTConsistencyDat& data(towerConsistencies[towerID(eid)]);
208  data.setProcessedEvents(nDigis);
209  data.setProblematicEvents(towerid + blocksize + l1a + bx);
210  data.setProblemsID(towerid);
211  data.setProblemsSize(blocksize);
212  data.setProblemsLV1(l1a);
213  data.setProblemsBunchX(bx);
214  data.setTaskStatus(towerBad);
215 
216  result &= !towerBad;
217  }
218  }
219  }
220 
221  if(verbosity_ > 1) edm::LogInfo("EcalDQM") << " Looping over MEM channels and towers";
222 
223  for(unsigned iMD(0); iMD < memDCC.size(); ++iMD){
224  unsigned iDCC(memDCC[iMD]);
225 
226  int subdet(iDCC <= kEEmHigh || iDCC >= kEEpLow ? EcalEndcap : EcalBarrel);
227 
228  for(unsigned iPN(1); iPN <= 10; ++iPN){
229  EcalPnDiodeDetId pnid(subdet, iDCC + 1, iPN);
230 
231  int nDigis(memdigiME.getBinContent(pnid));
232  int memchid(memchidME.getBinContent(pnid));
233  int memgain(memgainME.getBinContent(pnid));
234 
235  if(memchid > 0 || memgain > 0){
236  MonMemChConsistencyDat& data(memChannelConsistencies[memChannelID(pnid)]);
237 
238  data.setProcessedEvents(nDigis);
239  data.setProblematicEvents(memchid + memgain);
240  data.setProblemsID(memchid);
241  data.setProblemsGainZero(memgain);
242 
243  int channelStatus(pnqualityME.getBinContent(pnid));
244  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
245  data.setTaskStatus(channelBad);
246 
247  result &= qualityOK(channelStatus);
248  }
249  }
250 
251  for(unsigned iTower(69); iTower <= 70; ++iTower){
252  EcalElectronicsId eid(iDCC + 1, iTower, 1, 1);
253 
254  int nDigis(0);
255  bool towerBad(false);
256  for(unsigned iPN(1); iPN <= 10; ++iPN){
257  EcalPnDiodeDetId pnid(subdet, iDCC + 1, iPN);
258  int n(memdigiME.getBinContent(pnid));
259  if(n > nDigis) nDigis = n;
260  int channelStatus(pnqualityME.getBinContent(pnid));
261  if(channelStatus == kBad || channelStatus == kMBad) towerBad = true;
262  }
263 
264  int towerid(memtoweridME.getBinContent(eid));
265  int blocksize(memblocksizeME.getBinContent(eid));
266 
267  if(towerid > 0 || blocksize > 0){
268  MonMemTTConsistencyDat& data(memTowerConsistencies[memTowerID(eid)]);
269 
270  data.setProcessedEvents(nDigis);
271  data.setProblematicEvents(towerid + blocksize);
272  data.setProblemsID(towerid);
273  data.setProblemsSize(blocksize);
274  data.setTaskStatus(towerBad);
275 
276  result &= !towerBad;
277  }
278  }
279  }
280 
281  if(verbosity_ > 1) edm::LogInfo("EcalDQM") << " Inserting data";
282 
283  try{
284  if(crystalConsistencies.size() > 0){
285  if(verbosity_ > 2) edm::LogInfo("EcalDQM") << " crystalConsistencies";
286  _db->insertDataArraySet(&crystalConsistencies, &_iov);
287  }
288  if(towerConsistencies.size() > 0){
289  if(verbosity_ > 2) edm::LogInfo("EcalDQM") << " towerConsistencies";
290  _db->insertDataArraySet(&towerConsistencies, &_iov);
291  }
292  if(memChannelConsistencies.size() > 0){
293  if(verbosity_ > 2) edm::LogInfo("EcalDQM") << " memChannelConsistencies";
294  _db->insertDataArraySet(&memChannelConsistencies, &_iov);
295  }
296  if(memTowerConsistencies.size() > 0){
297  if(verbosity_ > 2) edm::LogInfo("EcalDQM") << " memTowerConsistencies";
298  _db->insertDataArraySet(&memTowerConsistencies, &_iov);
299  }
300  }
301  catch(std::runtime_error& e){
302  if(std::string(e.what()).find("unique constraint") != std::string::npos)
303  edm::LogWarning("EcalDQM") << e.what();
304  else
305  throw cms::Exception("DBError") << e.what();
306  }
307 
308  return result;
309  }
310 
311  LaserWriter::LaserWriter(edm::ParameterSet const& _ps) :
312  DBWriterWorker("Laser", _ps),
313  wlToME_()
314  {
315  std::vector<int> laserWavelengths(_ps.getUntrackedParameter<std::vector<int> >("laserWavelengths"));
316 
317  // wavelengths are not necessarily ordered
318  // create a map wl -> MESet index
319  // using Amplitude here but any multi-wavelength plot is fine
320 
321  MESet::PathReplacements repl;
322 
323  MESetMulti const& amplitude(static_cast<MESetMulti const&>(source_.at("Amplitude")));
324  unsigned nWL(laserWavelengths.size());
325  for(unsigned iWL(0); iWL != nWL; ++iWL){
326  int wl(laserWavelengths[iWL]);
327  if(wl <= 0 || wl >= 5) throw cms::Exception("InvalidConfiguration") << "Laser Wavelength";
328  repl["wl"] = std::to_string(wl);
329  wlToME_[wl] = amplitude.getIndex(repl);
330  }
331  }
332 
333  bool
334  LaserWriter::run(EcalCondDBInterface* _db, MonRunIOV& _iov)
335  {
336  /*
337  uses
338  LaserTask.Amplitude (h01, h03, h05, h07)
339  LaserTask.AOverP (h02, h04, h06, h08)
340  LaserTask.Timing (h09, h10, h11, h12)
341  LaserClient.Quality (meg01, meg02, meg03, meg04)
342  LaserTask.PNAmplitude (i09, i10, i11, i12)
343  LaserClient.PNQualitySummary (meg09, meg10, meg11, meg12)
344  PNDiodeTask.Pedestal (i13, i14, i15, i16)
345  */
346 
347  bool result(true);
348 
349  std::map<EcalLogicID, MonLaserBlueDat> l1Amp;
350  std::map<EcalLogicID, MonTimingLaserBlueCrystalDat> l1Time;
351  std::map<EcalLogicID, MonPNBlueDat> l1PN;
352  std::map<EcalLogicID, MonLaserGreenDat> l2Amp;
353  std::map<EcalLogicID, MonTimingLaserGreenCrystalDat> l2Time;
354  std::map<EcalLogicID, MonPNGreenDat> l2PN;
355  std::map<EcalLogicID, MonLaserIRedDat> l3Amp;
356  std::map<EcalLogicID, MonTimingLaserIRedCrystalDat> l3Time;
357  std::map<EcalLogicID, MonPNIRedDat> l3PN;
358  std::map<EcalLogicID, MonLaserRedDat> l4Amp;
359  std::map<EcalLogicID, MonTimingLaserRedCrystalDat> l4Time;
360  std::map<EcalLogicID, MonPNRedDat> l4PN;
361 
362  MESet const& ampME(source_.at("Amplitude"));
363  MESet const& aopME(source_.at("AOverP"));
364  MESet const& timeME(source_.at("Timing"));
365  MESet const& qualityME(source_.at("Quality"));
366 
367  MESet const& pnME(source_.at("PNAmplitude"));
368  MESet const& pnQualityME(source_.at("PNQuality"));
369  MESet const& pnPedestalME(source_.at("PNPedestal"));
370 
371  for(std::map<int, unsigned>::iterator wlItr(wlToME_.begin()); wlItr != wlToME_.end(); ++wlItr){
372  int wl(wlItr->first);
373  unsigned iM(wlItr->second);
374 
375  static_cast<MESetMulti const&>(ampME).use(iM);
376  static_cast<MESetMulti const&>(aopME).use(iM);
377  static_cast<MESetMulti const&>(timeME).use(iM);
378  static_cast<MESetMulti const&>(qualityME).use(iM);
379  static_cast<MESetMulti const&>(pnME).use(iM);
380  static_cast<MESetMulti const&>(pnQualityME).use(iM);
381 
382  MESet::const_iterator aEnd(ampME.end());
383  MESet::const_iterator qItr(qualityME);
384  MESet::const_iterator oItr(aopME);
385  MESet::const_iterator tItr(timeME);
386  for(MESet::const_iterator aItr(ampME.beginChannel()); aItr != aEnd; aItr.toNextChannel()){
387  float aEntries(aItr->getBinEntries());
388  if(aEntries < 1.) continue;
389 
390  qItr = aItr;
391  oItr = aItr;
392  tItr = aItr;
393 
394  DetId id(aItr->getId());
395 
396  float ampMean(aItr->getBinContent());
397  float ampRms(aItr->getBinError() * std::sqrt(aEntries));
398 
399  float aopEntries(oItr->getBinEntries());
400  float aopMean(oItr->getBinContent());
401  float aopRms(oItr->getBinError() * std::sqrt(aopEntries));
402 
403  float timeEntries(tItr->getBinEntries());
404  float timeMean(tItr->getBinContent());
405  float timeRms(tItr->getBinError() * std::sqrt(timeEntries));
406 
407  int channelStatus(qItr->getBinContent());
408  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
409 
410  EcalLogicID logicID(crystalID(id));
411 
412  switch(wl){
413  case 1:
414  {
415  MonLaserBlueDat& aData(l1Amp[logicID]);
416  aData.setAPDMean(ampMean);
417  aData.setAPDRMS(ampRms);
418  aData.setAPDOverPNMean(aopMean);
419  aData.setAPDOverPNRMS(aopRms);
420  aData.setTaskStatus(channelBad);
421 
422  MonTimingLaserBlueCrystalDat& tData(l1Time[logicID]);
423  tData.setTimingMean(timeMean);
424  tData.setTimingRMS(timeRms);
425  tData.setTaskStatus(channelBad);
426  }
427  break;
428  case 2:
429  {
430  MonLaserGreenDat& aData(l2Amp[logicID]);
431  aData.setAPDMean(ampMean);
432  aData.setAPDRMS(ampRms);
433  aData.setAPDOverPNMean(aopMean);
434  aData.setAPDOverPNRMS(aopRms);
435  aData.setTaskStatus(channelBad);
436 
437  MonTimingLaserGreenCrystalDat& tData(l2Time[logicID]);
438  tData.setTimingMean(timeMean);
439  tData.setTimingRMS(timeRms);
440  tData.setTaskStatus(channelBad);
441  }
442  break;
443  case 3:
444  {
445  MonLaserIRedDat& aData(l3Amp[logicID]);
446  aData.setAPDMean(ampMean);
447  aData.setAPDRMS(ampRms);
448  aData.setAPDOverPNMean(aopMean);
449  aData.setAPDOverPNRMS(aopRms);
450  aData.setTaskStatus(channelBad);
451 
452  MonTimingLaserIRedCrystalDat& tData(l3Time[logicID]);
453  tData.setTimingMean(timeMean);
454  tData.setTimingRMS(timeRms);
455  tData.setTaskStatus(channelBad);
456  }
457  break;
458  case 4:
459  {
460  MonLaserRedDat& aData(l4Amp[logicID]);
461  aData.setAPDMean(ampMean);
462  aData.setAPDRMS(ampRms);
463  aData.setAPDOverPNMean(aopMean);
464  aData.setAPDOverPNRMS(aopRms);
465  aData.setTaskStatus(channelBad);
466 
467  MonTimingLaserRedCrystalDat& tData(l4Time[logicID]);
468  tData.setTimingMean(timeMean);
469  tData.setTimingRMS(timeRms);
470  tData.setTaskStatus(channelBad);
471  }
472  break;
473  }
474  result &= qualityOK(channelStatus);
475  }
476 
477  for(unsigned iMD(0); iMD < memDCC.size(); ++iMD){
478  unsigned iDCC(memDCC[iMD]);
479 
480  int subdet(iDCC <= kEEmHigh || iDCC >= kEEpLow ? EcalEndcap : EcalBarrel);
481 
482  for(unsigned iPN(1); iPN <= 10; ++iPN){
483  EcalPnDiodeDetId pnid(subdet, iDCC + 1, iPN);
484 
485  float entries(pnME.getBinEntries(pnid));
486  if(entries < 1.) continue;
487 
488  float mean(pnME.getBinContent(pnid));
489  float rms(pnME.getBinError(pnid) * std::sqrt(entries));
490 
491  float pedestalEntries(pnPedestalME.getBinEntries(pnid));
492  float pedestalMean(pnPedestalME.getBinContent(pnid));
493  float pedestalRms(pnPedestalME.getBinError(pnid) * std::sqrt(pedestalEntries));
494 
495  int channelStatus(pnQualityME.getBinContent(pnid));
496  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
497 
498  switch(wl){
499  case 1:
500  {
501  MonPNBlueDat& data(l1PN[lmPNID(pnid)]);
502  data.setADCMeanG1(-1.);
503  data.setADCRMSG1(-1.);
504  data.setPedMeanG1(-1.);
505  data.setPedRMSG1(-1.);
506  data.setADCMeanG16(mean);
507  data.setADCRMSG16(rms);
508  data.setPedMeanG16(pedestalMean);
509  data.setPedRMSG16(pedestalRms);
510  data.setTaskStatus(channelBad);
511  }
512  break;
513  case 2:
514  {
515  MonPNGreenDat& data(l2PN[lmPNID(pnid)]);
516  data.setADCMeanG1(-1.);
517  data.setADCRMSG1(-1.);
518  data.setPedMeanG1(-1.);
519  data.setPedRMSG1(-1.);
520  data.setADCMeanG16(mean);
521  data.setADCRMSG16(rms);
522  data.setPedMeanG16(pedestalMean);
523  data.setPedRMSG16(pedestalRms);
524  data.setTaskStatus(channelBad);
525  }
526  break;
527  case 3:
528  {
529  MonPNIRedDat& data(l3PN[lmPNID(pnid)]);
530  data.setADCMeanG1(-1.);
531  data.setADCRMSG1(-1.);
532  data.setPedMeanG1(-1.);
533  data.setPedRMSG1(-1.);
534  data.setADCMeanG16(mean);
535  data.setADCRMSG16(rms);
536  data.setPedMeanG16(pedestalMean);
537  data.setPedRMSG16(pedestalRms);
538  data.setTaskStatus(channelBad);
539  }
540  break;
541  case 4:
542  {
543  MonPNRedDat& data(l4PN[lmPNID(pnid)]);
544  data.setADCMeanG1(-1.);
545  data.setADCRMSG1(-1.);
546  data.setPedMeanG1(-1.);
547  data.setPedRMSG1(-1.);
548  data.setADCMeanG16(mean);
549  data.setADCRMSG16(rms);
550  data.setPedMeanG16(pedestalMean);
551  data.setPedRMSG16(pedestalRms);
552  data.setTaskStatus(channelBad);
553  }
554  break;
555  }
556 
557  result &= qualityOK(channelStatus);
558 
559  }
560  }
561  }
562 
563  try{
564  if(l1Amp.size() > 0)
565  _db->insertDataArraySet(&l1Amp, &_iov);
566  if(l1Time.size() > 0)
567  _db->insertDataArraySet(&l1Time, &_iov);
568  if(l1PN.size() > 0)
569  _db->insertDataArraySet(&l1PN, &_iov);
570  if(l2Amp.size() > 0)
571  _db->insertDataArraySet(&l2Amp, &_iov);
572  if(l2Time.size() > 0)
573  _db->insertDataArraySet(&l2Time, &_iov);
574  if(l2PN.size() > 0)
575  _db->insertDataArraySet(&l2PN, &_iov);
576  if(l3Amp.size() > 0)
577  _db->insertDataArraySet(&l3Amp, &_iov);
578  if(l3Time.size() > 0)
579  _db->insertDataArraySet(&l3Time, &_iov);
580  if(l3PN.size() > 0)
581  _db->insertDataArraySet(&l3PN, &_iov);
582  if(l4Amp.size() > 0)
583  _db->insertDataArraySet(&l4Amp, &_iov);
584  if(l4Time.size() > 0)
585  _db->insertDataArraySet(&l4Time, &_iov);
586  if(l4PN.size() > 0)
587  _db->insertDataArraySet(&l4PN, &_iov);
588  }
589  catch(std::runtime_error& e){
590  if(std::string(e.what()).find("unique constraint") != std::string::npos)
591  edm::LogWarning("EcalDQM") << e.what();
592  else
593  throw cms::Exception("DBError") << e.what();
594  }
595 
596  return result;
597  }
598 
599  PedestalWriter::PedestalWriter(edm::ParameterSet const& _ps) :
600  DBWriterWorker("Pedestal", _ps),
601  gainToME_(),
602  pnGainToME_()
603  {
604  std::vector<int> MGPAGains(_ps.getUntrackedParameter<std::vector<int> >("MGPAGains"));
605  std::vector<int> MGPAGainsPN(_ps.getUntrackedParameter<std::vector<int> >("MGPAGainsPN"));
606 
607  MESet::PathReplacements repl;
608 
609  MESetMulti const& pedestal(static_cast<MESetMulti const&>(source_.at("Pedestal")));
610  unsigned nG(MGPAGains.size());
611  for(unsigned iG(0); iG != nG; ++iG){
612  int gain(MGPAGains[iG]);
613  if(gain != 1 && gain != 6 && gain != 12) throw cms::Exception("InvalidConfiguration") << "MGPA gain";
614  repl["gain"] = std::to_string(gain);
615  gainToME_[gain] = pedestal.getIndex(repl);
616  }
617 
618  repl.clear();
619 
620  MESetMulti const& pnPedestal(static_cast<MESetMulti const&>(source_.at("PNPedestal")));
621  unsigned nGPN(MGPAGainsPN.size());
622  for(unsigned iG(0); iG != nGPN; ++iG){
623  int gain(MGPAGainsPN[iG]);
624  if(gain != 1 && gain != 16) throw cms::Exception("InvalidConfiguration") << "PN MGPA gain";
625  repl["pngain"] = std::to_string(gain);
626  pnGainToME_[gain] = pnPedestal.getIndex(repl);
627  }
628  }
629 
630  bool
631  PedestalWriter::run(EcalCondDBInterface* _db, MonRunIOV& _iov)
632  {
633  /*
634  uses
635  PedestalTask.Pedestal (h01, h02, h03)
636  PedestalTask.PNPedestal (i01, i02)
637  PedestalClient.Quality (meg01, meg02, meg03)
638  PedestalClient.PNQualitySummary (meg04, meg05)
639  */
640 
641  bool result(true);
642 
643  std::map<EcalLogicID, MonPedestalsDat> pedestals;
644  std::map<EcalLogicID, MonPNPedDat> pnPedestals;
645 
646  MESet const& pedestalME(source_.at("Pedestal"));
647  MESet const& qualityME(source_.at("Quality"));
648 
649  MESet const& pnPedestalME(source_.at("PNPedestal"));
650  MESet const& pnQualityME(source_.at("PNQuality"));
651 
652  for(std::map<int, unsigned>::iterator gainItr(gainToME_.begin()); gainItr != gainToME_.end(); ++gainItr){
653  int gain(gainItr->first);
654  int iM(gainItr->second);
655 
656  static_cast<MESetMulti const&>(pedestalME).use(iM);
657  static_cast<MESetMulti const&>(qualityME).use(iM);
658 
659  MESet::const_iterator pEnd(pedestalME.end());
660  MESet::const_iterator qItr(qualityME);
661  for(MESet::const_iterator pItr(pedestalME.beginChannel()); pItr != pEnd; pItr.toNextChannel()){
662  float entries(pItr->getBinEntries());
663  if(entries < 1.) continue;
664 
665  qItr = pItr;
666 
667  float mean(pItr->getBinContent());
668  float rms(pItr->getBinError() * std::sqrt(entries));
669 
670  EcalLogicID logicID(crystalID(pItr->getId()));
671  if(pedestals.find(logicID) == pedestals.end()){
672  MonPedestalsDat& insertion(pedestals[logicID]);
673  insertion.setPedMeanG1(-1.);
674  insertion.setPedRMSG1(-1.);
675  insertion.setPedMeanG6(-1.);
676  insertion.setPedRMSG6(-1.);
677  insertion.setPedMeanG12(-1.);
678  insertion.setPedRMSG12(-1.);
679  insertion.setTaskStatus(false);
680  }
681 
682  MonPedestalsDat& data(pedestals[logicID]);
683  switch(gain){
684  case 1:
685  data.setPedMeanG1(mean);
686  data.setPedRMSG1(rms);
687  break;
688  case 6:
689  data.setPedMeanG6(mean);
690  data.setPedRMSG6(rms);
691  break;
692  case 12:
693  data.setPedMeanG12(mean);
694  data.setPedRMSG12(rms);
695  break;
696  }
697 
698  int channelStatus(qItr->getBinContent());
699  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
700  if(channelBad)
701  data.setTaskStatus(true);
702 
703  result &= qualityOK(channelStatus);
704  }
705  }
706 
707  for(std::map<int, unsigned>::iterator gainItr(pnGainToME_.begin()); gainItr != pnGainToME_.end(); ++gainItr){
708  int gain(gainItr->first);
709  int iM(gainItr->second);
710 
711  static_cast<MESetMulti const&>(pnPedestalME).use(iM);
712  static_cast<MESetMulti const&>(pnQualityME).use(iM);
713 
714  for(unsigned iMD(0); iMD < memDCC.size(); ++iMD){
715  unsigned iDCC(memDCC[iMD]);
716 
717  int subdet(iDCC <= kEEmHigh || iDCC >= kEEpLow ? EcalEndcap : EcalBarrel);
718 
719  for(unsigned iPN(1); iPN <= 10; ++iPN){
720  EcalPnDiodeDetId pnid(subdet, iDCC + 1, iPN);
721 
722  float entries(pnPedestalME.getBinEntries(pnid));
723  if(entries < 1.) continue;
724 
725  float mean(pnPedestalME.getBinContent(pnid));
726  float rms(pnPedestalME.getBinError(pnid) * std::sqrt(entries));
727 
728  EcalLogicID logicID(lmPNID(pnid));
729  if(pnPedestals.find(logicID) == pnPedestals.end()){
730  MonPNPedDat& insertion(pnPedestals[logicID]);
731  insertion.setPedMeanG1(-1.);
732  insertion.setPedRMSG1(-1.);
733  insertion.setPedMeanG16(-1.);
734  insertion.setPedRMSG16(-1.);
735  insertion.setTaskStatus(false);
736  }
737 
738  MonPNPedDat& data(pnPedestals[lmPNID(pnid)]);
739  switch(gain){
740  case 1:
741  data.setPedMeanG1(mean);
742  data.setPedRMSG1(rms);
743  break;
744  case 16:
745  data.setPedMeanG16(mean);
746  data.setPedRMSG16(rms);
747  break;
748  }
749 
750  int channelStatus(pnQualityME.getBinContent(pnid));
751  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
752  if(channelBad)
753  data.setTaskStatus(true);
754 
755  result &= qualityOK(channelStatus);
756  }
757  }
758  }
759 
760  try{
761  if(pedestals.size() > 0)
762  _db->insertDataArraySet(&pedestals, &_iov);
763  if(pnPedestals.size() > 0)
764  _db->insertDataArraySet(&pnPedestals, &_iov);
765  }
766  catch(std::runtime_error& e){
767  if(std::string(e.what()).find("unique constraint") != std::string::npos)
768  edm::LogWarning("EcalDQM") << e.what();
769  else
770  throw cms::Exception("DBError") << e.what();
771  }
772 
773  return result;
774  }
775 
776  bool
777  PresampleWriter::run(EcalCondDBInterface* _db, MonRunIOV& _iov)
778  {
779  /*
780  uses
781  PresampleTask.Pedestal (h03)
782  PresampleClient.Quality (meg03)
783  */
784 
785  bool result(true);
786 
787  std::map<EcalLogicID, MonPedestalsOnlineDat> pedestals;
788 
789  MESet const& pedestalME(source_.at("Pedestal"));
790  MESet const& qualityME(source_.at("Quality"));
791 
792  MESet::const_iterator pEnd(pedestalME.end());
793  MESet::const_iterator qItr(qualityME);
794  for(MESet::const_iterator pItr(pedestalME.beginChannel()); pItr != pEnd; pItr.toNextChannel()){
795  float entries(pItr->getBinEntries());
796  if(entries < 1.) continue;
797 
798  qItr = pItr;
799 
800  float mean(pItr->getBinContent());
801  float rms(pItr->getBinError() * std::sqrt(entries));
802 
803  MonPedestalsOnlineDat& data(pedestals[crystalID(pItr->getId())]);
804  data.setADCMeanG12(mean);
805  data.setADCRMSG12(rms);
806 
807  int channelStatus(qItr->getBinContent());
808  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
809  data.setTaskStatus(channelBad);
810 
811  result &= qualityOK(channelStatus);
812  }
813 
814  try{
815  if(pedestals.size() > 0)
816  _db->insertDataArraySet(&pedestals, &_iov);
817  }
818  catch(std::runtime_error& e){
819  if(std::string(e.what()).find("unique constraint") != std::string::npos)
820  edm::LogWarning("EcalDQM") << e.what();
821  else
822  throw cms::Exception("DBError") << e.what();
823  }
824 
825  return result;
826  }
827 
828  TestPulseWriter::TestPulseWriter(edm::ParameterSet const& _ps) :
829  DBWriterWorker("TestPulse", _ps),
830  gainToME_(),
831  pnGainToME_()
832  {
833  std::vector<int> MGPAGains(_ps.getUntrackedParameter<std::vector<int> >("MGPAGains"));
834  std::vector<int> MGPAGainsPN(_ps.getUntrackedParameter<std::vector<int> >("MGPAGainsPN"));
835 
836  MESet::PathReplacements repl;
837 
838  MESetMulti const& amplitude(static_cast<MESetMulti const&>(source_.at("Amplitude")));
839  unsigned nG(MGPAGains.size());
840  for(unsigned iG(0); iG != nG; ++iG){
841  int gain(MGPAGains[iG]);
842  if(gain != 1 && gain != 6 && gain != 12) throw cms::Exception("InvalidConfiguration") << "MGPA gain";
843  repl["gain"] = std::to_string(gain);
844  gainToME_[gain] = amplitude.getIndex(repl);
845  }
846 
847  repl.clear();
848 
849  MESetMulti const& pnAmplitude(static_cast<MESetMulti const&>(source_.at("PNAmplitude")));
850  unsigned nGPN(MGPAGainsPN.size());
851  for(unsigned iG(0); iG != nGPN; ++iG){
852  int gain(MGPAGainsPN[iG]);
853  if(gain != 1 && gain != 16) throw cms::Exception("InvalidConfiguration") << "PN MGPA gain";
854  repl["pngain"] = std::to_string(gain);
855  pnGainToME_[gain] = pnAmplitude.getIndex(repl);
856  }
857  }
858 
859  bool
860  TestPulseWriter::run(EcalCondDBInterface* _db, MonRunIOV& _iov)
861  {
862  /*
863  uses
864  TestPulseTask.Amplitude (ha01, ha02, ha03)
865  TestPulseTask.Shape (me_hs01, me_hs02, me_hs03)
866  TestPulseTask.PNAmplitude (i01, i02)
867  PNDiodeTask.Pedestal (i03, i04)
868  TestPulseClient.Quality (meg01, meg02, meg03)
869  TestPulseClient.PNQualitySummary (meg04, meg05)
870  */
871 
872  bool result(true);
873 
874  std::map<EcalLogicID, MonTestPulseDat> amplitude;
875  std::map<EcalLogicID, MonPulseShapeDat> shape;
876  std::map<EcalLogicID, MonPNMGPADat> pnAmplitude;
877 
878  MESet const& amplitudeME(source_.at("Amplitude"));
879  MESet const& shapeME(source_.at("Shape"));
880  MESet const& qualityME(source_.at("Quality"));
881 
882  MESet const& pnAmplitudeME(source_.at("PNAmplitude"));
883  MESet const& pnPedestalME(source_.at("PNPedestal"));
884  MESet const& pnQualityME(source_.at("PNQuality"));
885 
886  for(std::map<int, unsigned>::iterator gainItr(gainToME_.begin()); gainItr != gainToME_.end(); ++gainItr){
887  int gain(gainItr->first);
888  int iM(gainItr->second);
889 
890  static_cast<MESetMulti const&>(amplitudeME).use(iM);
891  static_cast<MESetMulti const&>(shapeME).use(iM);
892  static_cast<MESetMulti const&>(qualityME).use(iM);
893 
894  MESet::const_iterator aEnd(amplitudeME.end());
895  MESet::const_iterator qItr(qualityME);
896  for(MESet::const_iterator aItr(amplitudeME.beginChannel()); aItr != aEnd; aItr.toNextChannel()){
897  float entries(aItr->getBinEntries());
898  if(entries < 1.) continue;
899 
900  qItr = aItr;
901 
902  float mean(aItr->getBinContent());
903  float rms(aItr->getBinError() * std::sqrt(entries));
904 
905  EcalLogicID logicID(crystalID(aItr->getId()));
906  if(amplitude.find(logicID) == amplitude.end()){
907  MonTestPulseDat& insertion(amplitude[logicID]);
908  insertion.setADCMeanG1(-1.);
909  insertion.setADCRMSG1(-1.);
910  insertion.setADCMeanG6(-1.);
911  insertion.setADCRMSG6(-1.);
912  insertion.setADCMeanG12(-1.);
913  insertion.setADCRMSG12(-1.);
914  insertion.setTaskStatus(false);
915  }
916 
917  MonTestPulseDat& data(amplitude[logicID]);
918  switch(gain){
919  case 1:
920  data.setADCMeanG1(mean);
921  data.setADCRMSG1(rms);
922  break;
923  case 6:
924  data.setADCMeanG6(mean);
925  data.setADCRMSG6(rms);
926  break;
927  case 12:
928  data.setADCMeanG12(mean);
929  data.setADCRMSG12(rms);
930  break;
931  }
932 
933  int channelStatus(qItr->getBinContent());
934  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
935  if(channelBad)
936  data.setTaskStatus(true);
937 
938  result &= qualityOK(channelStatus);
939  }
940 
941  for(unsigned iSM(0); iSM < 54; ++iSM){
942  std::vector<float> samples(10, 0.);
943  std::vector<DetId> ids(getElectronicsMap()->dccConstituents(iSM + 1));
944  unsigned nId(ids.size());
945  unsigned nChannels(0);
946  EcalLogicID logicID;
947  for(unsigned iD(0); iD < nId; ++iD){
948  DetId& id(ids[iD]);
949 
950  if(iD == 0) logicID = crystalID(id);
951 
952  if(shapeME.getBinEntries(id, 1) < 1.) continue;
953 
954  ++nChannels;
955 
956  for(int i(0); i < 10; ++i)
957  samples[i] += shapeME.getBinContent(id, i + 1);
958  }
959 
960  if(nChannels == 0) continue;
961 
962  for(int i(0); i < 10; ++i)
963  samples[i] /= nChannels;
964 
965  if(shape.find(logicID) == shape.end()){
966  MonPulseShapeDat& insertion(shape[logicID]);
967  std::vector<float> defval(10, -1.);
968  insertion.setSamples(defval, 1);
969  insertion.setSamples(defval, 6);
970  insertion.setSamples(defval, 12);
971  }
972 
973  MonPulseShapeDat& data(shape[logicID]);
974  data.setSamples(samples, gain);
975  }
976  }
977 
978  for(std::map<int, unsigned>::iterator gainItr(pnGainToME_.begin()); gainItr != pnGainToME_.end(); ++gainItr){
979  int gain(gainItr->first);
980  int iM(gainItr->second);
981 
982  static_cast<MESetMulti const&>(pnAmplitudeME).use(iM);
983  static_cast<MESetMulti const&>(pnQualityME).use(iM);
984 
985  for(unsigned iMD(0); iMD < memDCC.size(); ++iMD){
986  unsigned iDCC(memDCC[iMD]);
987 
988  int subdet(iDCC <= kEEmHigh || iDCC >= kEEpLow ? EcalEndcap : EcalBarrel);
989 
990  for(unsigned iPN(1); iPN <= 10; ++iPN){
991  EcalPnDiodeDetId pnid(subdet, iDCC + 1, iPN);
992 
993  float entries(pnAmplitudeME.getBinEntries(pnid));
994  if(entries < 1.) continue;
995 
996  float mean(pnAmplitudeME.getBinContent(pnid));
997  float rms(pnAmplitudeME.getBinError(pnid) * std::sqrt(entries));
998  float pedestalEntries(pnPedestalME.getBinEntries(pnid));
999  float pedestalMean(pnPedestalME.getBinContent(pnid));
1000  float pedestalRms(pnPedestalME.getBinError(pnid) * std::sqrt(pedestalEntries));
1001 
1002  EcalLogicID logicID(lmPNID(pnid));
1003  if(pnAmplitude.find(logicID) == pnAmplitude.end()){
1004  MonPNMGPADat& insertion(pnAmplitude[logicID]);
1005  insertion.setADCMeanG1(-1.);
1006  insertion.setADCRMSG1(-1.);
1007  insertion.setPedMeanG1(-1.);
1008  insertion.setPedRMSG1(-1.);
1009  insertion.setADCMeanG16(-1.);
1010  insertion.setADCRMSG16(-1.);
1011  insertion.setPedMeanG16(-1.);
1012  insertion.setPedRMSG16(-1.);
1013  insertion.setTaskStatus(false);
1014  }
1015 
1016  MonPNMGPADat& data(pnAmplitude[lmPNID(pnid)]);
1017  switch(gain){
1018  case 1:
1019  data.setADCMeanG1(mean);
1020  data.setADCRMSG1(rms);
1021  // dynamic pedestal not measured for G1
1022 // data.setPedMeanG1(pedestalMean);
1023 // data.setPedRMSG1(pedestalRms);
1024  break;
1025  case 16:
1026  data.setADCMeanG16(mean);
1027  data.setADCRMSG16(rms);
1028  data.setPedMeanG16(pedestalMean);
1029  data.setPedRMSG16(pedestalRms);
1030  break;
1031  }
1032 
1033  int channelStatus(pnQualityME.getBinContent(pnid));
1034  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
1035  if(channelBad)
1036  data.setTaskStatus(true);
1037 
1038  result &= qualityOK(channelStatus);
1039  }
1040  }
1041  }
1042 
1043  try{
1044  if(amplitude.size() > 0)
1045  _db->insertDataArraySet(&amplitude, &_iov);
1046  if(shape.size() > 0)
1047  _db->insertDataSet(&shape, &_iov);
1048  if(pnAmplitude.size() > 0)
1049  _db->insertDataArraySet(&pnAmplitude, &_iov);
1050  }
1051  catch(std::runtime_error& e){
1052  if(std::string(e.what()).find("unique constraint") != std::string::npos)
1053  edm::LogWarning("EcalDQM") << e.what();
1054  else
1055  throw cms::Exception("DBError") << e.what();
1056  }
1057 
1058  return result;
1059  }
1060 
1061  bool
1062  TimingWriter::run(EcalCondDBInterface* _db, MonRunIOV& _iov)
1063  {
1064  /*
1065  uses
1066  TimingTask.TimeMap (h01)
1067  TimingClient.Quality (meg01)
1068  */
1069 
1070  bool result(true);
1071 
1072  std::map<EcalLogicID, MonTimingCrystalDat> timing;
1073 
1074  MESet const& timingME(source_.at("Timing"));
1075  MESet const& qualityME(source_.at("Quality"));
1076 
1077  MESet::const_iterator tEnd(timingME.end());
1078  MESet::const_iterator qItr(qualityME);
1079  for(MESet::const_iterator tItr(timingME.beginChannel()); tItr != tEnd; tItr.toNextChannel()){
1080  float entries(tItr->getBinEntries());
1081  if(entries < 1.) continue;
1082 
1083  qItr = tItr;
1084 
1085  float mean(tItr->getBinContent());
1086  float rms(tItr->getBinError() * std::sqrt(entries));
1087 
1088  MonTimingCrystalDat& data(timing[crystalID(tItr->getId())]);
1089  data.setTimingMean(mean);
1090  data.setTimingRMS(rms);
1091 
1092  int channelStatus(qItr->getBinContent());
1093  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
1094  data.setTaskStatus(channelBad);
1095 
1096  result &= qualityOK(channelStatus);
1097  }
1098 
1099  try{
1100  if(timing.size() > 0)
1101  _db->insertDataArraySet(&timing, &_iov);
1102  }
1103  catch(std::runtime_error& e){
1104  if(std::string(e.what()).find("unique constraint") != std::string::npos)
1105  edm::LogWarning("EcalDQM") << e.what();
1106  else
1107  throw cms::Exception("DBError") << e.what();
1108  }
1109 
1110  return result;
1111  }
1112 
1113  LedWriter::LedWriter(edm::ParameterSet const& _ps) :
1114  DBWriterWorker("Led", _ps),
1115  wlToME_()
1116  {
1117  std::vector<int> ledWavelengths(_ps.getUntrackedParameter<std::vector<int> >("ledWavelengths"));
1118 
1119  // wavelengths are not necessarily ordered
1120  // create a map wl -> MESet index
1121  // using Amplitude here but any multi-wavelength plot is fine
1122 
1123  MESet::PathReplacements repl;
1124 
1125  MESetMulti const& amplitude(static_cast<MESetMulti const&>(source_.at("Amplitude")));
1126  unsigned nWL(ledWavelengths.size());
1127  for(unsigned iWL(0); iWL != nWL; ++iWL){
1128  int wl(ledWavelengths[iWL]);
1129  if(wl != 1 && wl != 2) throw cms::Exception("InvalidConfiguration") << "Led Wavelength";
1130  repl["wl"] = std::to_string(wl);
1131  wlToME_[wl] = amplitude.getIndex(repl);
1132  }
1133  }
1134 
1135  bool
1136  LedWriter::run(EcalCondDBInterface* _db, MonRunIOV& _iov)
1137  {
1138  /*
1139  uses
1140  LedTask.Amplitude (h01, h03)
1141  LedTask.AOverP (h02, h04)
1142  LedTask.Timing (h09, h10)
1143  LedClient.Quality (meg01, meg02)
1144  LedTask.PNAmplitude (i09, i10)
1145 x LedClient.PNQualitySummary (meg09, meg10)
1146 x PNDiodeTask.Pedestal (i13, i14)
1147  */
1148 
1149  bool result(true);
1150 
1151  std::map<EcalLogicID, MonLed1Dat> l1Amp;
1152  std::map<EcalLogicID, MonTimingLed1CrystalDat> l1Time;
1153 // std::map<EcalLogicID, MonPNLed1Dat> l1PN;
1154  std::map<EcalLogicID, MonLed2Dat> l2Amp;
1155  std::map<EcalLogicID, MonTimingLed2CrystalDat> l2Time;
1156 // std::map<EcalLogicID, MonPNLed2Dat> l2PN;
1157 
1158  MESet const& ampME(source_.at("Amplitude"));
1159  MESet const& aopME(source_.at("AOverP"));
1160  MESet const& timeME(source_.at("Timing"));
1161  MESet const& qualityME(source_.at("Quality"));
1162 
1163 // MESet const& pnME(source_.at("PNAmplitude"));
1164 // MESet const& pnQualityME(source_.at("PNQuality"));
1165 // MESet const& pnPedestalME(source_.at("PNPedestal"));
1166 
1167  for(std::map<int, unsigned>::iterator wlItr(wlToME_.begin()); wlItr != wlToME_.end(); ++wlItr){
1168  int wl(wlItr->first);
1169  unsigned iM(wlItr->second);
1170 
1171  static_cast<MESetMulti const&>(ampME).use(iM);
1172  static_cast<MESetMulti const&>(aopME).use(iM);
1173  static_cast<MESetMulti const&>(timeME).use(iM);
1174  static_cast<MESetMulti const&>(qualityME).use(iM);
1175 // static_cast<MESetMulti const&>(pnME).use(iM);
1176 // static_cast<MESetMulti const&>(pnQualityME).use(iM);
1177 
1178  MESet::const_iterator aEnd(ampME.end());
1179  MESet::const_iterator qItr(qualityME);
1180  MESet::const_iterator oItr(aopME);
1181  MESet::const_iterator tItr(timeME);
1182  for(MESet::const_iterator aItr(ampME.beginChannel()); aItr != aEnd; aItr.toNextChannel()){
1183  float aEntries(aItr->getBinEntries());
1184  if(aEntries < 1.) continue;
1185 
1186  qItr = aItr;
1187  oItr = aItr;
1188  tItr = aItr;
1189 
1190  DetId id(aItr->getId());
1191 
1192  float ampMean(aItr->getBinContent());
1193  float ampRms(aItr->getBinError() * std::sqrt(aEntries));
1194 
1195  float aopEntries(oItr->getBinEntries());
1196  float aopMean(oItr->getBinContent());
1197  float aopRms(oItr->getBinError() * std::sqrt(aopEntries));
1198 
1199  float timeEntries(tItr->getBinEntries());
1200  float timeMean(tItr->getBinContent());
1201  float timeRms(tItr->getBinError() * std::sqrt(timeEntries));
1202 
1203  int channelStatus(qItr->getBinContent());
1204  bool channelBad(channelStatus == kBad || channelStatus == kMBad);
1205 
1206  EcalLogicID logicID(crystalID(id));
1207 
1208  switch(wl){
1209  case 1:
1210  {
1211  MonLed1Dat& aData(l1Amp[logicID]);
1212  aData.setVPTMean(ampMean);
1213  aData.setVPTRMS(ampRms);
1214  aData.setVPTOverPNMean(aopMean);
1215  aData.setVPTOverPNRMS(aopRms);
1216  aData.setTaskStatus(channelBad);
1217 
1218  MonTimingLed1CrystalDat& tData(l1Time[logicID]);
1219  tData.setTimingMean(timeMean);
1220  tData.setTimingRMS(timeRms);
1221  tData.setTaskStatus(channelBad);
1222  }
1223  break;
1224  case 2:
1225  {
1226  MonLed2Dat& aData(l2Amp[logicID]);
1227  aData.setVPTMean(ampMean);
1228  aData.setVPTRMS(ampRms);
1229  aData.setVPTOverPNMean(aopMean);
1230  aData.setVPTOverPNRMS(aopRms);
1231  aData.setTaskStatus(channelBad);
1232 
1233  MonTimingLed2CrystalDat& tData(l2Time[logicID]);
1234  tData.setTimingMean(timeMean);
1235  tData.setTimingRMS(timeRms);
1236  tData.setTaskStatus(channelBad);
1237  }
1238  break;
1239  }
1240  result &= qualityOK(channelStatus);
1241  }
1242 
1243 // for(unsigned iMD(0); iMD < memDCC.size(); ++iMD){
1244 // unsigned iDCC(memDCC[iMD]);
1245 
1246 // if(iDCC >= kEBmLow && iDCC <= kEBpHigh) continue;
1247 
1248 // for(unsigned iPN(1); iPN <= 10; ++iPN){
1249 // EcalPnDiodeDetId pnid(EcalEndcap, iDCC + 1, iPN);
1250 
1251 // float entries(pnME.getBinEntries(pnid));
1252 // if(entries < 1.) continue;
1253 
1254 // float mean(pnME.getBinContent(pnid));
1255 // float rms(pnME.getBinError(pnid) * std::sqrt(entries));
1256 
1257 // float pedestalEntries(pnPedestalME.getBinEntries(pnid));
1258 // float pedestalMean(pnPedestalME.getBinContent(pnid));
1259 // float pedestalRms(pnPedestalME.getBinError(pnid) * std::sqrt(pedestalEntries));
1260 
1261 // int channelStatus(pnQualityME.getBinContent(pnid));
1262 // bool channelBad(channelStatus == kBad || channelStatus == kMBad);
1263 
1264 // switch(wl){
1265 // case 1:
1266 // {
1267 // MonPNLed1Dat& data(l1PN[lmPNID(pnid)]);
1268 // data.setADCMeanG1(-1.);
1269 // data.setADCRMSG1(-1.);
1270 // data.setPedMeanG1(-1.);
1271 // data.setPedRMSG1(-1.);
1272 // data.setADCMeanG16(mean);
1273 // data.setADCRMSG16(rms);
1274 // data.setPedMeanG16(pedestalMean);
1275 // data.setPedRMSG16(pedestalRms);
1276 // data.setTaskStatus(channelBad);
1277 // }
1278 // break;
1279 // case 2:
1280 // {
1281 // MonPNLed2Dat& data(l2PN[lmPNID(pnid)]);
1282 // data.setADCMeanG1(-1.);
1283 // data.setADCRMSG1(-1.);
1284 // data.setPedMeanG1(-1.);
1285 // data.setPedRMSG1(-1.);
1286 // data.setADCMeanG16(mean);
1287 // data.setADCRMSG16(rms);
1288 // data.setPedMeanG16(pedestalMean);
1289 // data.setPedRMSG16(pedestalRms);
1290 // data.setTaskStatus(channelBad);
1291 // }
1292 // break;
1293 // }
1294 
1295 // result &= qualityOK(channelStatus);
1296 
1297 // }
1298 // }
1299  }
1300 
1301  try{
1302  if(l1Amp.size() > 0)
1303  _db->insertDataArraySet(&l1Amp, &_iov);
1304  if(l1Time.size() > 0)
1305  _db->insertDataArraySet(&l1Time, &_iov);
1306 // if(l1PN.size() > 0)
1307 // _db->insertDataArraySet(&l1PN, &_iov);
1308  if(l2Amp.size() > 0)
1309  _db->insertDataArraySet(&l2Amp, &_iov);
1310  if(l2Time.size() > 0)
1311  _db->insertDataArraySet(&l2Time, &_iov);
1312 // if(l2PN.size() > 0)
1313 // _db->insertDataArraySet(&l2PN, &_iov);
1314  }
1315  catch(std::runtime_error& e){
1316  if(std::string(e.what()).find("unique constraint") != std::string::npos)
1317  edm::LogWarning("EcalDQM") << e.what();
1318  else
1319  throw cms::Exception("DBError") << e.what();
1320  }
1321 
1322  return result;
1323  }
1324 
1325  bool
1326  OccupancyWriter::run(EcalCondDBInterface* _db, MonRunIOV& _iov)
1327  {
1328  /*
1329  uses
1330  OccupancyTask.Digi (i01)
1331  EnergyTask.HitMap (i02)
1332  */
1333  std::map<EcalLogicID, MonOccupancyDat> occupancy;
1334 
1335  MESet const& occupancyME(source_.at("Occupancy"));
1336  MESet const& energyME(source_.at("Energy"));
1337 
1338  MESet::const_iterator oEnd(occupancyME.end());
1339  MESet::const_iterator eItr(energyME);
1340  for(MESet::const_iterator oItr(occupancyME.beginChannel()); oItr != oEnd; oItr.toNextChannel()){
1341 
1342  if(oItr->getME()->getTH1()->GetEntries() < 1000.) continue;
1343 
1344  int entries(oItr->getBinContent());
1345  if(entries < 10) continue;
1346 
1347  eItr = oItr;
1348 
1349  int eEntries(eItr->getBinEntries());
1350  float energy(eEntries > 10 ? eItr->getBinContent() : -1.);
1351 
1352  MonOccupancyDat& data(occupancy[crystalID(oItr->getId())]);
1353  data.setEventsOverLowThreshold(entries);
1354  data.setEventsOverHighThreshold(eEntries);
1355  data.setAvgEnergy(energy);
1356  }
1357 
1358  try{
1359  if(occupancy.size() > 0)
1360  _db->insertDataArraySet(&occupancy, &_iov);
1361  }
1362  catch(std::runtime_error& e){
1363  if(std::string(e.what()).find("unique constraint") != std::string::npos)
1364  edm::LogWarning("EcalDQM") << e.what();
1365  else
1366  throw cms::Exception("DBError") << e.what();
1367  }
1368 
1369  return true;
1370  }
1371 
1372  bool
1373  SummaryWriter::run(EcalCondDBInterface* _db, MonRunIOV& _iov)
1374  {
1375  std::map<EcalLogicID, MonRunDat> dataset;
1376  MonRunDat& runDat(dataset[ecalID()]);
1377 
1378  // CURRENTLY ONLY WRITING SUCCESS
1379  MonRunOutcomeDef outcomeDef;
1380  outcomeDef.setShortDesc("success");
1381 
1382  runDat.setNumEvents(processedEvents_);
1383  runDat.setMonRunOutcomeDef(outcomeDef);
1384  runDat.setTaskList(taskList_);
1385  runDat.setTaskOutcome(outcome_);
1386 
1387  try{
1388  _db->insertDataSet(&dataset, &_iov);
1389  }
1390  catch(std::runtime_error& e){
1391  if(std::string(e.what()).find("unique constraint") != std::string::npos)
1392  edm::LogWarning("EcalDQM") << e.what();
1393  else
1394  throw cms::Exception("DBError") << e.what();
1395  }
1396 
1397  return true;
1398  }
1399 }
ecaldqm::memDCC
std::vector< unsigned > const memDCC
MonPNBlueDat::setADCMeanG1
void setADCMeanG1(float mean)
Definition: MonPNBlueDat.h:21
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
i
int i
Definition: DBlmapReader.cc:9
MonPedestalsDat::setPedMeanG1
void setPedMeanG1(float mean)
Definition: MonPedestalsDat.h:20
MonRunDat::setTaskList
void setTaskList(int list)
Definition: MonRunDat.h:30
MonPNIRedDat::setADCRMSG16
void setADCRMSG16(float mean)
Definition: MonPNIRedDat.h:30
MonPNIRedDat::setPedRMSG16
void setPedRMSG16(float mean)
Definition: MonPNIRedDat.h:42
MonPNMGPADat::setPedRMSG1
void setPedRMSG1(float mean)
Definition: MonPNMGPADat.h:36
MonRunDat::setNumEvents
void setNumEvents(int num)
Definition: MonRunDat.h:21
ecaldqm::SummaryWriter::run
bool run(EcalCondDBInterface *, MonRunIOV &) override
Definition: DBWriterWorkers.cc:1373
ecaldqm::PedestalWriter::PedestalWriter
PedestalWriter(edm::ParameterSet const &)
Definition: DBWriterWorkers.cc:599
MonRunDat::setMonRunOutcomeDef
void setMonRunOutcomeDef(const MonRunOutcomeDef &outcomeDef)
Definition: MonRunDat.h:24
ecaldqm::DBWriterWorker::DBWriterWorker
DBWriterWorker(std::string const &, edm::ParameterSet const &)
Definition: DBWriterWorkers.cc:69
MonTTConsistencyDat::setProblematicEvents
void setProblematicEvents(int prob)
Definition: MonTTConsistencyDat.h:24
MonPNBlueDat::setADCRMSG16
void setADCRMSG16(float mean)
Definition: MonPNBlueDat.h:30
MonTestPulseDat::setADCRMSG1
void setADCRMSG1(float rms)
Definition: MonTestPulseDat.h:24
MonPNBlueDat::setADCMeanG16
void setADCMeanG16(float mean)
Definition: MonPNBlueDat.h:27
MonOccupancyDat::setAvgEnergy
void setAvgEnergy(float energy)
Definition: MonOccupancyDat.h:27
MonLaserRedDat::setAPDOverPNRMS
void setAPDOverPNRMS(float rms)
Definition: MonLaserRedDat.h:30
MonOccupancyDat::setEventsOverLowThreshold
void setEventsOverLowThreshold(int events)
Definition: MonOccupancyDat.h:21
MonLaserBlueDat::setAPDOverPNMean
void setAPDOverPNMean(float mean)
Definition: MonLaserBlueDat.h:27
EcalElectronicsId
Ecal readout channel identification [32:20] Unused (so far) [19:13] DCC id [12:6] tower [5:3] strip [...
Definition: EcalElectronicsId.h:20
MonPNPedDat::setPedRMSG16
void setPedRMSG16(float mean)
Definition: MonPNPedDat.h:30
ecaldqm::LaserWriter::wlToME_
std::map< int, unsigned > wlToME_
Definition: DBWriterWorkers.h:55
MonLaserIRedDat::setAPDMean
void setAPDMean(float mean)
Definition: MonLaserIRedDat.h:21
MonPNIRedDat::setADCMeanG16
void setADCMeanG16(float mean)
Definition: MonPNIRedDat.h:27
MonPNRedDat::setADCMeanG1
void setADCMeanG1(float mean)
Definition: MonPNRedDat.h:21
ecaldqm::getElectronicsMap
EcalElectronicsMapping const * getElectronicsMap()
Definition: EcalDQMCommonUtils.cc:479
ecaldqm::MESet::ConstBin::getBinEntries
double getBinEntries() const
Definition: MESet.h:180
MonTTConsistencyDat::setProblemsLV1
void setProblemsLV1(int LV1)
Definition: MonTTConsistencyDat.h:33
MonPNRedDat::setADCRMSG1
void setADCRMSG1(float mean)
Definition: MonPNRedDat.h:24
MonPNRedDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonPNRedDat.h:45
ecaldqm::TestPulseWriter::gainToME_
std::map< int, unsigned > gainToME_
Definition: DBWriterWorkers.h:86
MonLed2Dat::setVPTOverPNMean
void setVPTOverPNMean(float mean)
Definition: MonLed2Dat.h:27
EcalCondDBWriter_cfi.pedestal
string pedestal
Definition: EcalCondDBWriter_cfi.py:48
MonTestPulseDat::setADCMeanG1
void setADCMeanG1(float mean)
Definition: MonTestPulseDat.h:21
MonPNGreenDat::setADCRMSG1
void setADCRMSG1(float mean)
Definition: MonPNGreenDat.h:24
ecaldqm::IntegrityWriter::run
bool run(EcalCondDBInterface *, MonRunIOV &) override
Definition: DBWriterWorkers.cc:108
ecaldqm::DBWriterWorker::name_
std::string const name_
Definition: DBWriterWorkers.h:32
edm::ParameterSet::getUntrackedParameterSet
ParameterSet getUntrackedParameterSet(std::string const &name, ParameterSet const &defaultValue) const
Definition: ParameterSet.cc:2367
MonTestPulseDat::setADCMeanG6
void setADCMeanG6(float mean)
Definition: MonTestPulseDat.h:27
ecaldqm::ccuExists
bool ccuExists(unsigned, unsigned)
Definition: EcalDQMCommonUtils.cc:445
MonPNPedDat::setPedRMSG1
void setPedRMSG1(float mean)
Definition: MonPNPedDat.h:24
MonPNMGPADat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonPNMGPADat.h:45
MonPNBlueDat::setPedRMSG16
void setPedRMSG16(float mean)
Definition: MonPNBlueDat.h:42
ITimingDat::setTimingMean
void setTimingMean(float mean)
Definition: ITimingDat.h:45
MonPNPedDat::setPedMeanG1
void setPedMeanG1(float mean)
Definition: MonPNPedDat.h:21
MonTTConsistencyDat::setProblemsSize
void setProblemsSize(int size)
Definition: MonTTConsistencyDat.h:30
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:7
MonPNBlueDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonPNBlueDat.h:45
ecaldqm::LaserWriter::run
bool run(EcalCondDBInterface *, MonRunIOV &) override
Definition: DBWriterWorkers.cc:334
MonPedestalsDat::setPedRMSG6
void setPedRMSG6(float rms)
Definition: MonPedestalsDat.h:32
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
ecaldqm::OccupancyWriter::run
bool run(EcalCondDBInterface *, MonRunIOV &) override
Definition: DBWriterWorkers.cc:1326
MonPulseShapeDat::setSamples
void setSamples(std::vector< float > &samples, int gain)
Definition: MonPulseShapeDat.h:22
ecaldqm::DBWriterWorker::retrieveSource
virtual void retrieveSource(DQMStore const &)
Definition: DBWriterWorkers.cc:93
MonRunOutcomeDef::setShortDesc
void setShortDesc(std::string desc)
Definition: MonRunOutcomeDef.cc:35
MonPedestalsDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonPedestalsDat.h:38
MonTTConsistencyDat::setProcessedEvents
void setProcessedEvents(int proc)
Definition: MonTTConsistencyDat.h:21
MonLed2Dat::setVPTMean
void setVPTMean(float mean)
Definition: MonLed2Dat.h:21
cond::to_string
std::string to_string(const T &t)
Definition: Logger.cc:26
MonTestPulseDat::setADCMeanG12
void setADCMeanG12(float mean)
Definition: MonTestPulseDat.h:33
MonLed2Dat::setVPTOverPNRMS
void setVPTOverPNRMS(float rms)
Definition: MonLed2Dat.h:30
MonLed1Dat::setVPTOverPNMean
void setVPTOverPNMean(float mean)
Definition: MonLed1Dat.h:27
ecaldqm::LedWriter::LedWriter
LedWriter(edm::ParameterSet const &)
Definition: DBWriterWorkers.cc:1113
MonPNIRedDat::setADCMeanG1
void setADCMeanG1(float mean)
Definition: MonPNIRedDat.h:21
ecaldqm::LaserWriter::LaserWriter
LaserWriter(edm::ParameterSet const &)
Definition: DBWriterWorkers.cc:311
MonPNMGPADat::setADCMeanG16
void setADCMeanG16(float mean)
Definition: MonPNMGPADat.h:27
MonLaserGreenDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonLaserGreenDat.h:33
MonLaserRedDat::setAPDMean
void setAPDMean(float mean)
Definition: MonLaserRedDat.h:21
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
MonTestPulseDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonTestPulseDat.h:39
MonLed1Dat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonLed1Dat.h:33
ecaldqm::DBWriterWorker::source_
MESetCollection source_
Definition: DBWriterWorkers.h:34
MonPedestalsDat::setPedMeanG6
void setPedMeanG6(float mean)
Definition: MonPedestalsDat.h:23
MonLed2Dat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonLed2Dat.h:33
ecaldqm::TimingWriter::run
bool run(EcalCondDBInterface *, MonRunIOV &) override
Definition: DBWriterWorkers.cc:1062
MonLed2Dat::setVPTRMS
void setVPTRMS(float rms)
Definition: MonLed2Dat.h:24
query.result
tuple result
Definition: query.py:137
ecaldqm::MESet::ConstBin::getBinError
double getBinError() const
Definition: MESet.h:175
MonPNBlueDat::setPedMeanG1
void setPedMeanG1(float mean)
Definition: MonPNBlueDat.h:33
MonLaserGreenDat::setAPDMean
void setAPDMean(float mean)
Definition: MonLaserGreenDat.h:21
MonPNGreenDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonPNGreenDat.h:45
ecaldqm::TestPulseWriter::run
bool run(EcalCondDBInterface *, MonRunIOV &) override
Definition: DBWriterWorkers.cc:860
MonPNGreenDat::setPedRMSG1
void setPedRMSG1(float mean)
Definition: MonPNGreenDat.h:36
MonPNBlueDat::setPedRMSG1
void setPedRMSG1(float mean)
Definition: MonPNBlueDat.h:36
MonTestPulseDat::setADCRMSG12
void setADCRMSG12(float rms)
Definition: MonTestPulseDat.h:36
MonPNRedDat::setPedRMSG1
void setPedRMSG1(float mean)
Definition: MonPNRedDat.h:36
MonPNPedDat::setPedMeanG16
void setPedMeanG16(float mean)
Definition: MonPNPedDat.h:27
ecaldqm::memChannelID
EcalLogicID memChannelID(EcalPnDiodeDetId const &)
Definition: LogicIDTranslation.cc:65
MonRunDat::setTaskOutcome
void setTaskOutcome(int outcome)
Definition: MonRunDat.h:33
MonTTConsistencyDat::setProblemsBunchX
void setProblemsBunchX(int bunchX)
Definition: MonTTConsistencyDat.h:36
MonPNGreenDat::setADCMeanG1
void setADCMeanG1(float mean)
Definition: MonPNGreenDat.h:21
MonPNIRedDat::setADCRMSG1
void setADCRMSG1(float mean)
Definition: MonPNIRedDat.h:24
MonPNIRedDat::setPedRMSG1
void setPedRMSG1(float mean)
Definition: MonPNIRedDat.h:36
MonPNBlueDat::setADCRMSG1
void setADCRMSG1(float mean)
Definition: MonPNBlueDat.h:24
MonLaserIRedDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonLaserIRedDat.h:33
ecaldqm::TestPulseWriter::pnGainToME_
std::map< int, unsigned > pnGainToME_
Definition: DBWriterWorkers.h:87
ecaldqm::MESet::const_iterator
Definition: MESet.h:243
MonLaserBlueDat::setAPDRMS
void setAPDRMS(float rms)
Definition: MonLaserBlueDat.h:24
MonPNRedDat::setPedRMSG16
void setPedRMSG16(float mean)
Definition: MonPNRedDat.h:42
ecaldqm::ecalID
EcalLogicID ecalID()
Definition: LogicIDTranslation.cc:10
MonPNGreenDat::setADCRMSG16
void setADCRMSG16(float mean)
Definition: MonPNGreenDat.h:30
MonLaserIRedDat::setAPDOverPNRMS
void setAPDOverPNRMS(float rms)
Definition: MonLaserIRedDat.h:30
MonLaserGreenDat::setAPDRMS
void setAPDRMS(float rms)
Definition: MonLaserGreenDat.h:24
ecaldqm::PedestalWriter::pnGainToME_
std::map< int, unsigned > pnGainToME_
Definition: DBWriterWorkers.h:67
DetId
Definition: DetId.h:18
ITimingDat::setTaskStatus
void setTaskStatus(bool status)
Definition: ITimingDat.h:51
MonPedestalsDat::setPedRMSG1
void setPedRMSG1(float rms)
Definition: MonPedestalsDat.h:29
MonLaserGreenDat::setAPDOverPNRMS
void setAPDOverPNRMS(float rms)
Definition: MonLaserGreenDat.h:30
MonLed1Dat::setVPTRMS
void setVPTRMS(float rms)
Definition: MonLed1Dat.h:24
ecaldqm::qualityOK
bool qualityOK(int _quality)
Definition: DBWriterWorkers.cc:64
MonMemChConsistencyDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonMemChConsistencyDat.h:36
ecaldqm::lmPNID
EcalLogicID lmPNID(EcalPnDiodeDetId const &)
Definition: LogicIDTranslation.cc:101
ecaldqm::LedWriter::run
bool run(EcalCondDBInterface *, MonRunIOV &) override
Definition: DBWriterWorkers.cc:1136
MonLaserIRedDat::setAPDOverPNMean
void setAPDOverPNMean(float mean)
Definition: MonLaserIRedDat.h:27
ITimingDat::setTimingRMS
void setTimingRMS(float rms)
Definition: ITimingDat.h:48
MonPNRedDat::setADCMeanG16
void setADCMeanG16(float mean)
Definition: MonPNRedDat.h:27
dataset.dataset
tuple dataset
Definition: dataset.py:393
ecaldqm::PresampleWriter::run
bool run(EcalCondDBInterface *, MonRunIOV &) override
Definition: DBWriterWorkers.cc:777
MonTestPulseDat::setADCRMSG6
void setADCRMSG6(float rms)
Definition: MonTestPulseDat.h:30
MonPNGreenDat::setADCMeanG16
void setADCMeanG16(float mean)
Definition: MonPNGreenDat.h:27
compareJSON.const
string const
Definition: compareJSON.py:14
MonLaserBlueDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonLaserBlueDat.h:33
MonPNRedDat::setPedMeanG16
void setPedMeanG16(float mean)
Definition: MonPNRedDat.h:39
MonPNMGPADat::setPedMeanG16
void setPedMeanG16(float mean)
Definition: MonPNMGPADat.h:39
MonLaserBlueDat::setAPDOverPNRMS
void setAPDOverPNRMS(float rms)
Definition: MonLaserBlueDat.h:30
ecaldqm::MESet::ConstBin::getBinContent
double getBinContent() const
Definition: MESet.h:170
MonLaserRedDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonLaserRedDat.h:33
ecaldqm::PedestalWriter::gainToME_
std::map< int, unsigned > gainToME_
Definition: DBWriterWorkers.h:66
MonPNGreenDat::setPedMeanG1
void setPedMeanG1(float mean)
Definition: MonPNGreenDat.h:33
MonTTConsistencyDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonTTConsistencyDat.h:39
MonLaserGreenDat::setAPDOverPNMean
void setAPDOverPNMean(float mean)
Definition: MonLaserGreenDat.h:27
MonLaserIRedDat::setAPDRMS
void setAPDRMS(float rms)
Definition: MonLaserIRedDat.h:24
MonPNBlueDat::setPedMeanG16
void setPedMeanG16(float mean)
Definition: MonPNBlueDat.h:39
MonOccupancyDat::setEventsOverHighThreshold
void setEventsOverHighThreshold(int events)
Definition: MonOccupancyDat.h:24
MonMemTTConsistencyDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonMemTTConsistencyDat.h:39
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82
MonPNMGPADat::setADCRMSG1
void setADCRMSG1(float mean)
Definition: MonPNMGPADat.h:24
MonPNIRedDat::setPedMeanG1
void setPedMeanG1(float mean)
Definition: MonPNIRedDat.h:33
MonPNGreenDat::setPedRMSG16
void setPedRMSG16(float mean)
Definition: MonPNGreenDat.h:42
MonPedestalsDat::setPedMeanG12
void setPedMeanG12(float mean)
Definition: MonPedestalsDat.h:26
MonPNMGPADat::setADCMeanG1
void setADCMeanG1(float mean)
Definition: MonPNMGPADat.h:21
MonPNPedDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonPNPedDat.h:33
EcalCondDBInterface::insertDataArraySet
void insertDataArraySet(const std::map< EcalLogicID, DATT > *data, IOVT *iov)
Definition: EcalCondDBInterface.h:347
relval_parameters_module.energy
string energy
Definition: relval_parameters_module.py:29
EcalCondDBInterface::insertDataSet
void insertDataSet(const std::map< EcalLogicID, DATT > *data, IOVT *iov)
Definition: EcalCondDBInterface.h:307
ecaldqm::towerID
EcalLogicID towerID(EcalElectronicsId const &)
Definition: LogicIDTranslation.cc:48
ecaldqm::TestPulseWriter::TestPulseWriter
TestPulseWriter(edm::ParameterSet const &)
Definition: DBWriterWorkers.cc:828
MonLed1Dat::setVPTMean
void setVPTMean(float mean)
Definition: MonLed1Dat.h:21
ecaldqm::MESet::const_iterator::toNextChannel
const_iterator & toNextChannel()
Definition: MESet.cc:446
MonPNIRedDat::setPedMeanG16
void setPedMeanG16(float mean)
Definition: MonPNIRedDat.h:39
MonPNIRedDat::setTaskStatus
void setTaskStatus(bool status)
Definition: MonPNIRedDat.h:45
edm::false
volatile std::atomic< bool > shutdown_flag false
Definition: UnixSignalHandlers.cc:22
MonLaserBlueDat::setAPDMean
void setAPDMean(float mean)
Definition: MonLaserBlueDat.h:21
ecaldqm::LedWriter::wlToME_
std::map< int, unsigned > wlToME_
Definition: DBWriterWorkers.h:106
MonLed1Dat::setVPTOverPNRMS
void setVPTOverPNRMS(float rms)
Definition: MonLed1Dat.h:30
MonPNMGPADat::setADCRMSG16
void setADCRMSG16(float mean)
Definition: MonPNMGPADat.h:30
ecaldqm::DBWriterWorker::runTypes_
std::set< std::string > runTypes_
Definition: DBWriterWorkers.h:33
MonPNRedDat::setADCRMSG16
void setADCRMSG16(float mean)
Definition: MonPNRedDat.h:30
MonLaserRedDat::setAPDOverPNMean
void setAPDOverPNMean(float mean)
Definition: MonLaserRedDat.h:27
ecaldqm::memTowerID
EcalLogicID memTowerID(EcalElectronicsId const &)
Definition: LogicIDTranslation.cc:84
ecaldqm::MESet::PathReplacements
std::map< std::string, std::string > PathReplacements
Definition: MESet.h:31
ecaldqm::createMESet
MESet * createMESet(edm::ParameterSet const &)
Definition: MESetUtils.cc:19
ecaldqm::PedestalWriter::run
bool run(EcalCondDBInterface *, MonRunIOV &) override
Definition: DBWriterWorkers.cc:631
MonPNMGPADat::setPedMeanG1
void setPedMeanG1(float mean)
Definition: MonPNMGPADat.h:33
MonPNRedDat::setPedMeanG1
void setPedMeanG1(float mean)
Definition: MonPNRedDat.h:33
ecaldqm::crystalID
EcalLogicID crystalID(DetId const &)
Definition: LogicIDTranslation.cc:29
MonPNMGPADat::setPedRMSG16
void setPedRMSG16(float mean)
Definition: MonPNMGPADat.h:42
MonLaserRedDat::setAPDRMS
void setAPDRMS(float rms)
Definition: MonLaserRedDat.h:24
ecaldqm::MESetMulti::getIndex
unsigned getIndex(PathReplacements const &) const
Definition: MESetMulti.cc:164
MonPNGreenDat::setPedMeanG16
void setPedMeanG16(float mean)
Definition: MonPNGreenDat.h:39
MonPedestalsDat::setPedRMSG12
void setPedRMSG12(float rms)
Definition: MonPedestalsDat.h:35
Generated for CMSSW Reference Manual by doxygen 1.8.5