L1TConfigProducers/src/CaloParamsHelperO2O.h

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     // DO NOT ADD ENTRIES ANYWHERE BUT DIRECTLY BEFORE "NUM_CALOPARAMNODES"
0019     // DO NOT CHANGE NUMERICAL VALUES OF ANY ALREADY EXISTING FIELDS, YOU CAN ONLY EXTEND, AT THE END.
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         // at version 2, tauCompress was added, we can add a default version here if necessary...
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     // towers
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     // regions
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     // EG
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     // - recently imported:
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     // tau
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     // jets
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     // sums
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     // HI centrality
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     // HI Q2
0547     l1t::LUT* q2LUT() { return &pnode_[hiQ2].LUT_; }
0548     void setQ2LUT(const l1t::LUT& lut) { pnode_[hiQ2].LUT_ = lut; }
0549
0550     // HI parameters
0551
0552     // Layer 1 LUT specification
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 }  // namespace l1t
0591
0592 #endif