File indexing completed on 2024-04-06 12:04:57
0001
0002
0003
0004 #include "DataFormats/PatCandidates/interface/MET.h"
0005
0006 using namespace pat;
0007
0008
0009 MET::MET() { initCorMap(); }
0010
0011
0012 MET::MET(const reco::MET &aMET) : PATObject<reco::MET>(aMET) {
0013 const reco::CaloMET *calo = dynamic_cast<const reco::CaloMET *>(&aMET);
0014 if (calo != nullptr)
0015 caloMET_.push_back(calo->getSpecific());
0016 const reco::PFMET *pf = dynamic_cast<const reco::PFMET *>(&aMET);
0017 if (pf != nullptr)
0018 pfMET_.push_back(pf->getSpecific());
0019 const pat::MET *pm = dynamic_cast<const pat::MET *>(&aMET);
0020 if (pm != nullptr)
0021 this->operator=(*pm);
0022
0023 metSig_ = 0.;
0024 sumPtUnclustered_ = 0.;
0025 initCorMap();
0026 }
0027
0028
0029 MET::MET(const edm::RefToBase<reco::MET> &aMETRef) : PATObject<reco::MET>(aMETRef) {
0030 const reco::CaloMET *calo = dynamic_cast<const reco::CaloMET *>(aMETRef.get());
0031 if (calo != nullptr)
0032 caloMET_.push_back(calo->getSpecific());
0033 const reco::PFMET *pf = dynamic_cast<const reco::PFMET *>(aMETRef.get());
0034 if (pf != nullptr)
0035 pfMET_.push_back(pf->getSpecific());
0036 const pat::MET *pm = dynamic_cast<const pat::MET *>(aMETRef.get());
0037 if (pm != nullptr)
0038 this->operator=(*pm);
0039
0040 metSig_ = 0.;
0041 sumPtUnclustered_ = 0.;
0042 initCorMap();
0043 }
0044
0045
0046 MET::MET(const edm::Ptr<reco::MET> &aMETRef) : PATObject<reco::MET>(aMETRef) {
0047 const reco::CaloMET *calo = dynamic_cast<const reco::CaloMET *>(aMETRef.get());
0048 if (calo != nullptr)
0049 caloMET_.push_back(calo->getSpecific());
0050 const reco::PFMET *pf = dynamic_cast<const reco::PFMET *>(aMETRef.get());
0051 if (pf != nullptr)
0052 pfMET_.push_back(pf->getSpecific());
0053 const pat::MET *pm = dynamic_cast<const pat::MET *>(aMETRef.get());
0054 if (pm != nullptr)
0055 this->operator=(*pm);
0056
0057 metSig_ = 0.;
0058 sumPtUnclustered_ = 0.;
0059 initCorMap();
0060 }
0061
0062
0063 MET::MET(MET const &iOther)
0064 : PATObject<reco::MET>(iOther),
0065 genMET_(iOther.genMET_),
0066 caloMET_(iOther.caloMET_),
0067 pfMET_(iOther.pfMET_),
0068 metSig_(iOther.metSig_),
0069 sumPtUnclustered_(iOther.sumPtUnclustered_),
0070 uncertaintiesRaw_(iOther.uncertaintiesRaw_),
0071 uncertaintiesType1_(iOther.uncertaintiesType1_),
0072 uncertaintiesType1p2_(iOther.uncertaintiesType1p2_),
0073 uncertainties_(iOther.uncertainties_),
0074 corrections_(iOther.corrections_),
0075 caloPackedMet_(iOther.caloPackedMet_) {
0076 initCorMap();
0077 }
0078
0079
0080
0081 MET::MET(const reco::MET &corMET, const MET &srcMET)
0082 : PATObject<reco::MET>(corMET),
0083 genMET_(srcMET.genMET_),
0084 caloMET_(srcMET.caloMET_),
0085 pfMET_(srcMET.pfMET_),
0086 metSig_(srcMET.metSig_),
0087 sumPtUnclustered_(srcMET.sumPtUnclustered_),
0088 caloPackedMet_(srcMET.caloPackedMet_) {
0089 setSignificanceMatrix(srcMET.getSignificanceMatrix());
0090
0091 initCorMap();
0092 }
0093
0094
0095 MET::~MET() {}
0096
0097 MET &MET::operator=(MET const &iOther) {
0098 PATObject<reco::MET>::operator=(iOther);
0099 genMET_ = iOther.genMET_;
0100 caloMET_ = iOther.caloMET_;
0101 pfMET_ = iOther.pfMET_;
0102 uncertaintiesRaw_ = iOther.uncertaintiesRaw_;
0103 uncertaintiesType1_ = iOther.uncertaintiesType1_;
0104 uncertaintiesType1p2_ = iOther.uncertaintiesType1p2_;
0105 uncertainties_ = iOther.uncertainties_;
0106 corrections_ = iOther.corrections_;
0107 metSig_ = iOther.metSig_;
0108 sumPtUnclustered_ = iOther.sumPtUnclustered_;
0109 caloPackedMet_ = iOther.caloPackedMet_;
0110
0111 return *this;
0112 }
0113
0114
0115 const reco::GenMET *MET::genMET() const { return (!genMET_.empty() ? &genMET_.front() : nullptr); }
0116
0117
0118 void MET::setGenMET(const reco::GenMET &gm) {
0119 genMET_.clear();
0120 genMET_.push_back(gm);
0121 }
0122
0123
0124 void MET::setMETSignificance(const double &metSig) { metSig_ = metSig; }
0125
0126 double MET::metSignificance() const { return metSig_; }
0127
0128 void MET::setMETSumPtUnclustered(const double &sumPtUnclustered) { sumPtUnclustered_ = sumPtUnclustered; }
0129
0130 double MET::metSumPtUnclustered() const { return sumPtUnclustered_; }
0131
0132 void MET::initCorMap() {
0133 std::vector<MET::METCorrectionType> tmpRaw;
0134 std::vector<MET::METCorrectionType> tmpType1;
0135 std::vector<MET::METCorrectionType> tmpType01;
0136 std::vector<MET::METCorrectionType> tmpTypeXY;
0137 std::vector<MET::METCorrectionType> tmpType1XY;
0138 std::vector<MET::METCorrectionType> tmpType01XY;
0139 std::vector<MET::METCorrectionType> tmpType1Smear;
0140 std::vector<MET::METCorrectionType> tmpType01Smear;
0141 std::vector<MET::METCorrectionType> tmpType1SmearXY;
0142 std::vector<MET::METCorrectionType> tmpType01SmearXY;
0143
0144 tmpRaw.push_back(MET::None);
0145
0146 tmpType1.push_back(MET::T1);
0147 tmpType01.push_back(MET::T1);
0148 tmpType1XY.push_back(MET::T1);
0149 tmpType01XY.push_back(MET::T1);
0150 tmpType1Smear.push_back(MET::T1);
0151 tmpType01Smear.push_back(MET::T1);
0152 tmpType1SmearXY.push_back(MET::T1);
0153 tmpType01SmearXY.push_back(MET::T1);
0154
0155 tmpType01.push_back(MET::T0);
0156 tmpType01XY.push_back(MET::T0);
0157 tmpType01Smear.push_back(MET::T0);
0158 tmpType01SmearXY.push_back(MET::T0);
0159
0160 tmpType1Smear.push_back(MET::Smear);
0161 tmpType01Smear.push_back(MET::Smear);
0162 tmpType1SmearXY.push_back(MET::Smear);
0163 tmpType01SmearXY.push_back(MET::Smear);
0164
0165 tmpTypeXY.push_back(MET::TXYForRaw);
0166 tmpType1XY.push_back(MET::TXY);
0167 tmpType01XY.push_back(MET::TXYForT01);
0168 tmpType1SmearXY.push_back(MET::TXYForT1Smear);
0169 tmpType01SmearXY.push_back(MET::TXYForT01Smear);
0170
0171 corMap_[MET::Raw] = tmpRaw;
0172 corMap_[MET::Type1] = tmpType1;
0173 corMap_[MET::Type01] = tmpType01;
0174 corMap_[MET::TypeXY] = tmpTypeXY;
0175 corMap_[MET::Type1XY] = tmpType1XY;
0176 corMap_[MET::Type01XY] = tmpType01XY;
0177 corMap_[MET::Type1Smear] = tmpType1Smear;
0178 corMap_[MET::Type01Smear] = tmpType01Smear;
0179 corMap_[MET::Type1SmearXY] = tmpType1SmearXY;
0180 corMap_[MET::Type01SmearXY] = tmpType01SmearXY;
0181
0182
0183 std::vector<MET::METCorrectionType> tmpRawCalo;
0184 tmpRawCalo.push_back(MET::Calo);
0185 corMap_[MET::RawCalo] = tmpRawCalo;
0186
0187
0188 std::vector<MET::METCorrectionType> tmpRawChs;
0189 tmpRawChs.push_back(MET::Chs);
0190 corMap_[MET::RawChs] = tmpRawChs;
0191
0192
0193 std::vector<MET::METCorrectionType> tmpRawTrk;
0194 tmpRawTrk.push_back(MET::Trk);
0195 corMap_[MET::RawTrk] = tmpRawTrk;
0196
0197
0198 std::vector<MET::METCorrectionType> tmpDeepResponse;
0199 tmpDeepResponse.push_back(MET::DeepResponseTune);
0200 corMap_[MET::RawDeepResponseTune] = tmpDeepResponse;
0201
0202
0203 std::vector<MET::METCorrectionType> tmpDeepResolution;
0204 tmpDeepResolution.push_back(MET::DeepResolutionTune);
0205 corMap_[MET::RawDeepResolutionTune] = tmpDeepResolution;
0206 }
0207
0208 MET::UnpackedMETUncertainty MET::findMETTotalShift(MET::METCorrectionLevel cor, MET::METUncertainty shift) const {
0209
0210 std::map<MET::METCorrectionLevel, std::vector<MET::METCorrectionType> >::const_iterator itCor_ = corMap_.find(cor);
0211 if (itCor_ == corMap_.end())
0212 throw cms::Exception("Unsupported", "Specified MET correction scheme does not exist");
0213
0214 bool isSmeared = false;
0215 MET::UnpackedMETUncertainty totShift;
0216 unsigned int scor = itCor_->second.size();
0217 for (unsigned int i = 0; i < scor; i++) {
0218 auto up = corrections_[itCor_->second[i]].unpack();
0219 totShift.add(up.dpx(), up.dpy(), up.dsumEt());
0220
0221 if (itCor_->first >= MET::Type1Smear)
0222 isSmeared = true;
0223 }
0224
0225
0226
0227 if (uncertainties_.empty())
0228 return totShift;
0229
0230 if (shift >= MET::METUncertaintySize)
0231 throw cms::Exception("Unsupported", "MET uncertainty does not exist");
0232 if (isSmeared && shift <= MET::JetResDown)
0233 shift = (MET::METUncertainty)(MET::METUncertaintySize + shift + 1);
0234
0235 auto up = uncertainties_[shift].unpack();
0236 totShift.add(up.dpx(), up.dpy(), up.dsumEt());
0237
0238 return totShift;
0239 }
0240
0241 MET::Vector2 MET::shiftedP2(MET::METUncertainty shift, MET::METCorrectionLevel cor) const {
0242 Vector2 vo;
0243
0244
0245
0246
0247 if (!uncertaintiesType1_.empty() || !uncertaintiesRaw_.empty()) {
0248 if (cor != MET::METCorrectionLevel::RawCalo) {
0249 vo = shiftedP2_74x(shift, cor);
0250 } else {
0251 Vector2 ret{caloPackedMet_.unpackDpx(), caloPackedMet_.unpackDpy()};
0252 vo = ret;
0253 }
0254 } else {
0255 auto v = findMETTotalShift(cor, shift);
0256 Vector2 ret{(px() + v.dpx()), (py() + v.dpy())};
0257
0258 vo = ret;
0259 }
0260 return vo;
0261 }
0262 MET::Vector MET::shiftedP3(MET::METUncertainty shift, MET::METCorrectionLevel cor) const {
0263 Vector vo;
0264
0265
0266
0267
0268 if (!uncertaintiesType1_.empty() || !uncertaintiesRaw_.empty()) {
0269 if (cor != MET::METCorrectionLevel::RawCalo) {
0270 vo = shiftedP3_74x(shift, cor);
0271 } else {
0272 Vector tmp(caloPackedMet_.unpackDpx(), caloPackedMet_.unpackDpy(), 0);
0273 vo = tmp;
0274 }
0275 } else {
0276 const MET::UnpackedMETUncertainty &v = findMETTotalShift(cor, shift);
0277
0278 Vector tmp(px() + v.dpx(), py() + v.dpy(), 0);
0279 vo = tmp;
0280 }
0281 return vo;
0282 }
0283 MET::LorentzVector MET::shiftedP4(METUncertainty shift, MET::METCorrectionLevel cor) const {
0284 LorentzVector vo;
0285
0286
0287
0288
0289 if (!uncertaintiesType1_.empty() || !uncertaintiesRaw_.empty()) {
0290 if (cor != MET::METCorrectionLevel::RawCalo) {
0291 vo = shiftedP4_74x(shift, cor);
0292 } else {
0293 double x = caloPackedMet_.unpackDpx(), y = caloPackedMet_.unpackDpy();
0294 LorentzVector tmp(x, y, 0, std::hypot(x, y));
0295 vo = tmp;
0296 }
0297 } else {
0298 const auto v = findMETTotalShift(cor, shift);
0299 double x = px() + v.dpx(), y = py() + v.dpy();
0300
0301 LorentzVector tmp(x, y, 0, std::hypot(x, y));
0302 vo = tmp;
0303 }
0304 return vo;
0305 }
0306 double MET::shiftedSumEt(MET::METUncertainty shift, MET::METCorrectionLevel cor) const {
0307 double sumEto;
0308
0309
0310
0311
0312 if (!uncertaintiesType1_.empty() || !uncertaintiesRaw_.empty()) {
0313 if (cor != MET::METCorrectionLevel::RawCalo) {
0314 sumEto = shiftedSumEt_74x(shift, cor);
0315 } else {
0316 sumEto = caloPackedMet_.unpackDSumEt();
0317 }
0318 } else {
0319 const auto v = findMETTotalShift(cor, shift);
0320
0321 sumEto = sumEt() + v.dsumEt();
0322 }
0323 return sumEto;
0324 }
0325
0326 MET::Vector2 MET::corP2(MET::METCorrectionLevel cor) const { return shiftedP2(MET::NoShift, cor); }
0327 MET::Vector MET::corP3(MET::METCorrectionLevel cor) const { return shiftedP3(MET::NoShift, cor); }
0328 MET::LorentzVector MET::corP4(MET::METCorrectionLevel cor) const { return shiftedP4(MET::NoShift, cor); }
0329 double MET::corSumEt(MET::METCorrectionLevel cor) const { return shiftedSumEt(MET::NoShift, cor); }
0330
0331 MET::Vector2 MET::uncorP2() const { return shiftedP2(MET::NoShift, MET::Raw); }
0332 MET::Vector MET::uncorP3() const { return shiftedP3(MET::NoShift, MET::Raw); }
0333 MET::LorentzVector MET::uncorP4() const { return shiftedP4(MET::NoShift, MET::Raw); }
0334 double MET::uncorSumEt() const { return shiftedSumEt(MET::NoShift, MET::Raw); }
0335
0336 void MET::setUncShift(double px, double py, double sumEt, METUncertainty shift, bool isSmeared) {
0337 if (uncertainties_.empty()) {
0338 uncertainties_.resize(METUncertainty::METFullUncertaintySize);
0339 }
0340
0341 if (isSmeared && shift <= MET::JetResDown) {
0342
0343
0344 shift = (MET::METUncertainty)(METUncertainty::METUncertaintySize + shift + 1);
0345 const PackedMETUncertainty &ref = corrections_[METCorrectionType::Smear];
0346 uncertainties_[shift].set(px - ref.unpackDpx() - this->px(),
0347 py - ref.unpackDpy() - this->py(),
0348 sumEt - ref.unpackDSumEt() - this->sumEt());
0349 } else
0350 uncertainties_[shift].set(px - this->px(), py - this->py(), sumEt - this->sumEt());
0351 }
0352
0353 void MET::setCorShift(double px, double py, double sumEt, MET::METCorrectionType level) {
0354 if (corrections_.empty()) {
0355 corrections_.resize(MET::METCorrectionType::METCorrectionTypeSize);
0356 }
0357
0358 corrections_[level].set(px - this->px(), py - this->py(), sumEt - this->sumEt());
0359 }
0360
0361 MET::Vector2 MET::caloMETP2() const {
0362 return shiftedP2(MET::METUncertainty::NoShift, MET::METCorrectionLevel::RawCalo);
0363 }
0364
0365 double MET::caloMETPt() const { return caloMETP2().pt(); }
0366
0367 double MET::caloMETPhi() const { return caloMETP2().phi(); }
0368
0369 double MET::caloMETSumEt() const { return shiftedSumEt(MET::NoShift, MET::RawCalo); }
0370
0371
0372 MET::Vector2 MET::shiftedP2_74x(MET::METUncertainty shift, MET::METCorrectionLevel level) const {
0373 if (level != Type1 && level != Raw)
0374 throw cms::Exception("Unsupported", "MET uncertainties only supported for Raw and Type1 in 74X samples \n");
0375 const std::vector<PackedMETUncertainty> &v = (level == Type1 ? uncertaintiesType1_ : uncertaintiesRaw_);
0376 if (v.empty())
0377 throw cms::Exception("Unsupported", "MET uncertainties not available for the specified correction type\n");
0378 if (v.size() == 1) {
0379 if (shift != MET::METUncertainty::NoShift)
0380 throw cms::Exception(
0381 "Unsupported",
0382 "MET uncertainties not available for the specified correction type (only central value available)\n");
0383 auto const &p = v.front();
0384 return Vector2{(px() + p.unpackDpx()), (py() + p.unpackDpy())};
0385 }
0386 auto const &p = v[shift];
0387 Vector2 ret{(px() + p.unpackDpx()), (py() + p.unpackDpy())};
0388 return ret;
0389 }
0390
0391 MET::Vector MET::shiftedP3_74x(MET::METUncertainty shift, MET::METCorrectionLevel level) const {
0392 if (level != Type1 && level != Raw)
0393 throw cms::Exception("Unsupported", "MET uncertainties only supported for Raw and Type1 in 74X samples \n");
0394 const std::vector<PackedMETUncertainty> &v = (level == Type1 ? uncertaintiesType1_ : uncertaintiesRaw_);
0395 if (v.empty())
0396 throw cms::Exception("Unsupported", "MET uncertainties not available for the specified correction type\n");
0397 if (v.size() == 1) {
0398 if (shift != MET::METUncertainty::NoShift)
0399 throw cms::Exception(
0400 "Unsupported",
0401 "MET uncertainties not available for the specified correction type (only central value available)\n");
0402 auto const &p = v.front();
0403 return Vector(px() + p.unpackDpx(), py() + p.unpackDpy(), 0);
0404 }
0405 auto const &p = v[shift];
0406 return Vector(px() + p.unpackDpx(), py() + p.unpackDpy(), 0);
0407 }
0408
0409 MET::LorentzVector MET::shiftedP4_74x(METUncertainty shift, MET::METCorrectionLevel level) const {
0410 if (level != Type1 && level != Raw)
0411 throw cms::Exception("Unsupported", "MET uncertainties only supported for Raw and Type1 in 74X samples\n");
0412 const std::vector<PackedMETUncertainty> &v = (level == Type1 ? uncertaintiesType1_ : uncertaintiesRaw_);
0413 if (v.empty())
0414 throw cms::Exception("Unsupported", "MET uncertainties not available for the specified correction type\n");
0415 if (v.size() == 1) {
0416 if (shift != MET::METUncertainty::NoShift)
0417 throw cms::Exception(
0418 "Unsupported",
0419 "MET uncertainties not available for the specified correction type (only central value available)\n");
0420 auto const &p = v.front();
0421 double x = px() + p.unpackDpx(), y = py() + p.unpackDpy();
0422 return LorentzVector(x, y, 0, std::hypot(x, y));
0423 }
0424 auto const &p = v[shift];
0425 double x = px() + p.unpackDpx(), y = py() + p.unpackDpy();
0426 return LorentzVector(x, y, 0, std::hypot(x, y));
0427 }
0428
0429 double MET::shiftedSumEt_74x(MET::METUncertainty shift, MET::METCorrectionLevel level) const {
0430 if (level != Type1 && level != Raw)
0431 throw cms::Exception("Unsupported", "MET uncertainties only supported for Raw and Type1 in 74X samples\n");
0432 const std::vector<PackedMETUncertainty> &v = (level == Type1 ? uncertaintiesType1_ : uncertaintiesRaw_);
0433 if (v.empty())
0434 throw cms::Exception("Unsupported", "MET uncertainties not available for the specified correction type\n");
0435 if (v.size() == 1) {
0436 if (shift != MET::METUncertainty::NoShift)
0437 throw cms::Exception(
0438 "Unsupported",
0439 "MET uncertainties not available for the specified correction type (only central value available)\n");
0440 return sumEt() + v.front().unpackDSumEt();
0441 }
0442 return sumEt() + v[shift].unpackDSumEt();
0443 }
0444
0445 #include "DataFormats/Math/interface/libminifloat.h"
0446
0447 MET::UnpackedMETUncertainty MET::PackedMETUncertainty::unpack() const {
0448 auto dpx = MiniFloatConverter::float16to32(packedDpx_);
0449 auto dpy = MiniFloatConverter::float16to32(packedDpy_);
0450 auto dsumEt = MiniFloatConverter::float16to32(packedDSumEt_);
0451 return UnpackedMETUncertainty(dpx, dpy, dsumEt);
0452 }
0453
0454 float MET::PackedMETUncertainty::unpackDpx() const { return MiniFloatConverter::float16to32(packedDpx_); }
0455
0456 float MET::PackedMETUncertainty::unpackDpy() const { return MiniFloatConverter::float16to32(packedDpy_); }
0457
0458 float MET::PackedMETUncertainty::unpackDSumEt() const { return MiniFloatConverter::float16to32(packedDSumEt_); }
0459
0460 void MET::PackedMETUncertainty::pack(float dpx, float dpy, float dsumEt) {
0461 packedDpx_ = MiniFloatConverter::float32to16(dpx);
0462 packedDpy_ = MiniFloatConverter::float32to16(dpy);
0463 packedDSumEt_ = MiniFloatConverter::float32to16(dsumEt);
0464 }