CMS 3D CMS Logo

HcalHardcodeCalibrations.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 // Original Author: Fedor Ratnikov
3 //
4 //
5 
6 #include <memory>
7 #include <iostream>
8 #include <string>
9 #include <vector>
10 
18 
21 
25 
27 
28 //#define DebugLog
29 
30 // class decleration
31 //
32 
33 using namespace cms;
34 
35 namespace {
36 
37  const std::vector<HcalGenericDetId>& allCells(const HcalTopology& hcaltopology, bool killHE = false) {
38  static std::vector<HcalGenericDetId> result;
39  int maxDepth = hcaltopology.maxDepth();
40 
41 #ifdef DebugLog
42  std::cout << std::endl << "HcalHardcodeCalibrations: maxDepth = " << maxDepth << std::endl;
43 #endif
44 
45  if (result.empty()) {
47  for (unsigned int phi = 0; phi <= HcalDetId::kHcalPhiMask2; phi++) {
48  for (int depth = 1; depth <= maxDepth; depth++) {
49  for (int det = 1; det <= HcalForward; det++) {
50  HcalDetId cell((HcalSubdetector)det, eta, phi, depth);
51  if (killHE && HcalEndcap == cell.subdetId())
52  continue;
53  if (hcaltopology.valid(cell)) {
54  result.push_back(cell);
55 #ifdef DebugLog
56  std::cout << " HcalHardcodedCalibrations: det|eta|phi|depth = " << det << "|" << eta << "|" << phi
57  << "|" << depth << std::endl;
58 #endif
59  }
60  }
61  }
62  }
63  }
64  ZdcTopology zdctopology;
65  HcalZDCDetId zcell;
67  for (int depth = 1; depth < 6; depth++) {
68  zcell = HcalZDCDetId(section, true, depth);
69  if (zdctopology.valid(zcell))
70  result.push_back(zcell);
71  zcell = HcalZDCDetId(section, false, depth);
72  if (zdctopology.valid(zcell))
73  result.push_back(zcell);
74  }
76  for (int depth = 1; depth < 5; depth++) {
77  zcell = HcalZDCDetId(section, true, depth);
78  if (zdctopology.valid(zcell))
79  result.push_back(zcell);
80  zcell = HcalZDCDetId(section, false, depth);
81  if (zdctopology.valid(zcell))
82  result.push_back(zcell);
83  }
85  for (int depth = 1; depth < 3; depth++) {
86  zcell = HcalZDCDetId(section, true, depth);
87  if (zdctopology.valid(zcell))
88  result.push_back(zcell);
89  zcell = HcalZDCDetId(section, false, depth);
90  if (zdctopology.valid(zcell))
91  result.push_back(zcell);
92  }
94  for (int depth = 1; depth < 17; depth++) {
95  zcell = HcalZDCDetId(section, true, depth);
96  if (zdctopology.valid(zcell))
97  result.push_back(zcell);
98  zcell = HcalZDCDetId(section, false, depth);
99  if (zdctopology.valid(zcell))
100  result.push_back(zcell);
101  }
102 
103  // HcalGenTriggerTower (HcalGenericSubdetector = 5)
104  // NASTY HACK !!!
105  // - As no valid(cell) check found for HcalTrigTowerDetId
106  // to create HT cells (ieta=1-28, iphi=1-72)&(ieta=29-32, iphi=1,5,... 69)
107 
108  for (int vers = 0; vers <= HcalTrigTowerDetId::kHcalVersMask; ++vers) {
109  for (int depth = 0; depth <= HcalTrigTowerDetId::kHcalDepthMask; ++depth) {
111  for (int phi = 1; phi <= HcalTrigTowerDetId::kHcalPhiMask; phi++) {
112  HcalTrigTowerDetId cell(eta, phi, depth, vers);
113  if (hcaltopology.validHT(cell)) {
114  result.push_back(cell);
115 #ifdef DebugLog
116  std::cout << " HcalHardcodedCalibrations: eta|phi|depth|vers = " << eta << "|" << phi << "|" << depth
117  << "|" << vers << std::endl;
118 #endif
119  }
120  }
121  }
122  }
123  }
124  }
125  return result;
126  }
127 
128 } // namespace
129 
131  : hb_recalibration(nullptr),
132  he_recalibration(nullptr),
133  hf_recalibration(nullptr),
134  setHEdsegm(false),
135  setHBdsegm(false) {
136  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::HcalHardcodeCalibrations->...";
137 
138  if (iConfig.exists("GainWidthsForTrigPrims"))
139  switchGainWidthsForTrigPrims = iConfig.getParameter<bool>("GainWidthsForTrigPrims");
140  else
142 
143  //DB helper preparation
151  dbHardcode.useHBUpgrade(iConfig.getParameter<bool>("useHBUpgrade"));
152  dbHardcode.useHEUpgrade(iConfig.getParameter<bool>("useHEUpgrade"));
153  dbHardcode.useHFUpgrade(iConfig.getParameter<bool>("useHFUpgrade"));
154  dbHardcode.useHOUpgrade(iConfig.getParameter<bool>("useHOUpgrade"));
155  dbHardcode.testHFQIE10(iConfig.getParameter<bool>("testHFQIE10"));
156  dbHardcode.testHEPlan1(iConfig.getParameter<bool>("testHEPlan1"));
157  dbHardcode.setKillHE(iConfig.getParameter<bool>("killHE"));
158  dbHardcode.setSiPMCharacteristics(iConfig.getParameter<std::vector<edm::ParameterSet>>("SiPMCharacteristics"));
159 
160  useLayer0Weight = iConfig.getParameter<bool>("useLayer0Weight");
161  useIeta18depth1 = iConfig.getParameter<bool>("useIeta18depth1");
162  testHEPlan1 = iConfig.getParameter<bool>("testHEPlan1");
163  // HB, HE, HF recalibration preparation
164  iLumi = iConfig.getParameter<double>("iLumi");
165 
166  if (iLumi > 0.0) {
167  bool hb_recalib = iConfig.getParameter<bool>("HBRecalibration");
168  bool he_recalib = iConfig.getParameter<bool>("HERecalibration");
169  bool hf_recalib = iConfig.getParameter<bool>("HFRecalibration");
170  if (hb_recalib) {
172  std::make_unique<HBHERecalibration>(iLumi,
173  iConfig.getParameter<double>("HBreCalibCutoff"),
174  iConfig.getParameter<edm::FileInPath>("HBmeanenergies").fullPath());
175  }
176  if (he_recalib) {
178  std::make_unique<HBHERecalibration>(iLumi,
179  iConfig.getParameter<double>("HEreCalibCutoff"),
180  iConfig.getParameter<edm::FileInPath>("HEmeanenergies").fullPath());
181  }
182  if (hf_recalib && !iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock").empty())
184  std::make_unique<HFRecalibration>(iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock"));
185 
186 #ifdef DebugLog
187  std::cout << " HcalHardcodeCalibrations: iLumi = " << iLumi << std::endl;
188 #endif
189  }
190 
191  std::vector<std::string> toGet = iConfig.getUntrackedParameter<std::vector<std::string>>("toGet");
192  for (auto& objectName : toGet) {
193  bool all = objectName == "all";
194 #ifdef DebugLog
195  std::cout << "Load parameters for " << objectName << std::endl;
196 #endif
197  if ((objectName == "Pedestals") || all) {
199  findingRecord<HcalPedestalsRcd>();
200  }
201  if ((objectName == "PedestalWidths") || all) {
203  findingRecord<HcalPedestalWidthsRcd>();
204  }
205  if ((objectName == "EffectivePedestals") || all) {
208  .consumes();
209  findingRecord<HcalPedestalsRcd>();
210  }
211  if ((objectName == "EffectivePedestalWidths") || all) {
214  .consumes();
215  findingRecord<HcalPedestalWidthsRcd>();
216  }
217  if ((objectName == "Gains") || all) {
219  findingRecord<HcalGainsRcd>();
220  }
221  if ((objectName == "GainWidths") || all) {
223  findingRecord<HcalGainWidthsRcd>();
224  }
225  if ((objectName == "PFCuts") || all) {
227  findingRecord<HcalPFCutsRcd>();
228  }
229  if ((objectName == "QIEData") || all) {
231  findingRecord<HcalQIEDataRcd>();
232  }
233  if ((objectName == "QIETypes") || all) {
235  findingRecord<HcalQIETypesRcd>();
236  }
237  if ((objectName == "ChannelQuality") || (objectName == "channelQuality") || all) {
239  findingRecord<HcalChannelQualityRcd>();
240  }
241  if ((objectName == "ElectronicsMap") || (objectName == "electronicsMap") || all) {
243  findingRecord<HcalElectronicsMapRcd>();
244  }
245  if ((objectName == "ZSThresholds") || (objectName == "zsThresholds") || all) {
247  findingRecord<HcalZSThresholdsRcd>();
248  }
249  if ((objectName == "RespCorrs") || (objectName == "ResponseCorrection") || all) {
251  topoTokens_[kRespCorrs] = c.consumes();
252  if (he_recalibration) {
253  heDarkeningToken_ = c.consumes(edm::ESInputTag("", "HE"));
254  }
255  if (hb_recalibration) {
256  hbDarkeningToken_ = c.consumes(edm::ESInputTag("", "HB"));
257  }
258  findingRecord<HcalRespCorrsRcd>();
259  }
260  if ((objectName == "LUTCorrs") || (objectName == "LUTCorrection") || all) {
262  findingRecord<HcalLUTCorrsRcd>();
263  }
264  if ((objectName == "PFCorrs") || (objectName == "PFCorrection") || all) {
266  findingRecord<HcalPFCorrsRcd>();
267  }
268  if ((objectName == "TimeCorrs") || (objectName == "TimeCorrection") || all) {
270  findingRecord<HcalTimeCorrsRcd>();
271  }
272  if ((objectName == "L1TriggerObjects") || (objectName == "L1Trigger") || all) {
275  findingRecord<HcalL1TriggerObjectsRcd>();
276  }
277  if ((objectName == "ValidationCorrs") || (objectName == "ValidationCorrection") || all) {
280  findingRecord<HcalValidationCorrsRcd>();
281  }
282  if ((objectName == "LutMetadata") || (objectName == "lutMetadata") || all) {
284  findingRecord<HcalLutMetadataRcd>();
285  }
286  if ((objectName == "DcsValues") || all) {
288  findingRecord<HcalDcsRcd>();
289  }
290  if ((objectName == "DcsMap") || (objectName == "dcsMap") || all) {
292  findingRecord<HcalDcsMapRcd>();
293  }
294  if ((objectName == "RecoParams") || all) {
296  findingRecord<HcalRecoParamsRcd>();
297  }
298  if ((objectName == "LongRecoParams") || all) {
300  findingRecord<HcalLongRecoParamsRcd>();
301  }
302  if ((objectName == "ZDCLowGainFractions") || all) {
305  findingRecord<HcalZDCLowGainFractionsRcd>();
306  }
307  if ((objectName == "MCParams") || all) {
309  findingRecord<HcalMCParamsRcd>();
310  }
311  if ((objectName == "FlagHFDigiTimeParams") || all) {
314  findingRecord<HcalFlagHFDigiTimeParamsRcd>();
315  }
316  if ((objectName == "FrontEndMap") || (objectName == "frontEndMap") || all) {
318  findingRecord<HcalFrontEndMapRcd>();
319  }
320  if ((objectName == "SiPMParameters") || all) {
322  findingRecord<HcalSiPMParametersRcd>();
323  }
324  if ((objectName == "SiPMCharacteristics") || all) {
326  findingRecord<HcalSiPMCharacteristicsRcd>();
327  }
328  if ((objectName == "TPChannelParameters") || all) {
331  findingRecord<HcalTPChannelParametersRcd>();
332  }
333  if ((objectName == "TPParameters") || all) {
335  findingRecord<HcalTPParametersRcd>();
336  }
337  }
338 }
339 
341 
342 //
343 // member functions
344 //
346  const edm::IOVSyncValue& iTime,
347  edm::ValidityInterval& oInterval) {
348  std::string record = iKey.name();
349  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::setIntervalFor-> key: " << record << " time: " << iTime.eventID()
350  << '/' << iTime.time().value();
352 }
353 
354 std::unique_ptr<HcalPedestals> HcalHardcodeCalibrations::producePedestals_(
356  std::string seff = eff ? "Effective" : "";
357  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "Pedestals-> ...";
358 
359  auto const& topo = rec.get(token);
360  auto result = std::make_unique<HcalPedestals>(&topo, false);
361  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
362  for (auto cell : cells) {
363  HcalPedestal item = dbHardcode.makePedestal(cell, false, eff, &topo, iLumi);
364  result->addValues(item);
365  }
366  return result;
367 }
368 
369 std::unique_ptr<HcalPedestalWidths> HcalHardcodeCalibrations::producePedestalWidths_(
371  std::string seff = eff ? "Effective" : "";
372  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "PedestalWidths-> ...";
373  auto const& topo = rec.get(token);
374  auto result = std::make_unique<HcalPedestalWidths>(&topo, false);
375  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
376  for (auto cell : cells) {
378  result->addValues(item);
379  }
380  return result;
381 }
382 
383 std::unique_ptr<HcalPedestals> HcalHardcodeCalibrations::producePedestals(const HcalPedestalsRcd& rec) {
384  return producePedestals_(rec, topoTokens_[kPedestals], false);
385 }
386 
387 std::unique_ptr<HcalPedestals> HcalHardcodeCalibrations::produceEffectivePedestals(const HcalPedestalsRcd& rec) {
389 }
390 
391 std::unique_ptr<HcalPedestalWidths> HcalHardcodeCalibrations::producePedestalWidths(const HcalPedestalWidthsRcd& rec) {
393 }
394 
396  const HcalPedestalWidthsRcd& rec) {
398 }
399 
400 std::unique_ptr<HcalGains> HcalHardcodeCalibrations::produceGains(const HcalGainsRcd& rec) {
401  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGains-> ...";
402 
403  auto const& topo = rec.get(topoTokens_[kGains]);
404  auto result = std::make_unique<HcalGains>(&topo);
405  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
406  for (auto cell : cells) {
408  result->addValues(item);
409  }
410  return result;
411 }
412 
413 std::unique_ptr<HcalGainWidths> HcalHardcodeCalibrations::produceGainWidths(const HcalGainWidthsRcd& rec) {
414  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGainWidths-> ...";
415 
416  auto const& topo = rec.get(topoTokens_[kGainWidths]);
417  auto result = std::make_unique<HcalGainWidths>(&topo);
418  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
419  for (auto cell : cells) {
420  // for Upgrade - include TrigPrims, for regular case - only HcalDetId
423  result->addValues(item);
424  } else if (!cell.isHcalTrigTowerDetId()) {
426  result->addValues(item);
427  }
428  }
429  return result;
430 }
431 
432 std::unique_ptr<HcalPFCuts> HcalHardcodeCalibrations::producePFCuts(const HcalPFCutsRcd& rec) {
433  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::producePFCuts-> ...";
434 
435  auto const& topo = rec.get(topoTokens_[kPFCuts]);
436  auto result = std::make_unique<HcalPFCuts>(&topo);
437  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
438  for (auto cell : cells) {
439  // Use only standard Hcal channels for now, no TrigPrims
440  if (!cell.isHcalTrigTowerDetId()) {
442  result->addValues(item);
443  }
444  }
445  return result;
446 }
447 
448 std::unique_ptr<HcalQIEData> HcalHardcodeCalibrations::produceQIEData(const HcalQIEDataRcd& rcd) {
449  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIEData-> ...";
450 
451  /*
452  std::cout << std::endl << ">>> HcalHardcodeCalibrations::produceQIEData"
453  << std::endl;
454  */
455 
456  auto const& topo = rcd.get(topoTokens_[kQIEData]);
457  auto result = std::make_unique<HcalQIEData>(&topo);
458  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
459  for (auto cell : cells) {
460  HcalQIECoder coder = dbHardcode.makeQIECoder(cell);
461  result->addCoder(coder);
462  }
463  return result;
464 }
465 
466 std::unique_ptr<HcalQIETypes> HcalHardcodeCalibrations::produceQIETypes(const HcalQIETypesRcd& rcd) {
467  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIETypes-> ...";
468  auto const& topo = rcd.get(topoTokens_[kQIETypes]);
469 
470  auto result = std::make_unique<HcalQIETypes>(&topo);
471  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
472  for (auto cell : cells) {
474  result->addValues(item);
475  }
476  return result;
477 }
478 
479 std::unique_ptr<HcalChannelQuality> HcalHardcodeCalibrations::produceChannelQuality(const HcalChannelQualityRcd& rcd) {
480  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceChannelQuality-> ...";
481  auto const& topo = rcd.get(topoTokens_[kChannelQuality]);
482 
483  auto result = std::make_unique<HcalChannelQuality>(&topo);
484  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
485  for (auto cell : cells) {
486  // Special: removal of (non-instrumented) layer "-1"("nose") = depth 1
487  // from Upgrade HE, either from
488  // (i) HEP17 sector in 2017 or
489  // (ii) the entire HE rin=18 from 2018 through Run 3.
490  // May require a revision by 2021.
491 
492  uint32_t status = 0;
493 
494  if (!(cell.isHcalZDCDetId())) {
495  HcalDetId hid = HcalDetId(cell);
496  int iphi = hid.iphi();
497  int ieta = hid.ieta();
498  int absieta = hid.ietaAbs();
499  int depth = hid.depth();
500 
501  // specific HEP17 sector (2017 only)
502  bool isHEP17 = (iphi >= 63) && (iphi <= 66) && (ieta > 0);
503  // |ieta|=18, depth=1
504  bool is18d1 = (absieta == 18) && (depth == 1);
505 
506  if ((!useIeta18depth1 && is18d1) && ((testHEPlan1 && isHEP17) || (!testHEPlan1))) {
507  status = 0x8002; // dead cell
508  }
509  }
510 
511  HcalChannelStatus item(cell.rawId(), status);
512  result->addValues(item);
513  }
514 
515  return result;
516 }
517 
518 std::unique_ptr<HcalRespCorrs> HcalHardcodeCalibrations::produceRespCorrs(const HcalRespCorrsRcd& rcd) {
519  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRespCorrs-> ...";
520  auto const& topo = rcd.get(topoTokens_[kRespCorrs]);
521 
522  //set depth segmentation for HB/HE recalib - only happens once
524  std::vector<std::vector<int>> m_segmentation;
525  int maxEta = topo.lastHBHERing();
526  m_segmentation.resize(maxEta);
527  for (int i = 0; i < maxEta; i++) {
528  topo.getDepthSegmentation(i + 1, m_segmentation[i]);
529  }
530  if (he_recalibration && !setHEdsegm) {
531  he_recalibration->setup(m_segmentation, &rcd.get(heDarkeningToken_));
532  setHEdsegm = true;
533  }
534  if (hb_recalibration && !setHBdsegm) {
535  hb_recalibration->setup(m_segmentation, &rcd.get(hbDarkeningToken_));
536  setHBdsegm = true;
537  }
538  }
539 
540  auto result = std::make_unique<HcalRespCorrs>(&topo);
541  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
542  for (const auto& cell : cells) {
543  double corr = 1.0;
544 
545  //check for layer 0 reweighting: when depth 1 has only one layer, it is layer 0
546  if (useLayer0Weight &&
547  ((cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap) ||
548  (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) &&
549  (HcalDetId(cell).depth() == 1 &&
550  dbHardcode.getLayersInDepth(HcalDetId(cell).ietaAbs(), HcalDetId(cell).depth(), &topo) == 1)) {
551  //layer 0 is thicker than other layers (9mm vs 3.7mm) and brighter (Bicron vs SCSN81)
552  //in Run1/Run2 (pre-2017 for HE), ODU for layer 0 had neutral density filter attached
553  //NDF was simulated as weight of 0.5 applied to Geant energy deposits
554  //for Phase1, NDF is removed - simulated as weight of 1.2 applied to Geant energy deposits
555  //to maintain RECO calibrations, move the layer 0 energy scale back to its previous state using respcorrs
556  corr = 0.5 / 1.2;
557  }
558 
559  if ((hb_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) {
560  int depth_ = HcalDetId(cell).depth();
561  int ieta_ = HcalDetId(cell).ieta();
562  corr *= hb_recalibration->getCorr(ieta_, depth_);
563 #ifdef DebugLog
564  std::cout << "HB ieta, depth = " << ieta_ << ", " << depth_ << " corr = " << corr << std::endl;
565 #endif
566  } else if ((he_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap)) {
567  int depth_ = HcalDetId(cell).depth();
568  int ieta_ = HcalDetId(cell).ieta();
569  corr *= he_recalibration->getCorr(ieta_, depth_);
570 #ifdef DebugLog
571  std::cout << "HE ieta, depth = " << ieta_ << ", " << depth_ << " corr = " << corr << std::endl;
572 #endif
573  } else if ((hf_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenForward)) {
574  int depth_ = HcalDetId(cell).depth();
575  int ieta_ = HcalDetId(cell).ieta();
576  corr = hf_recalibration->getCorr(ieta_, depth_, iLumi);
577 #ifdef DebugLog
578  std::cout << "HF ieta, depth = " << ieta_ << ", " << depth_ << " corr = " << corr << std::endl;
579 #endif
580  }
581 
582  HcalRespCorr item(cell.rawId(), corr);
583  result->addValues(item);
584  }
585  return result;
586 }
587 
588 std::unique_ptr<HcalLUTCorrs> HcalHardcodeCalibrations::produceLUTCorrs(const HcalLUTCorrsRcd& rcd) {
589  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLUTCorrs-> ...";
590  auto const& topo = rcd.get(topoTokens_[kLUTCorrs]);
591 
592  auto result = std::make_unique<HcalLUTCorrs>(&topo);
593  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
594  for (auto cell : cells) {
595  HcalLUTCorr item(cell.rawId(), 1.0);
596  result->addValues(item);
597  }
598  return result;
599 }
600 
601 std::unique_ptr<HcalPFCorrs> HcalHardcodeCalibrations::producePFCorrs(const HcalPFCorrsRcd& rcd) {
602  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::producePFCorrs-> ...";
603  auto const& topo = rcd.get(topoTokens_[kPFCorrs]);
604 
605  auto result = std::make_unique<HcalPFCorrs>(&topo);
606  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
607  for (auto cell : cells) {
608  HcalPFCorr item(cell.rawId(), 1.0);
609  result->addValues(item);
610  }
611  return result;
612 }
613 
614 std::unique_ptr<HcalTimeCorrs> HcalHardcodeCalibrations::produceTimeCorrs(const HcalTimeCorrsRcd& rcd) {
615  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimeCorrs-> ...";
616  auto const& topo = rcd.get(topoTokens_[kTimeCorrs]);
617 
618  auto result = std::make_unique<HcalTimeCorrs>(&topo);
619  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
620  for (auto cell : cells) {
621  HcalTimeCorr item(cell.rawId(), 0.0);
622  result->addValues(item);
623  }
624  return result;
625 }
626 
627 std::unique_ptr<HcalZSThresholds> HcalHardcodeCalibrations::produceZSThresholds(const HcalZSThresholdsRcd& rcd) {
628  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZSThresholds-> ...";
629  auto const& topo = rcd.get(topoTokens_[kZSThresholds]);
630 
631  auto result = std::make_unique<HcalZSThresholds>(&topo);
632  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
633  for (auto cell : cells) {
635  result->addValues(item);
636  }
637  return result;
638 }
639 
640 std::unique_ptr<HcalL1TriggerObjects> HcalHardcodeCalibrations::produceL1TriggerObjects(
641  const HcalL1TriggerObjectsRcd& rcd) {
642  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceL1TriggerObjects-> ...";
643  auto const& topo = rcd.get(topoTokens_[kL1TriggerObjects]);
644 
645  auto result = std::make_unique<HcalL1TriggerObjects>(&topo);
646  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
647  for (auto cell : cells) {
648  HcalL1TriggerObject item(cell.rawId(), 0., 1., 0);
649  result->addValues(item);
650  }
651  // add tag and algo values
652  result->setTagString("hardcoded");
653  result->setAlgoString("hardcoded");
654  return result;
655 }
656 
657 std::unique_ptr<HcalElectronicsMap> HcalHardcodeCalibrations::produceElectronicsMap(const HcalElectronicsMapRcd& rcd) {
658  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceElectronicsMap-> ...";
659  auto const& topo = rcd.get(topoTokens_[kElectronicsMap]);
660 
661  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
663 }
664 
665 std::unique_ptr<HcalValidationCorrs> HcalHardcodeCalibrations::produceValidationCorrs(
666  const HcalValidationCorrsRcd& rcd) {
667  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceValidationCorrs-> ...";
668  auto const& topo = rcd.get(topoTokens_[kValidationCorrs]);
669 
670  auto result = std::make_unique<HcalValidationCorrs>(&topo);
671  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
672  for (auto cell : cells) {
673  HcalValidationCorr item(cell.rawId(), 1.0);
674  result->addValues(item);
675  }
676  return result;
677 }
678 
679 std::unique_ptr<HcalLutMetadata> HcalHardcodeCalibrations::produceLutMetadata(const HcalLutMetadataRcd& rcd) {
680  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLutMetadata-> ...";
681  auto const& topo = rcd.get(topoTokens_[kLutMetadata]);
682 
683  auto result = std::make_unique<HcalLutMetadata>(&topo);
684 
685  result->setRctLsb(0.5);
686  result->setNominalGain(0.177); // for HBHE SiPMs
687 
688  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
689  for (const auto& cell : cells) {
690  float rcalib = 1.;
691  int granularity = 1;
692  int threshold = 0;
693 
694  if (cell.isHcalTrigTowerDetId()) {
695  rcalib = 0.;
696  }
697 
698  HcalLutMetadatum item(cell.rawId(), rcalib, granularity, threshold);
699  result->addValues(item);
700  }
701 
702  return result;
703 }
704 
705 std::unique_ptr<HcalDcsValues> HcalHardcodeCalibrations::produceDcsValues(const HcalDcsRcd& rcd) {
706  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceDcsValues-> ...";
707  auto result = std::make_unique<HcalDcsValues>();
708  return result;
709 }
710 
711 std::unique_ptr<HcalDcsMap> HcalHardcodeCalibrations::produceDcsMap(const HcalDcsMapRcd& rcd) {
712  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceDcsMap-> ...";
713 
715 }
716 
717 std::unique_ptr<HcalRecoParams> HcalHardcodeCalibrations::produceRecoParams(const HcalRecoParamsRcd& rec) {
718  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRecoParams-> ...";
719  auto const& topo = rec.get(topoTokens_[kRecoParams]);
720 
721  auto result = std::make_unique<HcalRecoParams>(&topo);
722  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
723  for (auto cell : cells) {
725  result->addValues(item);
726  }
727  return result;
728 }
729 
730 std::unique_ptr<HcalTimingParams> HcalHardcodeCalibrations::produceTimingParams(const HcalTimingParamsRcd& rec) {
731  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimingParams-> ...";
732  auto const& topo = rec.get(topoTokens_[kTimingParams]);
733 
734  auto result = std::make_unique<HcalTimingParams>(&topo);
735  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
736  for (auto cell : cells) {
738  result->addValues(item);
739  }
740  return result;
741 }
742 
743 std::unique_ptr<HcalLongRecoParams> HcalHardcodeCalibrations::produceLongRecoParams(const HcalLongRecoParamsRcd& rec) {
744  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLongRecoParams-> ...";
745  auto const& topo = rec.get(topoTokens_[kLongRecoParams]);
746 
747  auto result = std::make_unique<HcalLongRecoParams>(&topo);
748  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
749  std::vector<unsigned int> mSignal;
750  mSignal.push_back(4);
751  mSignal.push_back(5);
752  mSignal.push_back(6);
753  std::vector<unsigned int> mNoise;
754  mNoise.push_back(1);
755  mNoise.push_back(2);
756  mNoise.push_back(3);
757  for (auto cell : cells) {
758  if (cell.isHcalZDCDetId()) {
759  HcalLongRecoParam item(cell.rawId(), mSignal, mNoise);
760  result->addValues(item);
761  }
762  }
763  return result;
764 }
765 
766 std::unique_ptr<HcalZDCLowGainFractions> HcalHardcodeCalibrations::produceZDCLowGainFractions(
767  const HcalZDCLowGainFractionsRcd& rec) {
768  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZDCLowGainFractions-> ...";
769  auto const& topo = rec.get(topoTokens_[kZDCLowGainFractions]);
770 
771  auto result = std::make_unique<HcalZDCLowGainFractions>(&topo);
772  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
773  for (auto cell : cells) {
774  HcalZDCLowGainFraction item(cell.rawId(), 0.0);
775  result->addValues(item);
776  }
777  return result;
778 }
779 
780 std::unique_ptr<HcalMCParams> HcalHardcodeCalibrations::produceMCParams(const HcalMCParamsRcd& rec) {
781  // std::cout << std::endl << " .... HcalHardcodeCalibrations::produceMCParams ->"<< std::endl;
782 
783  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceMCParams-> ...";
784  auto const& topo = rec.get(topoTokens_[kMCParams]);
785  auto result = std::make_unique<HcalMCParams>(&topo);
786  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
787  for (auto cell : cells) {
789  result->addValues(item);
790  }
791  return result;
792 }
793 
794 std::unique_ptr<HcalFlagHFDigiTimeParams> HcalHardcodeCalibrations::produceFlagHFDigiTimeParams(
795  const HcalFlagHFDigiTimeParamsRcd& rec) {
796  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFlagHFDigiTimeParams-> ...";
797  auto const& topo = rec.get(topoTokens_[kFlagHFDigiTimeParams]);
798 
799  auto result = std::make_unique<HcalFlagHFDigiTimeParams>(&topo);
800  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
801 
802  std::vector<double> coef;
803  coef.push_back(0.93);
804  coef.push_back(-0.38275);
805  coef.push_back(-0.012667);
806 
807  for (auto cell : cells) {
808  HcalFlagHFDigiTimeParam item(cell.rawId(),
809  1, //firstsample
810  3, // samplestoadd
811  2, //expectedpeak
812  40., // min energy threshold
813  coef // coefficients
814  );
815  result->addValues(item);
816  }
817  return result;
818 }
819 
820 std::unique_ptr<HcalFrontEndMap> HcalHardcodeCalibrations::produceFrontEndMap(const HcalFrontEndMapRcd& rec) {
821  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFrontEndMap-> ...";
822  auto const& topo = rec.get(topoTokens_[kFrontEndMap]);
823 
824  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
825 
827 }
828 
829 std::unique_ptr<HcalSiPMParameters> HcalHardcodeCalibrations::produceSiPMParameters(const HcalSiPMParametersRcd& rec) {
830  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMParameters-> ...";
831  auto const& topo = rec.get(topoTokens_[kSiPMParameters]);
832 
833  auto result = std::make_unique<HcalSiPMParameters>(&topo);
834  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
835  for (auto cell : cells) {
837  result->addValues(item);
838  }
839  return result;
840 }
841 
842 std::unique_ptr<HcalSiPMCharacteristics> HcalHardcodeCalibrations::produceSiPMCharacteristics(
843  const HcalSiPMCharacteristicsRcd& rcd) {
844  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMCharacteristics-> ...";
845 
847 }
848 
849 std::unique_ptr<HcalTPChannelParameters> HcalHardcodeCalibrations::produceTPChannelParameters(
850  const HcalTPChannelParametersRcd& rec) {
851  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTPChannelParameters-> ...";
852  auto const& topo = rec.get(topoTokens_[kTPChannelParameters]);
853 
854  auto result = std::make_unique<HcalTPChannelParameters>(&topo);
855  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
856  for (auto cell : cells) {
857  // Thinking about Phase2 and the new FIR filter,
858  // for now, don't put TT in TPChannelParams
859  if (cell.subdetId() == HcalTriggerTower)
860  continue;
862  result->addValues(item);
863  }
864  return result;
865 }
866 
867 std::unique_ptr<HcalTPParameters> HcalHardcodeCalibrations::produceTPParameters(const HcalTPParametersRcd& rcd) {
868  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTPParameters-> ...";
869 
870  auto result = std::make_unique<HcalTPParameters>();
872  return result;
873 }
874 
877  desc.add<double>("iLumi", -1.);
878  desc.add<bool>("HBRecalibration", false);
879  desc.add<double>("HBreCalibCutoff", 20.);
880  desc.add<edm::FileInPath>("HBmeanenergies", edm::FileInPath("CalibCalorimetry/HcalPlugins/data/meanenergiesHB.txt"));
881  desc.add<bool>("HERecalibration", false);
882  desc.add<double>("HEreCalibCutoff", 20.);
883  desc.add<edm::FileInPath>("HEmeanenergies", edm::FileInPath("CalibCalorimetry/HcalPlugins/data/meanenergiesHE.txt"));
884  desc.add<bool>("HFRecalibration", false);
885  desc.add<bool>("GainWidthsForTrigPrims", false);
886  desc.add<bool>("useHBUpgrade", false);
887  desc.add<bool>("useHEUpgrade", false);
888  desc.add<bool>("useHFUpgrade", false);
889  desc.add<bool>("useHOUpgrade", true);
890  desc.add<bool>("testHFQIE10", false);
891  desc.add<bool>("testHEPlan1", false);
892  desc.add<bool>("killHE", false);
893  desc.add<bool>("useLayer0Weight", false);
894  desc.add<bool>("useIeta18depth1", true);
895  desc.addUntracked<std::vector<std::string>>("toGet", std::vector<std::string>());
896  desc.addUntracked<bool>("fromDDD", false);
897 
899  desc_hb.add<std::vector<double>>("gain", std::vector<double>({0.19}));
900  desc_hb.add<std::vector<double>>("gainWidth", std::vector<double>({0.0}));
901  desc_hb.add<double>("pedestal", 3.0);
902  desc_hb.add<double>("pedestalWidth", 0.55);
903  desc_hb.add<int>("zsThreshold", 8);
904  desc_hb.add<std::vector<double>>("qieOffset", std::vector<double>({-0.49, 1.8, 7.2, 37.9}));
905  desc_hb.add<std::vector<double>>("qieSlope", std::vector<double>({0.912, 0.917, 0.922, 0.923}));
906  desc_hb.add<int>("qieType", 0);
907  desc_hb.add<int>("mcShape", 125);
908  desc_hb.add<int>("recoShape", 105);
909  desc_hb.add<double>("photoelectronsToAnalog", 0.0);
910  desc_hb.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
911  desc_hb.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
912  desc_hb.add<bool>("doRadiationDamage", false);
913  desc_hb.add<double>("noiseThreshold", 0.0);
914  desc_hb.add<double>("seedThreshold", 0.1);
915  desc.add<edm::ParameterSetDescription>("hb", desc_hb);
916 
917  edm::ParameterSetDescription desc_hbRaddam;
918  desc_hbRaddam.add<double>("temperatureBase", 20.0);
919  desc_hbRaddam.add<double>("temperatureNew", -5.0);
920  desc_hbRaddam.add<double>("intlumiOffset", 150);
921  desc_hbRaddam.add<double>("depVsTemp", 0.0631);
922  desc_hbRaddam.add<double>("intlumiToNeutrons", 3.67e8);
923  desc_hbRaddam.add<std::vector<double>>("depVsNeutrons", {5.69e-11, 7.90e-11});
924 
925  edm::ParameterSetDescription desc_hbUpgrade;
926  desc_hbUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
927  desc_hbUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
928  desc_hbUpgrade.add<double>("pedestal", 18.0);
929  desc_hbUpgrade.add<double>("pedestalWidth", 5.0);
930  desc_hbUpgrade.add<int>("zsThreshold", 3);
931  desc_hbUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0, 0.0, 0.0, 0.0}));
932  desc_hbUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.333, 0.333, 0.333, 0.333}));
933  desc_hbUpgrade.add<int>("qieType", 2);
934  desc_hbUpgrade.add<int>("mcShape", 206);
935  desc_hbUpgrade.add<int>("recoShape", 206);
936  desc_hbUpgrade.add<double>("photoelectronsToAnalog", 57.5);
937  desc_hbUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.055}));
938  desc_hbUpgrade.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.26}));
939  desc_hbUpgrade.add<bool>("doRadiationDamage", true);
940  desc_hbUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_hbRaddam);
941  desc_hbUpgrade.add<double>("noiseThreshold", 0.0);
942  desc_hbUpgrade.add<double>("seedThreshold", 0.1);
943  desc.add<edm::ParameterSetDescription>("hbUpgrade", desc_hbUpgrade);
944 
946  desc_he.add<std::vector<double>>("gain", std::vector<double>({0.23}));
947  desc_he.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
948  desc_he.add<double>("pedestal", 3.0);
949  desc_he.add<double>("pedestalWidth", 0.79);
950  desc_he.add<int>("zsThreshold", 9);
951  desc_he.add<std::vector<double>>("qieOffset", std::vector<double>({-0.38, 2.0, 7.6, 39.6}));
952  desc_he.add<std::vector<double>>("qieSlope", std::vector<double>({0.912, 0.916, 0.92, 0.922}));
953  desc_he.add<int>("qieType", 0);
954  desc_he.add<int>("mcShape", 125);
955  desc_he.add<int>("recoShape", 105);
956  desc_he.add<double>("photoelectronsToAnalog", 0.0);
957  desc_he.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
958  desc_he.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
959  desc_he.add<bool>("doRadiationDamage", false);
960  desc_he.add<double>("noiseThreshold", 0.0);
961  desc_he.add<double>("seedThreshold", 0.1);
962  desc.add<edm::ParameterSetDescription>("he", desc_he);
963 
964  edm::ParameterSetDescription desc_heRaddam;
965  desc_heRaddam.add<double>("temperatureBase", 20.0);
966  desc_heRaddam.add<double>("temperatureNew", 5.0);
967  desc_heRaddam.add<double>("intlumiOffset", 75);
968  desc_heRaddam.add<double>("depVsTemp", 0.0631);
969  desc_heRaddam.add<double>("intlumiToNeutrons", 2.92e8);
970  desc_heRaddam.add<std::vector<double>>("depVsNeutrons", {5.69e-11, 7.90e-11});
971 
972  edm::ParameterSetDescription desc_heUpgrade;
973  desc_heUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
974  desc_heUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
975  desc_heUpgrade.add<double>("pedestal", 18.0);
976  desc_heUpgrade.add<double>("pedestalWidth", 5.0);
977  desc_heUpgrade.add<int>("zsThreshold", 3);
978  desc_heUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0, 0.0, 0.0, 0.0}));
979  desc_heUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.333, 0.333, 0.333, 0.333}));
980  desc_heUpgrade.add<int>("qieType", 2);
981  desc_heUpgrade.add<int>("mcShape", 206);
982  desc_heUpgrade.add<int>("recoShape", 206);
983  desc_heUpgrade.add<double>("photoelectronsToAnalog", 57.5);
984  desc_heUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.055}));
985  desc_heUpgrade.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.26}));
986  desc_heUpgrade.add<bool>("doRadiationDamage", true);
987  desc_heUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_heRaddam);
988  desc_heUpgrade.add<double>("noiseThreshold", 0.0);
989  desc_heUpgrade.add<double>("seedThreshold", 0.1);
990  desc.add<edm::ParameterSetDescription>("heUpgrade", desc_heUpgrade);
991 
993  desc_hf.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
994  desc_hf.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
995  desc_hf.add<double>("pedestal", 3.0);
996  desc_hf.add<double>("pedestalWidth", 0.84);
997  desc_hf.add<int>("zsThreshold", -9999);
998  desc_hf.add<std::vector<double>>("qieOffset", std::vector<double>({-0.87, 1.4, 7.8, -29.6}));
999  desc_hf.add<std::vector<double>>("qieSlope", std::vector<double>({0.359, 0.358, 0.36, 0.367}));
1000  desc_hf.add<int>("qieType", 0);
1001  desc_hf.add<int>("mcShape", 301);
1002  desc_hf.add<int>("recoShape", 301);
1003  desc_hf.add<double>("photoelectronsToAnalog", 0.0);
1004  desc_hf.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
1005  desc_hf.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
1006  desc_hf.add<bool>("doRadiationDamage", false);
1007  desc_hf.add<double>("noiseThreshold", 0.0);
1008  desc_hf.add<double>("seedThreshold", 0.1);
1009  desc.add<edm::ParameterSetDescription>("hf", desc_hf);
1010 
1011  edm::ParameterSetDescription desc_hfUpgrade;
1012  desc_hfUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
1013  desc_hfUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
1014  desc_hfUpgrade.add<double>("pedestal", 13.33);
1015  desc_hfUpgrade.add<double>("pedestalWidth", 3.33);
1016  desc_hfUpgrade.add<int>("zsThreshold", -9999);
1017  desc_hfUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0697, -0.7405, 12.38, -671.9}));
1018  desc_hfUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.297, 0.298, 0.298, 0.313}));
1019  desc_hfUpgrade.add<int>("qieType", 1);
1020  desc_hfUpgrade.add<int>("mcShape", 301);
1021  desc_hfUpgrade.add<int>("recoShape", 301);
1022  desc_hfUpgrade.add<double>("photoelectronsToAnalog", 0.0);
1023  desc_hfUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
1024  desc_hfUpgrade.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
1025  desc_hfUpgrade.add<bool>("doRadiationDamage", false);
1026  desc_hfUpgrade.add<double>("noiseThreshold", 0.0);
1027  desc_hfUpgrade.add<double>("seedThreshold", 0.1);
1028  desc.add<edm::ParameterSetDescription>("hfUpgrade", desc_hfUpgrade);
1029 
1030  edm::ParameterSetDescription desc_hfrecal;
1031  desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterA", std::vector<double>());
1032  desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterB", std::vector<double>());
1033  desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterA", std::vector<double>());
1034  desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterB", std::vector<double>());
1035  desc.add<edm::ParameterSetDescription>("HFRecalParameterBlock", desc_hfrecal);
1036 
1038  desc_ho.add<std::vector<double>>("gain", std::vector<double>({0.006, 0.0087}));
1039  desc_ho.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
1040  desc_ho.add<double>("pedestal", 11.0);
1041  desc_ho.add<double>("pedestalWidth", 0.57);
1042  desc_ho.add<int>("zsThreshold", 24);
1043  desc_ho.add<std::vector<double>>("qieOffset", std::vector<double>({-0.44, 1.4, 7.1, 38.5}));
1044  desc_ho.add<std::vector<double>>("qieSlope", std::vector<double>({0.907, 0.915, 0.92, 0.921}));
1045  desc_ho.add<int>("qieType", 0);
1046  desc_ho.add<int>("mcShape", 201);
1047  desc_ho.add<int>("recoShape", 201);
1048  desc_ho.add<double>("photoelectronsToAnalog", 4.0);
1049  desc_ho.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
1050  desc_ho.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
1051  desc_ho.add<bool>("doRadiationDamage", false);
1052  desc_ho.add<double>("noiseThreshold", 0.0);
1053  desc_ho.add<double>("seedThreshold", 0.1);
1054  desc.add<edm::ParameterSetDescription>("ho", desc_ho);
1055 
1056  edm::ParameterSetDescription validator_sipm;
1057  validator_sipm.add<int>("pixels", 1);
1058  validator_sipm.add<double>("crosstalk", 0);
1059  validator_sipm.add<double>("nonlin1", 1);
1060  validator_sipm.add<double>("nonlin2", 0);
1061  validator_sipm.add<double>("nonlin3", 0);
1062  std::vector<edm::ParameterSet> default_sipm(1);
1063  desc.addVPSet("SiPMCharacteristics", validator_sipm, default_sipm);
1064 
1065  descriptions.addDefault(desc);
1066 }
std::unique_ptr< HcalPedestals > producePedestals(const HcalPedestalsRcd &rcd)
std::unique_ptr< HcalPFCuts > producePFCuts(const HcalPFCutsRcd &rcd)
static const int kHcalVersMask
auto setWhatProduced(T *iThis, const es::Label &iLabel={})
Definition: ESProducer.h:166
bool validHT(const HcalTrigTowerDetId &id) const
static constexpr uint32_t kHcalPhiMask2
Definition: HcalDetId.h:15
std::unique_ptr< HcalGains > produceGains(const HcalGainsRcd &rcd)
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
void useHBUpgrade(bool b)
HcalHardcodeCalibrations(const edm::ParameterSet &)
std::unique_ptr< HcalPedestalWidths > produceEffectivePedestalWidths(const HcalPedestalWidthsRcd &rcd)
std::unique_ptr< HcalPFCorrs > producePFCorrs(const HcalPFCorrsRcd &rcd)
std::unique_ptr< HcalQIEData > produceQIEData(const HcalQIEDataRcd &rcd)
HcalRecoParam makeRecoParam(HcalGenericDetId fId) const
void setHBUpgrade(HcalHardcodeParameters p)
def all(container)
workaround iterator generators for ROOT classes
Definition: cmstools.py:25
std::string fullPath() const
Definition: FileInPath.cc:161
void testHEPlan1(bool b)
std::unique_ptr< HcalTimeCorrs > produceTimeCorrs(const HcalTimeCorrsRcd &rcd)
void useHFUpgrade(bool b)
std::unique_ptr< HcalLongRecoParams > produceLongRecoParams(const HcalLongRecoParamsRcd &rcd)
constexpr int ietaAbs() const
get the absolute value of the cell ieta
Definition: HcalDetId.h:148
std::unique_ptr< HcalPedestals > produceEffectivePedestals(const HcalPedestalsRcd &rcd)
std::unique_ptr< HcalSiPMCharacteristics > produceSiPMCharacteristics(const HcalSiPMCharacteristicsRcd &rcd)
bool valid(const DetId &id) const override
bool exists(std::string const &parameterName) const
checks if a parameter exists
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > hbDarkeningToken_
std::unique_ptr< HcalElectronicsMap > produceElectronicsMap(const HcalElectronicsMapRcd &rcd)
void setHF(HcalHardcodeParameters p)
static const IOVSyncValue & endOfTime()
Definition: IOVSyncValue.cc:82
void makeHardcodeFrontEndMap(HcalFrontEndMap &emap, const std::vector< HcalGenericDetId > &cells) const
std::pair< Time_t, Time_t > ValidityInterval
Definition: Time.h:17
std::unique_ptr< HcalDcsValues > produceDcsValues(const HcalDcsRcd &rcd)
static const int kHcalEtaMask
void setIntervalFor(const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &) override
HcalZSThreshold makeZSThreshold(HcalGenericDetId fId) const
std::unique_ptr< HcalPedestalWidths > producePedestalWidths_(const HcalPedestalWidthsRcd &rcd, const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &, bool eff)
T getUntrackedParameter(std::string const &, T const &) const
std::unique_ptr< HcalPedestalWidths > producePedestalWidths(const HcalPedestalWidthsRcd &rcd)
const bool killHE() const
std::unique_ptr< HcalPedestals > producePedestals_(const HcalPedestalsRcd &rcd, const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &, bool eff)
std::unique_ptr< HcalSiPMCharacteristics > makeHardcodeSiPMCharacteristics() const
HcalGainWidth makeGainWidth(HcalGenericDetId fId) const
void addDefault(ParameterSetDescription const &psetDescription)
std::unique_ptr< HFRecalibration > hf_recalibration
std::unique_ptr< HcalRespCorrs > produceRespCorrs(const HcalRespCorrsRcd &rcd)
dictionary corr
std::unique_ptr< HcalLutMetadata > produceLutMetadata(const HcalLutMetadataRcd &rcd)
void setHO(HcalHardcodeParameters p)
static const IOVSyncValue & beginOfTime()
Definition: IOVSyncValue.cc:88
constexpr int ieta() const
get the cell ieta
Definition: HcalDetId.h:155
bool empty() const
Definition: ParameterSet.h:201
void setHFUpgrade(HcalHardcodeParameters p)
HcalTimingParam makeTimingParam(HcalGenericDetId fId) const
void setHE(HcalHardcodeParameters p)
void setKillHE(bool b)
HcalTPChannelParameter makeHardcodeTPChannelParameter(HcalGenericDetId fId) const
std::unique_ptr< HcalFlagHFDigiTimeParams > produceFlagHFDigiTimeParams(const HcalFlagHFDigiTimeParamsRcd &rcd)
HcalQIECoder makeQIECoder(HcalGenericDetId fId) const
std::unique_ptr< HcalFrontEndMap > produceFrontEndMap(const HcalFrontEndMapRcd &rcd)
int maxDepth(void) const
HcalSubdetector
Definition: HcalAssistant.h:31
std::unique_ptr< HBHERecalibration > hb_recalibration
static const int kHcalDepthMask
ParameterDescriptionBase * add(U const &iLabel, T const &value)
void useHOUpgrade(bool b)
std::unique_ptr< HcalSiPMParameters > produceSiPMParameters(const HcalSiPMParametersRcd &rcd)
std::unique_ptr< HBHERecalibration > he_recalibration
std::unique_ptr< HcalDcsMap > makeHardcodeDcsMap() const
static constexpr uint32_t kHcalEtaMask2
Definition: HcalDetId.h:19
HcalQIEType makeQIEType(HcalGenericDetId fId) const
virtual bool valid(const HcalZDCDetId &id) const
Definition: ZdcTopology.cc:28
static const int kHcalPhiMask
Namespace of DDCMS conversion namespace.
std::unique_ptr< HcalRecoParams > produceRecoParams(const HcalRecoParamsRcd &rcd)
void setHB(HcalHardcodeParameters p)
Log< level::Info, false > LogInfo
std::unique_ptr< HcalTPParameters > produceTPParameters(const HcalTPParametersRcd &rcd)
HcalGain makeGain(HcalGenericDetId fId, bool fSmear=false) const
TimeValue_t value() const
Definition: Timestamp.h:38
void makeHardcodeTPParameters(HcalTPParameters &tppar) const
std::unique_ptr< HcalGainWidths > produceGainWidths(const HcalGainWidthsRcd &rcd)
std::unique_ptr< HcalTPChannelParameters > produceTPChannelParameters(const HcalTPChannelParametersRcd &rcd)
std::unique_ptr< HcalElectronicsMap > makeHardcodeMap(const std::vector< HcalGenericDetId > &cells) const
std::unique_ptr< HcalL1TriggerObjects > produceL1TriggerObjects(const HcalL1TriggerObjectsRcd &rcd)
std::unique_ptr< HcalZSThresholds > produceZSThresholds(const HcalZSThresholdsRcd &rcd)
std::unique_ptr< HcalZDCLowGainFractions > produceZDCLowGainFractions(const HcalZDCLowGainFractionsRcd &rcd)
void setSiPMCharacteristics(std::vector< edm::ParameterSet > vps)
std::unique_ptr< HcalMCParams > produceMCParams(const HcalMCParamsRcd &rcd)
const EventID & eventID() const
Definition: IOVSyncValue.h:40
void useHEUpgrade(bool b)
std::unique_ptr< HcalTimingParams > produceTimingParams(const HcalTimingParamsRcd &rcd)
std::unique_ptr< HcalQIETypes > produceQIETypes(const HcalQIETypesRcd &rcd)
HcalMCParam makeMCParam(HcalGenericDetId fId) const
const Timestamp & time() const
Definition: IOVSyncValue.h:42
int getLayersInDepth(int ieta, int depth, const HcalTopology *topo)
std::unique_ptr< HcalChannelQuality > produceChannelQuality(const HcalChannelQualityRcd &rcd)
HcalPedestal makePedestal(HcalGenericDetId fId, bool fSmear, bool eff, const HcalTopology *topo, double intlumi)
HcalPFCut makePFCut(HcalGenericDetId fId) const
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > heDarkeningToken_
HcalSiPMParameter makeHardcodeSiPMParameter(HcalGenericDetId fId, const HcalTopology *topo, double intlumi)
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
void setHEUpgrade(HcalHardcodeParameters p)
std::unique_ptr< HcalDcsMap > produceDcsMap(const HcalDcsMapRcd &rcd)
constexpr int iphi() const
get the cell iphi
Definition: HcalDetId.h:157
std::unique_ptr< HcalLUTCorrs > produceLUTCorrs(const HcalLUTCorrsRcd &rcd)
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_
void testHFQIE10(bool b)
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
HcalPedestalWidth makePedestalWidth(HcalGenericDetId fId, bool eff, const HcalTopology *topo, double intlumi)
std::unique_ptr< HcalValidationCorrs > produceValidationCorrs(const HcalValidationCorrsRcd &rcd)
constexpr int depth() const
get the tower depth
Definition: HcalDetId.h:164