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