File indexing completed on 2025-05-20 22:25:17
0001 #include <iostream>
0002
0003 #include "CondFormats/L1TObjects/interface/CaloParams.h"
0004
0005 #include "CondFormats/L1TObjects/interface/L1CaloEtScale.h"
0006 #include "CondFormats/DataRecord/interface/L1EmEtScaleRcd.h"
0007 #include "CondFormats/DataRecord/interface/L1JetEtScaleRcd.h"
0008 #include "CondFormats/DataRecord/interface/L1HtMissScaleRcd.h"
0009 #include "CondFormats/DataRecord/interface/L1HfRingEtScaleRcd.h"
0010
0011 #ifndef CaloParamsHelperO2O_h
0012 #define CaloParamsHelperO2O_h
0013
0014 namespace l1t {
0015
0016 class CaloParamsHelperO2O : public CaloParams {
0017 public:
0018
0019
0020 enum {
0021 regionPUS = 0,
0022 egTrimming = 1,
0023 egMaxHOverE = 2,
0024 egCompressShapes = 3,
0025 egShapeId = 4,
0026 egCalibration = 5,
0027 egPUS = 6,
0028 egIsolation = 7,
0029 tauCalibration = 8,
0030 tauPUS = 9,
0031 tauIsolation = 10,
0032 jetPUS = 11,
0033 jetCalibration = 12,
0034 hiCentrality = 13,
0035 hiQ2 = 14,
0036 tauEtToHFRingEt = 15,
0037 tauCompress = 16,
0038 layer1ECal = 17,
0039 layer1HCal = 18,
0040 layer1HF = 19,
0041 jetCompressEta = 20,
0042 jetCompressPt = 21,
0043 metCalibration = 22,
0044 metHFCalibration = 23,
0045 etSumEttCalibration = 24,
0046 etSumEcalSumCalibration = 25,
0047 tauIsolation2 = 26,
0048 egBypassEGVetosFlag = 27,
0049 jetBypassPUSFlag = 28,
0050 egHOverEBarrel = 29,
0051 egHOverEEndcap = 30,
0052 etSumMetPUS = 31,
0053 etSumBypassMetPUSFlag = 32,
0054 egBypassExtHoE = 33,
0055 egIsolation2 = 34,
0056 etSumEttPUS = 35,
0057 etSumBypassEttPUSFlag = 36,
0058 etSumEcalSumPUS = 37,
0059 etSumBypassEcalSumPUSFlag = 38,
0060 layer1HOverE = 39,
0061 PUTowerThreshold = 40,
0062 tauTrimmingShapeVeto = 41,
0063 egBypassShapeFlag = 42,
0064 egBypassECALFGFlag = 43,
0065 egBypassHoEFlag = 44,
0066 etSumCentralityLower = 45,
0067 etSumCentralityUpper = 46,
0068 jetPUSUsePhiRingFlag = 47,
0069 metPhiCalibration = 48,
0070 metHFPhiCalibration = 49,
0071 layer1HCalFBUpper = 50,
0072 layer1HCalFBLower = 51,
0073 layer1ECalZS = 52,
0074 layer1HCalZS = 53,
0075 NUM_CALOPARAMNODES = 54
0076 };
0077
0078 CaloParamsHelperO2O() { pnode_.resize(NUM_CALOPARAMNODES); }
0079 CaloParamsHelperO2O(const CaloParams& p) : CaloParams(p) {
0080 if (pnode_.size() < NUM_CALOPARAMNODES) {
0081 pnode_.resize(NUM_CALOPARAMNODES);
0082
0083 }
0084 };
0085 ~CaloParamsHelperO2O() {}
0086
0087 bool isValidForStage1() { return true; }
0088 bool isValidForStage2() { return (version_ >= 2); }
0089
0090 L1CaloEtScale emScale() { return emScale_; }
0091 void setEmScale(L1CaloEtScale emScale) { emScale_ = emScale; }
0092 L1CaloEtScale jetScale() { return jetScale_; }
0093 void setJetScale(L1CaloEtScale jetScale) { jetScale_ = jetScale; }
0094 L1CaloEtScale HtMissScale() { return HtMissScale_; }
0095 L1CaloEtScale HfRingScale() { return HfRingScale_; }
0096 void setHtMissScale(L1CaloEtScale HtMissScale) { HtMissScale_ = HtMissScale; }
0097 void setHfRingScale(L1CaloEtScale HfRingScale) { HfRingScale_ = HfRingScale; }
0098
0099
0100 double towerLsbH() const { return towerp_.lsbH_; }
0101 double towerLsbE() const { return towerp_.lsbE_; }
0102 double towerLsbSum() const { return towerp_.lsbSum_; }
0103 int towerNBitsH() const { return towerp_.nBitsH_; }
0104 int towerNBitsE() const { return towerp_.nBitsE_; }
0105 int towerNBitsSum() const { return towerp_.nBitsSum_; }
0106 int towerNBitsRatio() const { return towerp_.nBitsRatio_; }
0107 int towerMaskE() const { return towerp_.maskE_; }
0108 int towerMaskH() const { return towerp_.maskH_; }
0109 int towerMaskSum() const { return towerp_.maskSum_; }
0110 int towerMaskRatio() const { return towerp_.maskRatio_; }
0111 bool doTowerEncoding() const { return towerp_.doEncoding_; }
0112
0113 void setTowerLsbH(double lsb) { towerp_.lsbH_ = lsb; }
0114 void setTowerLsbE(double lsb) { towerp_.lsbE_ = lsb; }
0115 void setTowerLsbSum(double lsb) { towerp_.lsbSum_ = lsb; }
0116 void setTowerNBitsH(int n) {
0117 towerp_.nBitsH_ = n;
0118 towerp_.maskH_ = std::pow(2, n) - 1;
0119 }
0120 void setTowerNBitsE(int n) {
0121 towerp_.nBitsE_ = n;
0122 towerp_.maskE_ = std::pow(2, n) - 1;
0123 }
0124 void setTowerNBitsSum(int n) {
0125 towerp_.nBitsSum_ = n;
0126 towerp_.maskSum_ = std::pow(2, n) - 1;
0127 }
0128 void setTowerNBitsRatio(int n) {
0129 towerp_.nBitsRatio_ = n;
0130 towerp_.maskRatio_ = std::pow(2, n) - 1;
0131 }
0132 void setTowerEncoding(bool doit) { towerp_.doEncoding_ = doit; }
0133
0134
0135 double regionLsb() const { return regionLsb_; }
0136 std::string regionPUSType() const { return pnode_[regionPUS].type_; }
0137 std::vector<double> regionPUSParams() { return pnode_[regionPUS].dparams_; }
0138 l1t::LUT* regionPUSLUT() { return &pnode_[regionPUS].LUT_; }
0139
0140 int regionPUSValue(int PUM0, int eta) {
0141 int puSub = ceil(regionPUSParams()[18 * eta + PUM0] * 2);
0142 return puSub;
0143 }
0144
0145 void setRegionLsb(double lsb) { regionLsb_ = lsb; }
0146 void setRegionPUSType(std::string type) { pnode_[regionPUS].type_ = type; }
0147 void setRegionPUSParams(const std::vector<double>& params) { pnode_[regionPUS].dparams_ = params; }
0148 void setRegionPUSLUT(const l1t::LUT& lut) { pnode_[regionPUS].LUT_ = lut; }
0149
0150 int pileUpTowerThreshold() const { return pnode_[PUTowerThreshold].iparams_[0]; }
0151 void setPileUpTowerThreshold(int thresh) {
0152 pnode_[PUTowerThreshold].iparams_.resize(1);
0153 pnode_[PUTowerThreshold].iparams_[0] = thresh;
0154 }
0155
0156
0157 int egEtaCut() const {
0158 if (pnode_[egPUS].version_ == 1)
0159 return pnode_[egPUS].iparams_[0];
0160 else
0161 return 0;
0162 }
0163 double egLsb() const { return egp_.lsb_; }
0164 double egSeedThreshold() const { return egp_.seedThreshold_; }
0165 double egNeighbourThreshold() const { return egp_.neighbourThreshold_; }
0166 double egHcalThreshold() const { return egp_.hcalThreshold_; }
0167 l1t::LUT* egTrimmingLUT() { return &pnode_[egTrimming].LUT_; }
0168 double egMaxHcalEt() const { return egp_.maxHcalEt_; }
0169 double egMaxPtHOverE() const { return egp_.maxPtHOverE_; }
0170 l1t::LUT* egMaxHOverELUT() { return &pnode_[egMaxHOverE].LUT_; }
0171 l1t::LUT* egCompressShapesLUT() { return &pnode_[egCompressShapes].LUT_; }
0172 l1t::LUT* egShapeIdLUT() { return &pnode_[egShapeId].LUT_; }
0173 int egMinPtJetIsolation() const { return egp_.minPtJetIsolation_; }
0174 int egMaxPtJetIsolation() const { return egp_.maxPtJetIsolation_; }
0175 int egMinPtHOverEIsolation() const { return egp_.minPtHOverEIsolation_; }
0176 int egMaxPtHOverEIsolation() const { return egp_.maxPtHOverEIsolation_; }
0177 unsigned egBypassEGVetos() { return pnode_[egBypassEGVetosFlag].uparams_[0]; }
0178 unsigned egBypassExtHOverE() { return pnode_[egBypassExtHoE].uparams_[0]; }
0179 unsigned egBypassShape() const {
0180 if (pnode_[egBypassShapeFlag].uparams_.empty())
0181 return 0;
0182 else
0183 return pnode_[egBypassShapeFlag].uparams_[0];
0184 }
0185 unsigned egBypassECALFG() const {
0186 if (pnode_[egBypassECALFGFlag].uparams_.empty())
0187 return 0;
0188 else
0189 return pnode_[egBypassECALFGFlag].uparams_[0];
0190 }
0191 unsigned egBypassHoE() const {
0192 if (pnode_[egBypassHoEFlag].uparams_.empty())
0193 return 0;
0194 else
0195 return pnode_[egBypassHoEFlag].uparams_[0];
0196 }
0197
0198 int egHOverEcutBarrel() const { return pnode_[egHOverEBarrel].iparams_[0]; }
0199 int egHOverEcutEndcap() const { return pnode_[egHOverEEndcap].iparams_[0]; }
0200
0201 unsigned egIsoAreaNrTowersEta() const { return egp_.isoAreaNrTowersEta_; }
0202 unsigned egIsoAreaNrTowersPhi() const { return egp_.isoAreaNrTowersPhi_; }
0203 unsigned egIsoVetoNrTowersPhi() const { return egp_.isoVetoNrTowersPhi_; }
0204 const std::string& egPUSType() const { return pnode_[egPUS].type_; }
0205 const std::vector<double>& egPUSParams() const { return pnode_[egPUS].dparams_; }
0206 double egPUSParam(int ipar) const { return pnode_[egPUS].dparams_.at(ipar); }
0207
0208 std::string egIsolationType() const { return pnode_[egIsolation].type_; }
0209 l1t::LUT* egIsolationLUT() { return &pnode_[egIsolation].LUT_; }
0210 l1t::LUT* egIsolationLUT2() { return &pnode_[egIsolation2].LUT_; }
0211 std::string egCalibrationType() const { return pnode_[egCalibration].type_; }
0212 std::vector<double> egCalibrationParams() { return pnode_[egCalibration].dparams_; }
0213 l1t::LUT* egCalibrationLUT() { return &pnode_[egCalibration].LUT_; }
0214
0215 void setEgEtaCut(int mask) {
0216 pnode_[egPUS].iparams_.resize(1);
0217 pnode_[egPUS].iparams_[0] = mask;
0218 }
0219 void setEgLsb(double lsb) { egp_.lsb_ = lsb; }
0220 void setEgSeedThreshold(double thresh) { egp_.seedThreshold_ = thresh; }
0221 void setEgNeighbourThreshold(double thresh) { egp_.neighbourThreshold_ = thresh; }
0222 void setEgHcalThreshold(double thresh) { egp_.hcalThreshold_ = thresh; }
0223 void setEgTrimmingLUT(const l1t::LUT& lut) { pnode_[egTrimming].LUT_ = lut; }
0224 void setEgMaxHcalEt(double cut) { egp_.maxHcalEt_ = cut; }
0225 void setEgMaxPtHOverE(double thresh) { egp_.maxPtHOverE_ = thresh; }
0226 void setEgMaxHOverELUT(const l1t::LUT& lut) { pnode_[egMaxHOverE].LUT_ = lut; }
0227 void setEgCompressShapesLUT(const l1t::LUT& lut) { pnode_[egCompressShapes].LUT_ = lut; }
0228 void setEgShapeIdLUT(const l1t::LUT& lut) { pnode_[egShapeId].LUT_ = lut; }
0229 void setEgMinPtJetIsolation(int cutValue) { egp_.minPtJetIsolation_ = cutValue; }
0230 void setEgMaxPtJetIsolation(int cutValue) { egp_.maxPtJetIsolation_ = cutValue; }
0231 void setEgMinPtHOverEIsolation(int cutValue) { egp_.minPtHOverEIsolation_ = cutValue; }
0232 void setEgMaxPtHOverEIsolation(int cutValue) { egp_.maxPtHOverEIsolation_ = cutValue; }
0233 void setEgBypassEGVetos(unsigned flag) {
0234 pnode_[egBypassEGVetosFlag].uparams_.resize(1);
0235 pnode_[egBypassEGVetosFlag].uparams_[0] = flag;
0236 }
0237 void setEgBypassShape(unsigned flag) {
0238 pnode_[egBypassShapeFlag].uparams_.resize(1);
0239 pnode_[egBypassShapeFlag].uparams_[0] = flag;
0240 }
0241 void setEgBypassECALFG(unsigned flag) {
0242 pnode_[egBypassECALFGFlag].uparams_.resize(1);
0243 pnode_[egBypassECALFGFlag].uparams_[0] = flag;
0244 }
0245 void setEgBypassExtHOverE(unsigned flag) {
0246 pnode_[egBypassExtHoE].uparams_.resize(1);
0247 pnode_[egBypassExtHoE].uparams_[0] = flag;
0248 }
0249 void setEgHOverEcutBarrel(int cut) {
0250 pnode_[egHOverEBarrel].iparams_.resize(1);
0251 pnode_[egHOverEBarrel].iparams_[0] = cut;
0252 }
0253 void setEgHOverEcutEndcap(int cut) {
0254 pnode_[egHOverEEndcap].iparams_.resize(1);
0255 pnode_[egHOverEEndcap].iparams_[0] = cut;
0256 }
0257
0258 void setEgIsoAreaNrTowersEta(unsigned iEgIsoAreaNrTowersEta) { egp_.isoAreaNrTowersEta_ = iEgIsoAreaNrTowersEta; }
0259 void setEgIsoAreaNrTowersPhi(unsigned iEgIsoAreaNrTowersPhi) { egp_.isoAreaNrTowersPhi_ = iEgIsoAreaNrTowersPhi; }
0260 void setEgIsoVetoNrTowersPhi(unsigned iEgIsoVetoNrTowersPhi) { egp_.isoVetoNrTowersPhi_ = iEgIsoVetoNrTowersPhi; }
0261 void setEgPUSType(std::string type) { pnode_[egPUS].type_ = type; }
0262 void setEgPUSParams(const std::vector<double>& params) { pnode_[egPUS].dparams_ = params; }
0263 void setEgIsolationType(std::string type) { pnode_[egIsolation].type_ = type; }
0264 void setEgIsolationLUT(const l1t::LUT& lut) { pnode_[egIsolation].LUT_ = lut; }
0265 void setEgIsolationLUT2(const l1t::LUT& lut) { pnode_[egIsolation2].LUT_ = lut; }
0266 void setEgCalibrationType(std::string type) { pnode_[egCalibration].type_ = type; }
0267 void setEgCalibrationParams(std::vector<double> params) { pnode_[egCalibration].dparams_ = params; }
0268 void setEgCalibrationLUT(const l1t::LUT& lut) { pnode_[egCalibration].LUT_ = lut; }
0269
0270
0271 std::string egShapeIdType() const { return pnode_[egShapeId].type_; }
0272 void setEgShapeIdType(std::string type) { pnode_[egShapeId].type_ = type; }
0273 unsigned egShapeIdVersion() const { return pnode_[egShapeId].version_; }
0274 void setEgShapeIdVersion(unsigned version) { pnode_[egShapeId].version_ = version; }
0275 unsigned egCalibrationVersion() const { return pnode_[egCalibration].version_; }
0276 void setEgCalibrationVersion(unsigned version) { pnode_[egCalibration].version_ = version; }
0277
0278
0279 int tauRegionMask() const {
0280 if (pnode_[tauPUS].version_ == 1)
0281 return pnode_[tauPUS].iparams_[0];
0282 else
0283 return 0;
0284 }
0285 double tauLsb() const { return taup_.lsb_; }
0286 double tauSeedThreshold() const { return taup_.seedThreshold_; }
0287 double tauNeighbourThreshold() const { return taup_.neighbourThreshold_; }
0288 double tauMaxPtTauVeto() const { return taup_.maxPtTauVeto_; }
0289 double tauMinPtJetIsolationB() const { return taup_.minPtJetIsolationB_; }
0290 double tauMaxJetIsolationB() const { return taup_.maxJetIsolationB_; }
0291 double tauMaxJetIsolationA() const { return taup_.maxJetIsolationA_; }
0292 int isoTauEtaMin() const { return taup_.isoEtaMin_; }
0293 int isoTauEtaMax() const { return taup_.isoEtaMax_; }
0294 std::string tauPUSType() const { return pnode_[tauPUS].type_; }
0295 const std::vector<double>& tauPUSParams() const { return pnode_[tauPUS].dparams_; }
0296 double tauPUSParam(int ipar) const { return pnode_[tauPUS].dparams_.at(ipar); }
0297
0298 l1t::LUT* tauIsolationLUT() { return &pnode_[tauIsolation].LUT_; }
0299 l1t::LUT* tauIsolationLUT2() { return &pnode_[tauIsolation2].LUT_; }
0300 l1t::LUT* tauTrimmingShapeVetoLUT() { return &pnode_[tauTrimmingShapeVeto].LUT_; }
0301
0302 std::string tauCalibrationType() const { return pnode_[tauCalibration].type_; }
0303 std::vector<double> tauCalibrationParams() { return pnode_[tauCalibration].dparams_; }
0304 l1t::LUT* tauCalibrationLUT() { return &pnode_[tauCalibration].LUT_; }
0305 l1t::LUT* tauCompressLUT() { return &pnode_[tauCompress].LUT_; }
0306
0307 l1t::LUT* tauEtToHFRingEtLUT() { return &pnode_[tauEtToHFRingEt].LUT_; }
0308
0309 unsigned tauIsoAreaNrTowersEta() const { return taup_.isoAreaNrTowersEta_; }
0310 unsigned tauIsoAreaNrTowersPhi() const { return taup_.isoAreaNrTowersPhi_; }
0311 unsigned tauIsoVetoNrTowersPhi() const { return taup_.isoVetoNrTowersPhi_; }
0312
0313 void setTauRegionMask(int mask) {
0314 pnode_[tauPUS].iparams_.resize(1);
0315 pnode_[tauPUS].iparams_[0] = mask;
0316 }
0317 void setTauLsb(double lsb) { taup_.lsb_ = lsb; }
0318 void setTauSeedThreshold(double thresh) { taup_.seedThreshold_ = thresh; }
0319 void setTauNeighbourThreshold(double thresh) { taup_.neighbourThreshold_ = thresh; }
0320 void setTauMaxPtTauVeto(double limit) { taup_.maxPtTauVeto_ = limit; }
0321 void setTauMinPtJetIsolationB(double limit) { taup_.minPtJetIsolationB_ = limit; }
0322 void setTauMaxJetIsolationB(double limit) { taup_.maxJetIsolationB_ = limit; }
0323 void setTauMaxJetIsolationA(double cutValue) { taup_.maxJetIsolationA_ = cutValue; }
0324 void setIsoTauEtaMin(int value) { taup_.isoEtaMin_ = value; }
0325 void setIsoTauEtaMax(int value) { taup_.isoEtaMax_ = value; }
0326 void setTauPUSType(std::string type) { pnode_[tauPUS].type_ = type; }
0327 void setTauIsolationLUT(const l1t::LUT& lut) { pnode_[tauIsolation].LUT_ = lut; }
0328 void setTauIsolationLUT2(const l1t::LUT& lut) { pnode_[tauIsolation2].LUT_ = lut; }
0329 void setTauTrimmingShapeVetoLUT(const l1t::LUT& lut) { pnode_[tauTrimmingShapeVeto].LUT_ = lut; }
0330
0331 void setTauCalibrationType(std::string type) { pnode_[tauCalibration].type_ = type; }
0332 void setTauIsoAreaNrTowersEta(unsigned iTauIsoAreaNrTowersEta) {
0333 taup_.isoAreaNrTowersEta_ = iTauIsoAreaNrTowersEta;
0334 }
0335 void setTauIsoAreaNrTowersPhi(unsigned iTauIsoAreaNrTowersPhi) {
0336 taup_.isoAreaNrTowersPhi_ = iTauIsoAreaNrTowersPhi;
0337 }
0338 void setTauIsoVetoNrTowersPhi(unsigned iTauIsoVetoNrTowersPhi) {
0339 taup_.isoVetoNrTowersPhi_ = iTauIsoVetoNrTowersPhi;
0340 }
0341
0342 void setTauCalibrationParams(std::vector<double> params) { pnode_[tauCalibration].dparams_ = params; }
0343 void setTauCalibrationLUT(const l1t::LUT& lut) { pnode_[tauCalibration].LUT_ = lut; }
0344 void setTauCompressLUT(const l1t::LUT& lut) { pnode_[tauCompress].LUT_ = lut; }
0345 void setTauPUSParams(const std::vector<double>& params) { pnode_[tauPUS].dparams_ = params; }
0346
0347 void setTauEtToHFRingEtLUT(const l1t::LUT& lut) { pnode_[tauEtToHFRingEt].LUT_ = lut; }
0348
0349
0350 double jetLsb() const { return jetp_.lsb_; }
0351 double jetSeedThreshold() const { return jetp_.seedThreshold_; }
0352 double jetNeighbourThreshold() const { return jetp_.neighbourThreshold_; }
0353 int jetRegionMask() const {
0354 if (pnode_[jetPUS].version_ == 1)
0355 return pnode_[jetPUS].iparams_[0];
0356 else
0357 return 0;
0358 }
0359
0360 unsigned jetBypassPUS() const { return pnode_[jetBypassPUSFlag].uparams_[0]; }
0361 unsigned jetPUSUsePhiRing() const {
0362 if (pnode_[jetPUSUsePhiRingFlag].uparams_.empty())
0363 return 0;
0364 else
0365 return pnode_[jetPUSUsePhiRingFlag].uparams_[0];
0366 }
0367
0368 std::string jetPUSType() const { return pnode_[jetPUS].type_; }
0369 std::vector<double> jetPUSParams() { return pnode_[jetPUS].dparams_; }
0370 std::string jetCalibrationType() const { return pnode_[jetCalibration].type_; }
0371 std::vector<double> jetCalibrationParams() { return pnode_[jetCalibration].dparams_; }
0372
0373 l1t::LUT* jetCalibrationLUT() { return &pnode_[jetCalibration].LUT_; }
0374 l1t::LUT* jetCompressPtLUT() { return &pnode_[jetCompressPt].LUT_; }
0375 l1t::LUT* jetCompressEtaLUT() { return &pnode_[jetCompressEta].LUT_; }
0376
0377 void setJetLsb(double lsb) { jetp_.lsb_ = lsb; }
0378 void setJetSeedThreshold(double thresh) { jetp_.seedThreshold_ = thresh; }
0379 void setJetNeighbourThreshold(double thresh) { jetp_.neighbourThreshold_ = thresh; }
0380 void setJetRegionMask(int mask) {
0381 pnode_[jetPUS].iparams_.resize(1);
0382 pnode_[jetPUS].iparams_[0] = mask;
0383 }
0384 void setJetPUSType(std::string type) { pnode_[jetPUS].type_ = type; }
0385 void setJetPUSParams(std::vector<double> params) { pnode_[jetPUS].dparams_ = params; }
0386 void setJetCalibrationType(std::string type) { pnode_[jetCalibration].type_ = type; }
0387 void setJetCalibrationParams(std::vector<double> params) { pnode_[jetCalibration].dparams_ = params; }
0388 void setJetCalibrationLUT(const l1t::LUT& lut) { pnode_[jetCalibration].LUT_ = lut; }
0389 void setJetCompressEtaLUT(const l1t::LUT& lut) { pnode_[jetCompressEta].LUT_ = lut; }
0390 void setJetCompressPtLUT(const l1t::LUT& lut) { pnode_[jetCompressPt].LUT_ = lut; }
0391 void setJetBypassPUS(unsigned flag) {
0392 pnode_[jetBypassPUSFlag].uparams_.resize(1);
0393 pnode_[jetBypassPUSFlag].uparams_[0] = flag;
0394 }
0395 void setJetPUSUsePhiRing(unsigned flag) {
0396 pnode_[jetPUSUsePhiRingFlag].uparams_.resize(1);
0397 pnode_[jetPUSUsePhiRingFlag].uparams_[0] = flag;
0398 }
0399
0400
0401 double etSumLsb() const { return etSumLsb_; }
0402 int etSumEtaMin(unsigned isum) const {
0403 if (etSumEtaMin_.size() > isum)
0404 return etSumEtaMin_.at(isum);
0405 else
0406 return 0;
0407 }
0408 int etSumEtaMax(unsigned isum) const {
0409 if (etSumEtaMax_.size() > isum)
0410 return etSumEtaMax_.at(isum);
0411 else
0412 return 0;
0413 }
0414 double etSumEtThreshold(unsigned isum) const {
0415 if (etSumEtThreshold_.size() > isum)
0416 return etSumEtThreshold_.at(isum);
0417 else
0418 return 0.;
0419 }
0420 unsigned etSumBypassMetPUS() const { return pnode_[etSumBypassMetPUSFlag].uparams_[0]; }
0421 unsigned etSumBypassEttPUS() const { return pnode_[etSumBypassEttPUSFlag].uparams_[0]; }
0422 unsigned etSumBypassEcalSumPUS() const { return pnode_[etSumBypassEcalSumPUSFlag].uparams_[0]; }
0423 std::string etSumMetPUSType() const { return pnode_[etSumMetPUS].type_; }
0424 std::string etSumEttPUSType() const { return pnode_[etSumEttPUS].type_; }
0425 std::string etSumEcalSumPUSType() const { return pnode_[etSumEcalSumPUS].type_; }
0426 std::string metCalibrationType() const { return pnode_[metCalibration].type_; }
0427 std::string metHFCalibrationType() const { return pnode_[metHFCalibration].type_; }
0428 std::string etSumEttCalibrationType() const { return pnode_[etSumEttCalibration].type_; }
0429 std::string etSumEcalSumCalibrationType() const { return pnode_[etSumEcalSumCalibration].type_; }
0430
0431 l1t::LUT* etSumMetPUSLUT() { return &pnode_[etSumMetPUS].LUT_; }
0432 l1t::LUT* etSumEttPUSLUT() { return &pnode_[etSumEttPUS].LUT_; }
0433 l1t::LUT* etSumEcalSumPUSLUT() { return &pnode_[etSumEcalSumPUS].LUT_; }
0434 l1t::LUT* metCalibrationLUT() { return &pnode_[metCalibration].LUT_; }
0435 l1t::LUT* metHFCalibrationLUT() { return &pnode_[metHFCalibration].LUT_; }
0436 l1t::LUT* etSumEttCalibrationLUT() { return &pnode_[etSumEttCalibration].LUT_; }
0437 l1t::LUT* etSumEcalSumCalibrationLUT() { return &pnode_[etSumEcalSumCalibration].LUT_; }
0438 l1t::LUT* metPhiCalibrationLUT() { return &pnode_[metPhiCalibration].LUT_; }
0439 l1t::LUT* metHFPhiCalibrationLUT() { return &pnode_[metHFPhiCalibration].LUT_; }
0440
0441 void setEtSumLsb(double lsb) { etSumLsb_ = lsb; }
0442 void setEtSumEtaMin(unsigned isum, int eta) {
0443 if (etSumEtaMin_.size() <= isum)
0444 etSumEtaMin_.resize(isum + 1);
0445 etSumEtaMin_.at(isum) = eta;
0446 }
0447 void setEtSumEtaMax(unsigned isum, int eta) {
0448 if (etSumEtaMax_.size() <= isum)
0449 etSumEtaMax_.resize(isum + 1);
0450 etSumEtaMax_.at(isum) = eta;
0451 }
0452 void setEtSumEtThreshold(unsigned isum, double thresh) {
0453 if (etSumEtThreshold_.size() <= isum)
0454 etSumEtThreshold_.resize(isum + 1);
0455 etSumEtThreshold_.at(isum) = thresh;
0456 }
0457 void setEtSumMetPUSType(std::string type) { pnode_[etSumMetPUS].type_ = type; }
0458 void setEtSumEttPUSType(std::string type) { pnode_[etSumEttPUS].type_ = type; }
0459 void setEtSumEcalSumPUSType(std::string type) { pnode_[etSumEcalSumPUS].type_ = type; }
0460 void setMetCalibrationType(std::string type) { pnode_[metCalibration].type_ = type; }
0461 void setMetHFCalibrationType(std::string type) { pnode_[metHFCalibration].type_ = type; }
0462 void setEtSumEttCalibrationType(std::string type) { pnode_[etSumEttCalibration].type_ = type; }
0463 void setEtSumEcalSumCalibrationType(std::string type) { pnode_[etSumEcalSumCalibration].type_ = type; }
0464 void setEtSumBypassMetPUS(unsigned flag) {
0465 pnode_[etSumBypassMetPUSFlag].uparams_.resize(1);
0466 pnode_[etSumBypassMetPUSFlag].uparams_[0] = flag;
0467 }
0468 void setEtSumBypassEttPUS(unsigned flag) {
0469 pnode_[etSumBypassEttPUSFlag].uparams_.resize(1);
0470 pnode_[etSumBypassEttPUSFlag].uparams_[0] = flag;
0471 }
0472 void setEtSumBypassEcalSumPUS(unsigned flag) {
0473 pnode_[etSumBypassEcalSumPUSFlag].uparams_.resize(1);
0474 pnode_[etSumBypassEcalSumPUSFlag].uparams_[0] = flag;
0475 }
0476
0477 void setEtSumMetPUSLUT(const l1t::LUT& lut) { pnode_[etSumMetPUS].LUT_ = lut; }
0478 void setEtSumEttPUSLUT(const l1t::LUT& lut) { pnode_[etSumEttPUS].LUT_ = lut; }
0479 void setEtSumEcalSumPUSLUT(const l1t::LUT& lut) { pnode_[etSumEcalSumPUS].LUT_ = lut; }
0480 void setMetCalibrationLUT(const l1t::LUT& lut) { pnode_[metCalibration].LUT_ = lut; }
0481 void setMetHFCalibrationLUT(const l1t::LUT& lut) { pnode_[metHFCalibration].LUT_ = lut; }
0482 void setEtSumEttCalibrationLUT(const l1t::LUT& lut) { pnode_[etSumEttCalibration].LUT_ = lut; }
0483 void setEtSumEcalSumCalibrationLUT(const l1t::LUT& lut) { pnode_[etSumEcalSumCalibration].LUT_ = lut; }
0484 void setMetPhiCalibrationLUT(const l1t::LUT& lut) { pnode_[metPhiCalibration].LUT_ = lut; }
0485 void setMetHFPhiCalibrationLUT(const l1t::LUT& lut) { pnode_[metHFPhiCalibration].LUT_ = lut; }
0486
0487 double etSumCentLower(unsigned centClass) const {
0488 if (pnode_[etSumCentralityLower].dparams_.size() > centClass)
0489 return pnode_[etSumCentralityLower].dparams_.at(centClass);
0490 else
0491 return 0.;
0492 }
0493
0494 double etSumCentUpper(unsigned centClass) const {
0495 if (pnode_[etSumCentralityUpper].dparams_.size() > centClass)
0496 return pnode_[etSumCentralityUpper].dparams_.at(centClass);
0497 else
0498 return 0.;
0499 }
0500
0501 void setEtSumCentLower(unsigned centClass, double loBound) {
0502 if (pnode_[etSumCentralityLower].dparams_.size() <= centClass)
0503 pnode_[etSumCentralityLower].dparams_.resize(centClass + 1);
0504 pnode_[etSumCentralityLower].dparams_.at(centClass) = loBound;
0505 }
0506
0507 void setEtSumCentUpper(unsigned centClass, double upBound) {
0508 if (pnode_[etSumCentralityUpper].dparams_.size() <= centClass)
0509 pnode_[etSumCentralityUpper].dparams_.resize(centClass + 1);
0510 pnode_[etSumCentralityUpper].dparams_.at(centClass) = upBound;
0511 }
0512
0513
0514 int centralityRegionMask() const {
0515 if (pnode_[hiCentrality].version_ == 1)
0516 return pnode_[hiCentrality].iparams_[0];
0517 else
0518 return 0;
0519 }
0520 std::vector<int> minimumBiasThresholds() const {
0521 if (pnode_[hiCentrality].version_ == 1 && pnode_[hiCentrality].iparams_.size() == 5) {
0522 std::vector<int> newVec;
0523 newVec.reserve(4);
0524 for (int i = 0; i < 4; i++) {
0525 newVec.push_back(pnode_[hiCentrality].iparams_.at(i + 1));
0526 }
0527 return newVec;
0528 } else {
0529 std::vector<int> newVec;
0530 return newVec;
0531 }
0532 }
0533 l1t::LUT* centralityLUT() { return &pnode_[hiCentrality].LUT_; }
0534 void setCentralityRegionMask(int mask) {
0535 pnode_[hiCentrality].iparams_.resize(5);
0536 pnode_[hiCentrality].iparams_[0] = mask;
0537 }
0538 void setMinimumBiasThresholds(std::vector<int> thresholds) {
0539 pnode_[hiCentrality].iparams_.resize(5);
0540 for (int i = 0; i < 4; i++) {
0541 pnode_[hiCentrality].iparams_[i + 1] = thresholds.at(i);
0542 }
0543 }
0544 void setCentralityLUT(const l1t::LUT& lut) { pnode_[hiCentrality].LUT_ = lut; }
0545
0546
0547 l1t::LUT* q2LUT() { return &pnode_[hiQ2].LUT_; }
0548 void setQ2LUT(const l1t::LUT& lut) { pnode_[hiQ2].LUT_ = lut; }
0549
0550
0551
0552
0553 std::vector<double> layer1ECalScaleFactors() { return pnode_[layer1ECal].dparams_; }
0554 std::vector<double> layer1HCalScaleFactors() { return pnode_[layer1HCal].dparams_; }
0555 std::vector<double> layer1ECalZSFactors() { return pnode_[layer1ECalZS].dparams_; }
0556 std::vector<double> layer1HCalZSFactors() { return pnode_[layer1HCalZS].dparams_; }
0557 std::vector<double> layer1HFScaleFactors() { return pnode_[layer1HF].dparams_; }
0558 std::vector<unsigned> layer1HCalFBLUTUpper() { return pnode_[layer1HCalFBUpper].uparams_; }
0559 std::vector<unsigned> layer1HCalFBLUTLower() { return pnode_[layer1HCalFBLower].uparams_; }
0560 std::vector<int> layer1ECalScaleETBins() { return pnode_[layer1ECal].iparams_; }
0561 std::vector<int> layer1HCalScaleETBins() { return pnode_[layer1HCal].iparams_; }
0562 std::vector<int> layer1HFScaleETBins() { return pnode_[layer1HF].iparams_; }
0563 std::vector<unsigned> layer1ECalScalePhiBins() { return pnode_[layer1ECal].uparams_; }
0564 std::vector<unsigned> layer1HCalScalePhiBins() { return pnode_[layer1HCal].uparams_; }
0565 std::vector<unsigned> layer1HFScalePhiBins() { return pnode_[layer1HF].uparams_; }
0566 void setLayer1ECalScaleFactors(const std::vector<double> params) { pnode_[layer1ECal].dparams_ = params; }
0567 void setLayer1HCalScaleFactors(const std::vector<double> params) { pnode_[layer1HCal].dparams_ = params; }
0568 void setLayer1ECalZSFactors(const std::vector<double> params) { pnode_[layer1ECalZS].dparams_ = params; }
0569 void setLayer1HCalZSFactors(const std::vector<double> params) { pnode_[layer1HCalZS].dparams_ = params; }
0570 void setLayer1HFScaleFactors(const std::vector<double> params) { pnode_[layer1HF].dparams_ = params; }
0571 void setLayer1HCalFBLUTUpper(const std::vector<unsigned> params) { pnode_[layer1HCalFBUpper].uparams_ = params; }
0572 void setLayer1HCalFBLUTLower(const std::vector<unsigned> params) { pnode_[layer1HCalFBLower].uparams_ = params; }
0573 void setLayer1ECalScaleETBins(const std::vector<int> params) { pnode_[layer1ECal].iparams_ = params; }
0574 void setLayer1HCalScaleETBins(const std::vector<int> params) { pnode_[layer1HCal].iparams_ = params; }
0575 void setLayer1HFScaleETBins(const std::vector<int> params) { pnode_[layer1HF].iparams_ = params; }
0576 void setLayer1ECalScalePhiBins(const std::vector<unsigned> params) { pnode_[layer1ECal].uparams_ = params; }
0577 void setLayer1HCalScalePhiBins(const std::vector<unsigned> params) { pnode_[layer1HCal].uparams_ = params; }
0578 void setLayer1HFScalePhiBins(const std::vector<unsigned> params) { pnode_[layer1HF].uparams_ = params; }
0579
0580 std::vector<unsigned> layer1SecondStageLUT() { return pnode_[layer1HOverE].uparams_; }
0581 void setLayer1SecondStageLUT(const std::vector<unsigned>& lut) { pnode_[layer1HOverE].uparams_ = lut; }
0582
0583 private:
0584 L1CaloEtScale emScale_;
0585 L1CaloEtScale jetScale_;
0586 L1CaloEtScale HtMissScale_;
0587 L1CaloEtScale HfRingScale_;
0588 };
0589
0590 }
0591
0592 #endif