Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-04-11 02:04:52 

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

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!