File indexing completed on 2021-02-14 12:47:13
0001
0002
0003
0004 #include <vector>
0005 #include <string>
0006 #include <cmath>
0007 #include <sstream>
0008 #include <iostream>
0009 #include <memory>
0010 #include <cassert>
0011
0012 #include "CLHEP/Random/RandGauss.h"
0013 #include "CalibCalorimetry/HcalAlgos/interface/HcalDbHardcode.h"
0014 #include "CalibFormats/HcalObjects/interface/HcalSiPMType.h"
0015 #include "DataFormats/HcalDigi/interface/HcalQIENum.h"
0016 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0017
0018 HcalDbHardcode::HcalDbHardcode()
0019 :
0020 theDefaultParameters_(3.0,
0021 0.5,
0022 {0.2, 0.2},
0023 {0.0, 0.0},
0024 0,
0025 0,
0026 {0.0, 0.0, 0.0, 0.0},
0027 {0.9, 0.9, 0.9, 0.9},
0028 125,
0029 105,
0030 0.0,
0031 {0.0},
0032 {0.0}
0033 ),
0034 setHB_(false),
0035 setHE_(false),
0036 setHF_(false),
0037 setHO_(false),
0038 setHBUpgrade_(false),
0039 setHEUpgrade_(false),
0040 setHFUpgrade_(false),
0041 useHBUpgrade_(false),
0042 useHEUpgrade_(false),
0043 useHOUpgrade_(true),
0044 useHFUpgrade_(false),
0045 testHFQIE10_(false),
0046 testHEPlan1_(false) {}
0047
0048 const HcalHardcodeParameters& HcalDbHardcode::getParameters(HcalGenericDetId fId) const {
0049 if (fId.genericSubdet() == HcalGenericDetId::HcalGenBarrel) {
0050 if (useHBUpgrade_ && setHBUpgrade_)
0051 return theHBUpgradeParameters_;
0052 else if (!useHBUpgrade_ && setHB_)
0053 return theHBParameters_;
0054 else
0055 return theDefaultParameters_;
0056 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenEndcap) {
0057 bool b_isHEPlan1 = testHEPlan1_ ? isHEPlan1(fId) : false;
0058 if ((useHEUpgrade_ || b_isHEPlan1) && setHEUpgrade_)
0059 return theHEUpgradeParameters_;
0060 else if (!useHEUpgrade_ && !b_isHEPlan1 && setHE_)
0061 return theHEParameters_;
0062 else
0063 return theDefaultParameters_;
0064 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenForward) {
0065 if (useHFUpgrade_ && setHFUpgrade_)
0066 return theHFUpgradeParameters_;
0067 else if (testHFQIE10_ && fId.isHcalDetId()) {
0068 HcalDetId hid(fId);
0069
0070 if (hid.iphi() == 39 && hid.zside() == 1 &&
0071 (hid.depth() >= 3 || (hid.depth() == 2 && (hid.ieta() == 30 || hid.ieta() == 34))) && setHFUpgrade_)
0072 return theHFUpgradeParameters_;
0073 else if (setHF_)
0074 return theHFParameters_;
0075 else
0076 return theDefaultParameters_;
0077 } else if (!useHFUpgrade_ && setHF_)
0078 return theHFParameters_;
0079 else
0080 return theDefaultParameters_;
0081 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenOuter) {
0082 if (setHO_)
0083 return theHOParameters_;
0084 else
0085 return theDefaultParameters_;
0086 } else
0087 return theDefaultParameters_;
0088 }
0089
0090 const int HcalDbHardcode::getGainIndex(HcalGenericDetId fId) const {
0091 int index = 0;
0092 if (fId.genericSubdet() == HcalGenericDetId::HcalGenOuter) {
0093 HcalDetId hid(fId);
0094 if ((hid.ieta() > -5) && (hid.ieta() < 5))
0095 index = 0;
0096 else
0097 index = 1;
0098 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenForward) {
0099 HcalDetId hid(fId);
0100 if (hid.depth() % 2 == 1)
0101 index = 0;
0102 else if (hid.depth() % 2 == 0)
0103 index = 1;
0104 }
0105 return index;
0106 }
0107
0108 HcalPedestal HcalDbHardcode::makePedestal(
0109 HcalGenericDetId fId, bool fSmear, bool eff, const HcalTopology* topo, double intlumi) {
0110 HcalPedestalWidth width = makePedestalWidth(fId, eff, topo, intlumi);
0111 float value0 = getParameters(fId).pedestal();
0112 if (eff) {
0113
0114 auto sipmpar = makeHardcodeSiPMParameter(fId, topo, intlumi);
0115 auto sipmchar = makeHardcodeSiPMCharacteristics();
0116 value0 += sipmpar.getDarkCurrent() * 25. / (1. - sipmchar->getCrossTalk(sipmpar.getType()));
0117 }
0118 float value[4] = {value0, value0, value0, value0};
0119 if (fSmear) {
0120 for (int i = 0; i < 4; i++) {
0121 value[i] = 0.0f;
0122 while (value[i] <= 0.0f)
0123
0124 value[i] = value0 + (float)CLHEP::RandGauss::shoot(0.0, width.getWidth(i) / 100.);
0125 }
0126 }
0127 HcalPedestal result(fId.rawId(), value[0], value[1], value[2], value[3]);
0128 return result;
0129 }
0130
0131 HcalPedestalWidth HcalDbHardcode::makePedestalWidth(HcalGenericDetId fId,
0132 bool eff,
0133 const HcalTopology* topo,
0134 double intlumi) {
0135 float value = getParameters(fId).pedestalWidth();
0136 float width2 = value * value;
0137
0138
0139 if (eff) {
0140
0141 auto sipmpar = makeHardcodeSiPMParameter(fId, topo, intlumi);
0142 auto sipmchar = makeHardcodeSiPMCharacteristics();
0143
0144 width2 += sipmpar.getDarkCurrent() * 25. / std::pow(1 - sipmchar->getCrossTalk(sipmpar.getType()), 3) *
0145 sipmpar.getFCByPE();
0146 }
0147
0148 HcalPedestalWidth result(fId.rawId());
0149 for (int i = 0; i < 4; i++) {
0150 for (int j = 0; j < 4; j++) {
0151 result.setSigma(i, j, 0.0);
0152 }
0153 result.setSigma(i, i, width2);
0154 }
0155 return result;
0156 }
0157
0158 HcalGain HcalDbHardcode::makeGain(HcalGenericDetId fId, bool fSmear) const {
0159 HcalGainWidth width = makeGainWidth(fId);
0160 float value0 = getParameters(fId).gain(getGainIndex(fId));
0161 float value[4] = {value0, value0, value0, value0};
0162 if (fSmear) {
0163 for (int i = 0; i < 4; i++) {
0164 value[i] = 0.0f;
0165 while (value[i] <= 0.0f)
0166 value[i] = value0 + (float)CLHEP::RandGauss::shoot(0.0, width.getValue(i));
0167 }
0168 }
0169 HcalGain result(fId.rawId(), value[0], value[1], value[2], value[3]);
0170 return result;
0171 }
0172
0173 HcalGainWidth HcalDbHardcode::makeGainWidth(HcalGenericDetId fId) const {
0174 float value = getParameters(fId).gainWidth(getGainIndex(fId));
0175 HcalGainWidth result(fId.rawId(), value, value, value, value);
0176 return result;
0177 }
0178
0179 HcalZSThreshold HcalDbHardcode::makeZSThreshold(HcalGenericDetId fId) const {
0180 int value = getParameters(fId).zsThreshold();
0181 HcalZSThreshold result(fId.rawId(), value);
0182 return result;
0183 }
0184
0185 HcalQIECoder HcalDbHardcode::makeQIECoder(HcalGenericDetId fId) const {
0186 HcalQIECoder result(fId.rawId());
0187
0188 const HcalHardcodeParameters& param(getParameters(fId));
0189 for (unsigned range = 0; range < 4; range++) {
0190 for (unsigned capid = 0; capid < 4; capid++) {
0191 result.setOffset(capid, range, param.qieOffset(range));
0192 result.setSlope(capid, range, param.qieSlope(range));
0193 }
0194 }
0195
0196 return result;
0197 }
0198
0199 HcalQIEType HcalDbHardcode::makeQIEType(HcalGenericDetId fId) const {
0200 HcalQIENum qieType = (HcalQIENum)(getParameters(fId).qieType());
0201 HcalQIEType result(fId.rawId(), qieType);
0202 return result;
0203 }
0204
0205 HcalCalibrationQIECoder HcalDbHardcode::makeCalibrationQIECoder(HcalGenericDetId fId) const {
0206 HcalCalibrationQIECoder result(fId.rawId());
0207 float lowEdges[64];
0208 for (int i = 0; i < 64; i++) {
0209 lowEdges[i] = -1.5 + i;
0210 }
0211 result.setMinCharges(lowEdges);
0212 return result;
0213 }
0214
0215 HcalQIEShape HcalDbHardcode::makeQIEShape() const { return HcalQIEShape(); }
0216
0217 HcalMCParam HcalDbHardcode::makeMCParam(HcalGenericDetId fId) const {
0218 int r1bit[5];
0219 r1bit[0] = 9;
0220 int syncPhase = 0;
0221 r1bit[1] = 1;
0222 int binOfMaximum = 0;
0223 r1bit[2] = 4;
0224 float phase = -25.0f;
0225 float Xphase = (phase + 32.0f) * 4.0f;
0226
0227 int Iphase = Xphase;
0228 r1bit[3] = 8;
0229 int timeSmearing = 0;
0230 r1bit[4] = 1;
0231
0232 const HcalHardcodeParameters& hparam(getParameters(fId));
0233 int pulseShapeID = hparam.mcShape();
0234
0235 if (fId.genericSubdet() == HcalGenericDetId::HcalGenBarrel) {
0236 syncPhase = 1;
0237 binOfMaximum = 5;
0238 phase = 5.0f;
0239 Xphase = (phase + 32.0f) * 4.0f;
0240
0241 Iphase = Xphase;
0242 timeSmearing = 1;
0243
0244 }
0245
0246 else if (fId.genericSubdet() == HcalGenericDetId::HcalGenEndcap) {
0247 syncPhase = 1;
0248 binOfMaximum = 5;
0249 phase = 5.0f;
0250 Xphase = (phase + 32.0f) * 4.0f;
0251
0252 Iphase = Xphase;
0253 timeSmearing = 1;
0254
0255 }
0256
0257 else if (fId.genericSubdet() == HcalGenericDetId::HcalGenOuter) {
0258 syncPhase = 1;
0259 binOfMaximum = 5;
0260 phase = 5.0f;
0261 Xphase = (phase + 32.0f) * 4.0f;
0262
0263 Iphase = Xphase;
0264 timeSmearing = 0;
0265
0266 HcalDetId cell = HcalDetId(fId);
0267 if (cell.ieta() == 1 && cell.iphi() == 1)
0268 pulseShapeID = 125;
0269
0270 }
0271
0272 else if (fId.genericSubdet() == HcalGenericDetId::HcalGenForward) {
0273 syncPhase = 1;
0274 binOfMaximum = 3;
0275 phase = 14.0f;
0276 Xphase = (phase + 32.0f) * 4.0f;
0277
0278 Iphase = Xphase;
0279 timeSmearing = 0;
0280
0281 }
0282
0283 else if (fId.genericSubdet() == HcalGenericDetId::HcalGenZDC) {
0284 pulseShapeID = 401;
0285 syncPhase = 1;
0286 binOfMaximum = 5;
0287 phase = -4.0f;
0288 Xphase = (phase + 32.0f) * 4.0f;
0289
0290 Iphase = Xphase;
0291 timeSmearing = 0;
0292 }
0293
0294 int rshift[7];
0295 rshift[0] = 0;
0296 for (int k = 0; k < 5; k++) {
0297 rshift[k + 1] = rshift[k] + r1bit[k];
0298 }
0299
0300 int packingScheme = 1;
0301 unsigned int param = pulseShapeID | syncPhase << rshift[1] | (binOfMaximum << rshift[2]) | (Iphase << rshift[3]) |
0302 (timeSmearing << rshift[4] | packingScheme << 27);
0303
0304 HcalMCParam result(fId.rawId(), param);
0305 return result;
0306 }
0307
0308 HcalRecoParam HcalDbHardcode::makeRecoParam(HcalGenericDetId fId) const {
0309
0310 int p1bit[6];
0311
0312
0313 int containmentCorrectionFlag = 0;
0314 p1bit[0] = 1;
0315 int containmentCorrectionPreSample = 0;
0316 p1bit[1] = 1;
0317 float phase = 13.0;
0318 float Xphase = (phase + 32.0) * 4.0;
0319
0320 int Iphase = Xphase;
0321 p1bit[2] = 8;
0322
0323 int firstSample = 4;
0324 p1bit[3] = 4;
0325 int samplesToAdd = 2;
0326 p1bit[4] = 4;
0327 p1bit[5] = 9;
0328
0329 const HcalHardcodeParameters& hparam(getParameters(fId));
0330 int pulseShapeID = hparam.recoShape();
0331
0332 int q2bit[10];
0333
0334 int useLeakCorrection = 0;
0335 q2bit[0] = 1;
0336 int LeakCorrectionID = 0;
0337 q2bit[1] = 4;
0338 int correctForTimeslew = 0;
0339 q2bit[2] = 1;
0340 int timeCorrectionID = 0;
0341 q2bit[3] = 4;
0342 int correctTiming = 0;
0343 q2bit[4] = 1;
0344 int firstAuxTS = 0;
0345 q2bit[5] = 4;
0346 int specialCaseID = 0;
0347 q2bit[6] = 4;
0348 int noiseFlaggingID = 0;
0349 q2bit[7] = 4;
0350 int pileupCleaningID = 0;
0351 q2bit[8] = 4;
0352 int packingScheme = 1;
0353 q2bit[9] = 4;
0354
0355 if ((fId.genericSubdet() == HcalGenericDetId::HcalGenBarrel) ||
0356 (fId.genericSubdet() == HcalGenericDetId::HcalGenEndcap)) {
0357
0358 containmentCorrectionFlag = 1;
0359 containmentCorrectionPreSample = 0;
0360 float phase = 6.0;
0361 float Xphase = (phase + 32.0) * 4.0;
0362
0363 Iphase = Xphase;
0364 firstSample = 4;
0365 samplesToAdd = 2;
0366
0367
0368 useLeakCorrection = 0;
0369 LeakCorrectionID = 0;
0370 correctForTimeslew = 1;
0371 timeCorrectionID = 0;
0372 correctTiming = 1;
0373 firstAuxTS = 4;
0374 specialCaseID = 0;
0375 noiseFlaggingID = 1;
0376 pileupCleaningID = 0;
0377 }
0378
0379 else if (fId.genericSubdet() == HcalGenericDetId::HcalGenOuter) {
0380
0381 containmentCorrectionFlag = 1;
0382 containmentCorrectionPreSample = 0;
0383 float phase = 13.0;
0384 float Xphase = (phase + 32.0) * 4.0;
0385
0386 Iphase = Xphase;
0387 firstSample = 4;
0388 samplesToAdd = 4;
0389
0390
0391 useLeakCorrection = 0;
0392 LeakCorrectionID = 0;
0393 correctForTimeslew = 1;
0394 timeCorrectionID = 0;
0395 correctTiming = 1;
0396 firstAuxTS = 4;
0397 specialCaseID = 0;
0398 noiseFlaggingID = 1;
0399 pileupCleaningID = 0;
0400
0401 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenForward) {
0402
0403 containmentCorrectionFlag = 0;
0404 containmentCorrectionPreSample = 0;
0405 float phase = 13.0;
0406 float Xphase = (phase + 32.0) * 4.0;
0407
0408 Iphase = Xphase;
0409 firstSample = 2;
0410 samplesToAdd = 1;
0411
0412
0413 useLeakCorrection = 0;
0414 LeakCorrectionID = 0;
0415 correctForTimeslew = 0;
0416 timeCorrectionID = 0;
0417 correctTiming = 1;
0418 firstAuxTS = 1;
0419 specialCaseID = 0;
0420 noiseFlaggingID = 1;
0421 pileupCleaningID = 0;
0422 }
0423
0424
0425
0426 int p1shift[7];
0427 p1shift[0] = 0;
0428 for (int k = 0; k < 6; k++) {
0429 int j = k + 1;
0430 p1shift[j] = p1shift[k] + p1bit[k];
0431
0432 }
0433 int param1 = 0;
0434 param1 = containmentCorrectionFlag | (containmentCorrectionPreSample << p1shift[1]) | (Iphase << p1shift[2]) |
0435 (firstSample << p1shift[3]) | (samplesToAdd << p1shift[4]) | (pulseShapeID << p1shift[5]);
0436
0437 int q2shift[10];
0438 q2shift[0] = 0;
0439 for (int k = 0; k < 9; k++) {
0440 int j = k + 1;
0441 q2shift[j] = q2shift[k] + q2bit[k];
0442
0443 }
0444 int param2 = 0;
0445 param2 = useLeakCorrection | (LeakCorrectionID << q2shift[1]) | (correctForTimeslew << q2shift[2]) |
0446 (timeCorrectionID << q2shift[3]) | (correctTiming << q2shift[4]) | (firstAuxTS << q2shift[5]) |
0447 (specialCaseID << q2shift[6]) | (noiseFlaggingID << q2shift[7]) | (pileupCleaningID << q2shift[8]) |
0448 (packingScheme << q2shift[9]);
0449
0450 HcalRecoParam result(fId.rawId(), param1, param2);
0451
0452 return result;
0453 }
0454
0455 HcalTimingParam HcalDbHardcode::makeTimingParam(HcalGenericDetId fId) const {
0456 int nhits = 0;
0457 float phase = 0.0;
0458 float rms = 0.0;
0459 if (fId.genericSubdet() == HcalGenericDetId::HcalGenBarrel) {
0460 nhits = 4;
0461 phase = 4.5;
0462 rms = 6.5;
0463 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenEndcap) {
0464 nhits = 4;
0465 phase = 9.3;
0466 rms = 7.8;
0467 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenOuter) {
0468 nhits = 4;
0469 phase = 8.6;
0470 rms = 2.3;
0471 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenForward) {
0472 nhits = 4;
0473 phase = 12.4;
0474 rms = 12.29;
0475 }
0476 HcalTimingParam result(fId.rawId(), nhits, phase, rms);
0477
0478 return result;
0479 }
0480
0481 #define EMAP_NHBHECR 9
0482 #define EMAP_NHFCR 3
0483 #define EMAP_NHOCR 4
0484 #define EMAP_NFBR 8
0485 #define EMAP_NFCH 3
0486 #define EMAP_NHTRS 3
0487 #define EMAP_NHSETS 4
0488 #define EMAP_NTOPBOT 2
0489 #define EMAP_NHTRSHO 4
0490 #define EMAP_NHSETSHO 3
0491
0492 std::unique_ptr<HcalDcsMap> HcalDbHardcode::makeHardcodeDcsMap() const {
0493 HcalDcsMapAddons::Helper dcs_map_helper;
0494 dcs_map_helper.mapGeomId2DcsId(HcalDetId(HcalBarrel, -16, 1, 1),
0495 HcalDcsDetId(HcalDcsBarrel, -1, 1, HcalDcsDetId::HV, 2));
0496 dcs_map_helper.mapGeomId2DcsId(HcalDetId(HcalForward, -41, 3, 1),
0497 HcalDcsDetId(HcalDcsForward, -1, 1, HcalDcsDetId::DYN8, 1));
0498 dcs_map_helper.mapGeomId2DcsId(HcalDetId(HcalForward, -26, 25, 2),
0499 HcalDcsDetId(HcalDcsForward, -1, 7, HcalDcsDetId::HV, 1));
0500 dcs_map_helper.mapGeomId2DcsId(HcalDetId(HcalBarrel, -15, 68, 1),
0501 HcalDcsDetId(HcalDcsBarrel, -1, 18, HcalDcsDetId::HV, 3));
0502 dcs_map_helper.mapGeomId2DcsId(HcalDetId(HcalOuter, -14, 1, 4),
0503 HcalDcsDetId(HcalDcsOuter, -2, 2, HcalDcsDetId::HV, 4));
0504 dcs_map_helper.mapGeomId2DcsId(HcalDetId(HcalForward, 41, 71, 2),
0505 HcalDcsDetId(HcalDcsForward, 1, 4, HcalDcsDetId::DYN8, 3));
0506 return std::make_unique<HcalDcsMap>(dcs_map_helper);
0507 }
0508
0509 std::unique_ptr<HcalElectronicsMap> HcalDbHardcode::makeHardcodeMap(const std::vector<HcalGenericDetId>& cells) const {
0510 static const int kUTCAMask = 0x4000000;
0511 static const int kLinearIndexMax = 0x7FFFF;
0512 static const int kTriggerBitMask = 0x02000000;
0513 uint32_t counter = 0;
0514 uint32_t counterTrig = 0;
0515 HcalElectronicsMapAddons::Helper emapHelper;
0516 for (const auto& fId : cells) {
0517 if (fId.genericSubdet() == HcalGenericDetId::HcalGenBarrel ||
0518 fId.genericSubdet() == HcalGenericDetId::HcalGenEndcap ||
0519 fId.genericSubdet() == HcalGenericDetId::HcalGenForward ||
0520 fId.genericSubdet() == HcalGenericDetId::HcalGenOuter || fId.genericSubdet() == HcalGenericDetId::HcalGenZDC) {
0521 ++counter;
0522 assert(counter < kLinearIndexMax);
0523 uint32_t raw = counter;
0524 raw |= kUTCAMask;
0525 HcalElectronicsId elId(raw);
0526 emapHelper.mapEId2chId(elId, fId);
0527 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenTriggerTower) {
0528 ++counterTrig;
0529 assert(counterTrig < kLinearIndexMax);
0530 uint32_t raw = counterTrig;
0531 raw |= kUTCAMask | kTriggerBitMask;
0532 HcalElectronicsId elId(raw);
0533 emapHelper.mapEId2tId(elId, fId);
0534 }
0535 }
0536 return std::make_unique<HcalElectronicsMap>(emapHelper);
0537 }
0538
0539 std::unique_ptr<HcalFrontEndMap> HcalDbHardcode::makeHardcodeFrontEndMap(
0540 const std::vector<HcalGenericDetId>& cells) const {
0541 HcalFrontEndMapAddons::Helper emapHelper;
0542 std::stringstream mystream;
0543 std::string detector[5] = {"XX", "HB", "HE", "HO", "HF"};
0544 for (const auto& fId : cells) {
0545 if (fId.isHcalDetId()) {
0546 HcalDetId id = HcalDetId(fId.rawId());
0547 HcalSubdetector subdet = id.subdet();
0548 int ieta = id.ietaAbs();
0549 int iside = id.zside();
0550 int iphi = id.iphi();
0551 std::string det, rbx;
0552 int irm(0);
0553 char tempbuff[30];
0554 char sidesign = (iside == -1) ? 'M' : 'P';
0555 if (subdet == HcalBarrel || subdet == HcalEndcap) {
0556 det = detector[subdet];
0557 irm = (iphi + 1) % 4 + 1;
0558 int iwedge(0);
0559 if (ieta >= 21 && (irm == 1 || irm == 3))
0560 iwedge = (iphi + 1 + irm + 1) / 4;
0561 else
0562 iwedge = (iphi + irm + 1) / 4;
0563 if (iwedge > 18)
0564 iwedge -= 18;
0565 sprintf(tempbuff, "%s%c%2.2i%c", det.c_str(), sidesign, iwedge, '\0');
0566 mystream << tempbuff;
0567 rbx = mystream.str();
0568 mystream.str("");
0569 emapHelper.loadObject(id, irm, rbx);
0570 } else if (subdet == HcalForward) {
0571 det = detector[subdet];
0572 int hfphi(0);
0573 if ((iside == 1 && ieta == 40) || (iside == -1 && ieta == 41)) {
0574 irm = ((iphi + 1) / 2) % 36 + 1;
0575 hfphi = ((iphi + 1) / 6) % 12 + 1;
0576 } else {
0577 irm = (iphi + 1) / 2;
0578 hfphi = (iphi - 1) / 6 + 1;
0579 }
0580 irm = (irm - 1) % 3 + 1;
0581 sprintf(tempbuff, "%s%c%2.2i%c", det.c_str(), sidesign, hfphi, '\0');
0582 mystream << tempbuff;
0583 rbx = mystream.str();
0584 mystream.str("");
0585 emapHelper.loadObject(id, irm, rbx);
0586 } else if (subdet == HcalOuter) {
0587 det = detector[subdet];
0588 int ring(0), sector(0);
0589 if (ieta <= 4)
0590 ring = 0;
0591 else if (ieta >= 5 && ieta <= 10)
0592 ring = 1;
0593 else
0594 ring = 2;
0595 for (int i = -2; i < iphi; i += 6)
0596 sector++;
0597 if (sector > 12)
0598 sector = 1;
0599 irm = ((iphi + 1) / 2) % 6 + 1;
0600 if (ring != 0 && sector % 2 != 0)
0601 sector++;
0602 if (ring == 0)
0603 sprintf(tempbuff, "%s%i%2.2d", det.c_str(), ring, sector);
0604 else
0605 sprintf(tempbuff, "%s%i%c%2.2d", det.c_str(), ring, sidesign, sector);
0606 mystream << tempbuff;
0607 rbx = mystream.str();
0608 mystream.str("");
0609 emapHelper.loadObject(id, irm, rbx);
0610 }
0611 }
0612 }
0613 return std::make_unique<HcalFrontEndMap>(emapHelper);
0614 }
0615
0616 int HcalDbHardcode::getLayersInDepth(int ieta, int depth, const HcalTopology* topo) {
0617
0618 auto eta_depth_pair = std::make_pair(ieta, depth);
0619 auto nLayers = theLayersInDepths_.find(eta_depth_pair);
0620 if (nLayers != theLayersInDepths_.end()) {
0621 return nLayers->second;
0622 } else {
0623 std::vector<int> segmentation;
0624 topo->getDepthSegmentation(ieta, segmentation);
0625
0626 int nLayersInDepth = std::distance(std::lower_bound(segmentation.begin(), segmentation.end(), depth),
0627 std::upper_bound(segmentation.begin(), segmentation.end(), depth));
0628 theLayersInDepths_.insert(std::make_pair(eta_depth_pair, nLayersInDepth));
0629 return nLayersInDepth;
0630 }
0631 }
0632
0633 bool HcalDbHardcode::isHEPlan1(HcalGenericDetId fId) const {
0634 if (fId.isHcalDetId()) {
0635 HcalDetId hid(fId);
0636
0637 if (hid.zside() == 1 && (hid.iphi() == 63 || hid.iphi() == 64 || hid.iphi() == 65 || hid.iphi() == 66))
0638 return true;
0639 }
0640 return false;
0641 }
0642
0643 HcalSiPMParameter HcalDbHardcode::makeHardcodeSiPMParameter(HcalGenericDetId fId,
0644 const HcalTopology* topo,
0645 double intlumi) {
0646
0647
0648
0649
0650
0651 HcalSiPMType theType = HcalNoSiPM;
0652 double thePe2fC = getParameters(fId).photoelectronsToAnalog();
0653 double theDC = getParameters(fId).darkCurrent(0, intlumi);
0654 double theNoiseCN = getParameters(fId).noiseCorrelation(0);
0655 if (fId.genericSubdet() == HcalGenericDetId::HcalGenBarrel) {
0656 if (useHBUpgrade_) {
0657 HcalDetId hid(fId);
0658 int nLayersInDepth = getLayersInDepth(hid.ietaAbs(), hid.depth(), topo);
0659 if (nLayersInDepth > 4) {
0660 theType = HcalHBHamamatsu2;
0661 theDC = getParameters(fId).darkCurrent(1, intlumi);
0662 theNoiseCN = getParameters(fId).noiseCorrelation(1);
0663 } else {
0664 theType = HcalHBHamamatsu1;
0665 theDC = getParameters(fId).darkCurrent(0, intlumi);
0666 theNoiseCN = getParameters(fId).noiseCorrelation(0);
0667 }
0668 } else
0669 theType = HcalHPD;
0670 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenEndcap) {
0671 if (useHEUpgrade_ || (testHEPlan1_ && isHEPlan1(fId))) {
0672 HcalDetId hid(fId);
0673 int nLayersInDepth = getLayersInDepth(hid.ietaAbs(), hid.depth(), topo);
0674 if (nLayersInDepth > 4) {
0675 theType = HcalHEHamamatsu2;
0676 theDC = getParameters(fId).darkCurrent(1, intlumi);
0677 theNoiseCN = getParameters(fId).noiseCorrelation(1);
0678 } else {
0679 theType = HcalHEHamamatsu1;
0680 theDC = getParameters(fId).darkCurrent(0, intlumi);
0681 theNoiseCN = getParameters(fId).noiseCorrelation(0);
0682 }
0683 } else
0684 theType = HcalHPD;
0685 } else if (fId.genericSubdet() == HcalGenericDetId::HcalGenOuter) {
0686 if (useHOUpgrade_)
0687 theType = HcalHOHamamatsu;
0688 else
0689 theType = HcalHPD;
0690 }
0691
0692 return HcalSiPMParameter(fId.rawId(), theType, thePe2fC, theDC, 0, (float)theNoiseCN);
0693 }
0694
0695 std::unique_ptr<HcalSiPMCharacteristics> HcalDbHardcode::makeHardcodeSiPMCharacteristics() const {
0696
0697
0698
0699
0700 HcalSiPMCharacteristicsAddons::Helper sipmHelper;
0701 for (unsigned ip = 0; ip < theSiPMCharacteristics_.size(); ++ip) {
0702 auto& ps = theSiPMCharacteristics_[ip];
0703 sipmHelper.loadObject(ip + 1,
0704 ps.getParameter<int>("pixels"),
0705 ps.getParameter<double>("nonlin1"),
0706 ps.getParameter<double>("nonlin2"),
0707 ps.getParameter<double>("nonlin3"),
0708 ps.getParameter<double>("crosstalk"),
0709 0,
0710 0);
0711 }
0712 return std::make_unique<HcalSiPMCharacteristics>(sipmHelper);
0713 }
0714
0715 HcalTPChannelParameter HcalDbHardcode::makeHardcodeTPChannelParameter(HcalGenericDetId fId) const {
0716
0717
0718
0719 uint32_t bitInfo = ((44 << 16) | 30);
0720 return HcalTPChannelParameter(fId.rawId(), 0, bitInfo, 0, 0);
0721 }
0722
0723 void HcalDbHardcode::makeHardcodeTPParameters(HcalTPParameters& tppar) const {
0724
0725
0726
0727 tppar.loadObject(0, 0, 0xFFFFFFFFFFFFFFFF, 0, 0, 0);
0728 }