Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-02-20 03:45:41 

0001 // CaloParamsHelper.h
0002 // Author: R. Alex Barbieri
0003 //
0004 // Wrapper class for CaloParams and Et scales
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     // DO NOT ADD ENTRIES ANYWHERE BUT DIRECTLY BEFORE "NUM_CALOPARAMNODES"
0024     // DO NOT CHANGE NUMERICAL VALUES OF ANY ALREADY EXISTING FIELDS, YOU CAN ONLY EXTEND, AT THE END.
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     // towers
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     // regions
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     // EG
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     // - recently imported:
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     // tau
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     // jets
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     // sums
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     // HI centrality
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     // HI Q2
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     // HI ZDC
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     // HI parameters
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     // Layer 1 LUT specification
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 }  // namespace l1t
0609 
0610 #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!