CMS 3D CMS Logo
MET.cc
Go to the documentation of this file.
1 //
2 //
3 
4 #include "DataFormats/PatCandidates/interface/MET.h"
5 
6 using namespace pat;
7 
9 MET::MET() { initCorMap(); }
10 
12 MET::MET(const reco::MET &aMET) : PATObject<reco::MET>(aMET) {
13  const reco::CaloMET *calo = dynamic_cast<const reco::CaloMET *>(&aMET);
14  if (calo != nullptr)
15  caloMET_.push_back(calo->getSpecific());
16  const reco::PFMET *pf = dynamic_cast<const reco::PFMET *>(&aMET);
17  if (pf != nullptr)
18  pfMET_.push_back(pf->getSpecific());
19  const pat::MET *pm = dynamic_cast<const pat::MET *>(&aMET);
20  if (pm != nullptr)
21  this->operator=(*pm);
22 
23  metSig_ = 0.;
24  sumPtUnclustered_ = 0.;
25  initCorMap();
26 }
27 
29 MET::MET(const edm::RefToBase<reco::MET> &aMETRef) : PATObject<reco::MET>(aMETRef) {
30  const reco::CaloMET *calo = dynamic_cast<const reco::CaloMET *>(aMETRef.get());
31  if (calo != nullptr)
32  caloMET_.push_back(calo->getSpecific());
33  const reco::PFMET *pf = dynamic_cast<const reco::PFMET *>(aMETRef.get());
34  if (pf != nullptr)
35  pfMET_.push_back(pf->getSpecific());
36  const pat::MET *pm = dynamic_cast<const pat::MET *>(aMETRef.get());
37  if (pm != nullptr)
38  this->operator=(*pm);
39 
40  metSig_ = 0.;
41  sumPtUnclustered_ = 0.;
42  initCorMap();
43 }
44 
46 MET::MET(const edm::Ptr<reco::MET> &aMETRef) : PATObject<reco::MET>(aMETRef) {
47  const reco::CaloMET *calo = dynamic_cast<const reco::CaloMET *>(aMETRef.get());
48  if (calo != nullptr)
49  caloMET_.push_back(calo->getSpecific());
50  const reco::PFMET *pf = dynamic_cast<const reco::PFMET *>(aMETRef.get());
51  if (pf != nullptr)
52  pfMET_.push_back(pf->getSpecific());
53  const pat::MET *pm = dynamic_cast<const pat::MET *>(aMETRef.get());
54  if (pm != nullptr)
55  this->operator=(*pm);
56 
57  metSig_ = 0.;
58  sumPtUnclustered_ = 0.;
59  initCorMap();
60 }
61 
63 MET::MET(MET const &iOther)
64  : PATObject<reco::MET>(iOther),
65  genMET_(iOther.genMET_),
66  caloMET_(iOther.caloMET_),
67  pfMET_(iOther.pfMET_),
68  metSig_(iOther.metSig_),
69  sumPtUnclustered_(iOther.sumPtUnclustered_),
70  uncertaintiesRaw_(iOther.uncertaintiesRaw_), //74X reading compatibility
71  uncertaintiesType1_(iOther.uncertaintiesType1_), //74X compatibility
72  uncertaintiesType1p2_(iOther.uncertaintiesType1p2_), //74X compatibility
73  uncertainties_(iOther.uncertainties_),
74  corrections_(iOther.corrections_),
75  caloPackedMet_(iOther.caloPackedMet_) {
76  initCorMap();
77 }
78 
80 // old uncertainties discarded on purpose to avoid confusion
81 MET::MET(const reco::MET &corMET, const MET &srcMET)
82  : PATObject<reco::MET>(corMET),
83  genMET_(srcMET.genMET_),
84  caloMET_(srcMET.caloMET_),
85  pfMET_(srcMET.pfMET_),
86  metSig_(srcMET.metSig_),
87  sumPtUnclustered_(srcMET.sumPtUnclustered_),
88  caloPackedMet_(srcMET.caloPackedMet_) {
89  setSignificanceMatrix(srcMET.getSignificanceMatrix());
90 
91  initCorMap();
92 }
93 
95 MET::~MET() {}
96 
97 MET &MET::operator=(MET const &iOther) {
98  PATObject<reco::MET>::operator=(iOther);
99  genMET_ = iOther.genMET_;
100  caloMET_ = iOther.caloMET_;
101  pfMET_ = iOther.pfMET_;
102  uncertaintiesRaw_ = iOther.uncertaintiesRaw_; //74X compatibility
103  uncertaintiesType1_ = iOther.uncertaintiesType1_;
104  uncertaintiesType1p2_ = iOther.uncertaintiesType1p2_;
105  uncertainties_ = iOther.uncertainties_;
106  corrections_ = iOther.corrections_;
107  metSig_ = iOther.metSig_;
108  sumPtUnclustered_ = iOther.sumPtUnclustered_;
109  caloPackedMet_ = iOther.caloPackedMet_;
110 
111  return *this;
112 }
113 
115 const reco::GenMET *MET::genMET() const { return (!genMET_.empty() ? &genMET_.front() : nullptr); }
116 
118 void MET::setGenMET(const reco::GenMET &gm) {
119  genMET_.clear();
120  genMET_.push_back(gm);
121 }
122 
123 //Method to set the MET significance
124 void MET::setMETSignificance(const double &metSig) { metSig_ = metSig; }
125 
126 double MET::metSignificance() const { return metSig_; }
127 
128 void MET::setMETSumPtUnclustered(const double &sumPtUnclustered) { sumPtUnclustered_ = sumPtUnclustered; }
129 
130 double MET::metSumPtUnclustered() const { return sumPtUnclustered_; }
131 
132 void MET::initCorMap() {
133  std::vector<MET::METCorrectionType> tmpRaw;
134  std::vector<MET::METCorrectionType> tmpType1;
135  std::vector<MET::METCorrectionType> tmpType01;
136  std::vector<MET::METCorrectionType> tmpTypeXY;
137  std::vector<MET::METCorrectionType> tmpType1XY;
138  std::vector<MET::METCorrectionType> tmpType01XY;
139  std::vector<MET::METCorrectionType> tmpType1Smear;
140  std::vector<MET::METCorrectionType> tmpType01Smear;
141  std::vector<MET::METCorrectionType> tmpType1SmearXY;
142  std::vector<MET::METCorrectionType> tmpType01SmearXY;
143 
144  tmpRaw.push_back(MET::None);
145 
146  tmpType1.push_back(MET::T1);
147  tmpType01.push_back(MET::T1);
148  tmpType1XY.push_back(MET::T1);
149  tmpType01XY.push_back(MET::T1);
150  tmpType1Smear.push_back(MET::T1);
151  tmpType01Smear.push_back(MET::T1);
152  tmpType1SmearXY.push_back(MET::T1);
153  tmpType01SmearXY.push_back(MET::T1);
154 
155  tmpType01.push_back(MET::T0);
156  tmpType01XY.push_back(MET::T0);
157  tmpType01Smear.push_back(MET::T0);
158  tmpType01SmearXY.push_back(MET::T0);
159 
160  tmpType1Smear.push_back(MET::Smear);
161  tmpType01Smear.push_back(MET::Smear);
162  tmpType1SmearXY.push_back(MET::Smear);
163  tmpType01SmearXY.push_back(MET::Smear);
164 
165  tmpTypeXY.push_back(MET::TXYForRaw);
166  tmpType1XY.push_back(MET::TXY);
167  tmpType01XY.push_back(MET::TXYForT01);
168  tmpType1SmearXY.push_back(MET::TXYForT1Smear);
169  tmpType01SmearXY.push_back(MET::TXYForT01Smear);
170 
171  corMap_[MET::Raw] = tmpRaw;
172  corMap_[MET::Type1] = tmpType1;
173  corMap_[MET::Type01] = tmpType01;
174  corMap_[MET::TypeXY] = tmpTypeXY;
175  corMap_[MET::Type1XY] = tmpType1XY;
176  corMap_[MET::Type01XY] = tmpType01XY;
177  corMap_[MET::Type1Smear] = tmpType1Smear;
178  corMap_[MET::Type01Smear] = tmpType01Smear;
179  corMap_[MET::Type1SmearXY] = tmpType1SmearXY;
180  corMap_[MET::Type01SmearXY] = tmpType01SmearXY;
181 
182  //specific calo case
183  std::vector<MET::METCorrectionType> tmpRawCalo;
184  tmpRawCalo.push_back(MET::Calo);
185  corMap_[MET::RawCalo] = tmpRawCalo;
186 
187  //specific chs case
188  std::vector<MET::METCorrectionType> tmpRawChs;
189  tmpRawChs.push_back(MET::Chs);
190  corMap_[MET::RawChs] = tmpRawChs;
191 
192  //specific trk case
193  std::vector<MET::METCorrectionType> tmpRawTrk;
194  tmpRawTrk.push_back(MET::Trk);
195  corMap_[MET::RawTrk] = tmpRawTrk;
196 
197  //specific deep response tune case
198  std::vector<MET::METCorrectionType> tmpDeepResponse;
199  tmpDeepResponse.push_back(MET::DeepResponseTune);
200  corMap_[MET::RawDeepResponseTune] = tmpDeepResponse;
201 
202  //specific deep resolution tune case
203  std::vector<MET::METCorrectionType> tmpDeepResolution;
204  tmpDeepResolution.push_back(MET::DeepResolutionTune);
205  corMap_[MET::RawDeepResolutionTune] = tmpDeepResolution;
206 }
207 
208 const MET::PackedMETUncertainty MET::findMETTotalShift(MET::METCorrectionLevel cor, MET::METUncertainty shift) const {
209  //find corrections shifts =============================
210  std::map<MET::METCorrectionLevel, std::vector<MET::METCorrectionType> >::const_iterator itCor_ = corMap_.find(cor);
211  if (itCor_ == corMap_.end())
212  throw cms::Exception("Unsupported", "Specified MET correction scheme does not exist");
213 
214  bool isSmeared = false;
215  MET::PackedMETUncertainty totShift;
216  unsigned int scor = itCor_->second.size();
217  for (unsigned int i = 0; i < scor; i++) {
218  totShift.add(corrections_[itCor_->second[i]].dpx(),
219  corrections_[itCor_->second[i]].dpy(),
220  corrections_[itCor_->second[i]].dsumEt());
221 
222  if (itCor_->first >= MET::Type1Smear)
223  isSmeared = true;
224  }
225 
226  //find uncertainty shift =============================
227 
228  if (uncertainties_.empty())
229  return totShift;
230 
231  if (shift >= MET::METUncertaintySize)
232  throw cms::Exception("Unsupported", "MET uncertainty does not exist");
233  if (isSmeared && shift <= MET::JetResDown)
234  shift = (MET::METUncertainty)(MET::METUncertaintySize + shift + 1);
235 
236  totShift.add(uncertainties_[shift].dpx(), uncertainties_[shift].dpy(), uncertainties_[shift].dsumEt());
237 
238  return totShift;
239 }
240 
241 MET::Vector2 MET::shiftedP2(MET::METUncertainty shift, MET::METCorrectionLevel cor) const {
242  Vector2 vo;
243 
244  //backward compatibility with 74X samples -> the only one
245  // with uncertaintiesType1_/uncertaintiesRaw_ not empty
246  //will be removed once 74X is not used anymore
247  if (!uncertaintiesType1_.empty() || !uncertaintiesRaw_.empty()) {
248  if (cor != MET::METCorrectionLevel::RawCalo) {
249  vo = shiftedP2_74x(shift, cor);
250  } else {
251  Vector2 ret{caloPackedMet_.dpx(), caloPackedMet_.dpy()};
252  vo = ret;
253  }
254  } else {
255  const MET::PackedMETUncertainty &v = findMETTotalShift(cor, shift);
256  Vector2 ret{(px() + v.dpx()), (py() + v.dpy())};
257  //return ret;
258  vo = ret;
259  }
260  return vo;
261 }
262 MET::Vector MET::shiftedP3(MET::METUncertainty shift, MET::METCorrectionLevel cor) const {
263  Vector vo;
264 
265  //backward compatibility with 74X samples -> the only one
266  // with uncertaintiesType1_/uncertaintiesRaw_ not empty
267  //will be removed once 74X is not used anymore
268  if (!uncertaintiesType1_.empty() || !uncertaintiesRaw_.empty()) {
269  if (cor != MET::METCorrectionLevel::RawCalo) {
270  vo = shiftedP3_74x(shift, cor);
271  } else {
272  Vector tmp(caloPackedMet_.dpx(), caloPackedMet_.dpy(), 0);
273  vo = tmp;
274  }
275  } else {
276  const MET::PackedMETUncertainty &v = findMETTotalShift(cor, shift);
277  //return Vector(px() + v.dpx(), py() + v.dpy(), 0);
278  Vector tmp(px() + v.dpx(), py() + v.dpy(), 0);
279  vo = tmp;
280  }
281  return vo;
282 }
283 MET::LorentzVector MET::shiftedP4(METUncertainty shift, MET::METCorrectionLevel cor) const {
284  LorentzVector vo;
285 
286  //backward compatibility with 74X samples -> the only one
287  // with uncertaintiesType1_/uncertaintiesRaw_ not empty
288  //will be removed once 74X is not used anymore
289  if (!uncertaintiesType1_.empty() || !uncertaintiesRaw_.empty()) {
290  if (cor != MET::METCorrectionLevel::RawCalo) {
291  vo = shiftedP4_74x(shift, cor);
292  } else {
293  double x = caloPackedMet_.dpx(), y = caloPackedMet_.dpy();
294  LorentzVector tmp(x, y, 0, std::hypot(x, y));
295  vo = tmp;
296  }
297  } else {
298  const MET::PackedMETUncertainty &v = findMETTotalShift(cor, shift);
299  double x = px() + v.dpx(), y = py() + v.dpy();
300  //return LorentzVector(x, y, 0, std::hypot(x,y));
301  LorentzVector tmp(x, y, 0, std::hypot(x, y));
302  vo = tmp;
303  }
304  return vo;
305 }
306 double MET::shiftedSumEt(MET::METUncertainty shift, MET::METCorrectionLevel cor) const {
307  double sumEto;
308 
309  //backward compatibility with 74X samples -> the only one
310  // with uncertaintiesType1_/uncertaintiesRaw_ not empty
311  //will be removed once 74X is not used anymore
312  if (!uncertaintiesType1_.empty() || !uncertaintiesRaw_.empty()) {
313  if (cor != MET::METCorrectionLevel::RawCalo) {
314  sumEto = shiftedSumEt_74x(shift, cor);
315  } else {
316  sumEto = caloPackedMet_.dsumEt();
317  }
318  } else {
319  const MET::PackedMETUncertainty &v = findMETTotalShift(cor, shift);
320  //return sumEt() + v.dsumEt();
321  sumEto = sumEt() + v.dsumEt();
322  }
323  return sumEto;
324 }
325 
326 MET::Vector2 MET::corP2(MET::METCorrectionLevel cor) const { return shiftedP2(MET::NoShift, cor); }
327 MET::Vector MET::corP3(MET::METCorrectionLevel cor) const { return shiftedP3(MET::NoShift, cor); }
328 MET::LorentzVector MET::corP4(MET::METCorrectionLevel cor) const { return shiftedP4(MET::NoShift, cor); }
329 double MET::corSumEt(MET::METCorrectionLevel cor) const { return shiftedSumEt(MET::NoShift, cor); }
330 
331 MET::Vector2 MET::uncorP2() const { return shiftedP2(MET::NoShift, MET::Raw); }
332 MET::Vector MET::uncorP3() const { return shiftedP3(MET::NoShift, MET::Raw); }
333 MET::LorentzVector MET::uncorP4() const { return shiftedP4(MET::NoShift, MET::Raw); }
334 double MET::uncorSumEt() const { return shiftedSumEt(MET::NoShift, MET::Raw); }
335 
336 void MET::setUncShift(double px, double py, double sumEt, METUncertainty shift, bool isSmeared) {
337  if (uncertainties_.empty()) {
338  uncertainties_.resize(METUncertainty::METFullUncertaintySize);
339  }
340 
341  if (isSmeared && shift <= MET::JetResDown) {
342  //changing reference to only get the uncertainty shift and not the smeared one
343  // which is performed independently
344  shift = (MET::METUncertainty)(METUncertainty::METUncertaintySize + shift + 1);
345  const PackedMETUncertainty &ref = uncertainties_[METUncertainty::NoShift];
346  uncertainties_[shift].set(
347  px + ref.dpx() - this->px(), py + ref.dpy() - this->py(), sumEt + ref.dsumEt() - this->sumEt());
348  } else
349  uncertainties_[shift].set(px - this->px(), py - this->py(), sumEt - this->sumEt());
350 }
351 
352 void MET::setCorShift(double px, double py, double sumEt, MET::METCorrectionType level) {
353  if (corrections_.empty()) {
354  corrections_.resize(MET::METCorrectionType::METCorrectionTypeSize);
355  }
356 
357  corrections_[level].set(px - this->px(), py - this->py(), sumEt - this->sumEt());
358 }
359 
360 MET::Vector2 MET::caloMETP2() const {
361  return shiftedP2(MET::METUncertainty::NoShift, MET::METCorrectionLevel::RawCalo);
362 }
363 
364 double MET::caloMETPt() const { return caloMETP2().pt(); }
365 
366 double MET::caloMETPhi() const { return caloMETP2().phi(); }
367 
368 double MET::caloMETSumEt() const { return shiftedSumEt(MET::NoShift, MET::RawCalo); }
369 
370 // functions to access to 74X samples ========================================================
371 MET::Vector2 MET::shiftedP2_74x(MET::METUncertainty shift, MET::METCorrectionLevel level) const {
372  if (level != Type1 && level != Raw)
373  throw cms::Exception("Unsupported", "MET uncertainties only supported for Raw and Type1 in 74X samples \n");
374  const std::vector<PackedMETUncertainty> &v = (level == Type1 ? uncertaintiesType1_ : uncertaintiesRaw_);
375  if (v.empty())
376  throw cms::Exception("Unsupported", "MET uncertainties not available for the specified correction type\n");
377  if (v.size() == 1) {
378  if (shift != MET::METUncertainty::NoShift)
379  throw cms::Exception(
380  "Unsupported",
381  "MET uncertainties not available for the specified correction type (only central value available)\n");
382  return Vector2{(px() + v.front().dpx()), (py() + v.front().dpy())};
383  }
384  Vector2 ret{(px() + v[shift].dpx()), (py() + v[shift].dpy())};
385  return ret;
386 }
387 
388 MET::Vector MET::shiftedP3_74x(MET::METUncertainty shift, MET::METCorrectionLevel level) const {
389  if (level != Type1 && level != Raw)
390  throw cms::Exception("Unsupported", "MET uncertainties only supported for Raw and Type1 in 74X samples \n");
391  const std::vector<PackedMETUncertainty> &v = (level == Type1 ? uncertaintiesType1_ : uncertaintiesRaw_);
392  if (v.empty())
393  throw cms::Exception("Unsupported", "MET uncertainties not available for the specified correction type\n");
394  if (v.size() == 1) {
395  if (shift != MET::METUncertainty::NoShift)
396  throw cms::Exception(
397  "Unsupported",
398  "MET uncertainties not available for the specified correction type (only central value available)\n");
399  return Vector(px() + v.front().dpx(), py() + v.front().dpy(), 0);
400  }
401  return Vector(px() + v[shift].dpx(), py() + v[shift].dpy(), 0);
402 }
403 
404 MET::LorentzVector MET::shiftedP4_74x(METUncertainty shift, MET::METCorrectionLevel level) const {
405  if (level != Type1 && level != Raw)
406  throw cms::Exception("Unsupported", "MET uncertainties only supported for Raw and Type1 in 74X samples\n");
407  const std::vector<PackedMETUncertainty> &v = (level == Type1 ? uncertaintiesType1_ : uncertaintiesRaw_);
408  if (v.empty())
409  throw cms::Exception("Unsupported", "MET uncertainties not available for the specified correction type\n");
410  if (v.size() == 1) {
411  if (shift != MET::METUncertainty::NoShift)
412  throw cms::Exception(
413  "Unsupported",
414  "MET uncertainties not available for the specified correction type (only central value available)\n");
415  double x = px() + v.front().dpx(), y = py() + v.front().dpy();
416  return LorentzVector(x, y, 0, std::hypot(x, y));
417  }
418  double x = px() + v[shift].dpx(), y = py() + v[shift].dpy();
419  return LorentzVector(x, y, 0, std::hypot(x, y));
420 }
421 
422 double MET::shiftedSumEt_74x(MET::METUncertainty shift, MET::METCorrectionLevel level) const {
423  if (level != Type1 && level != Raw)
424  throw cms::Exception("Unsupported", "MET uncertainties only supported for Raw and Type1 in 74X samples\n");
425  const std::vector<PackedMETUncertainty> &v = (level == Type1 ? uncertaintiesType1_ : uncertaintiesRaw_);
426  if (v.empty())
427  throw cms::Exception("Unsupported", "MET uncertainties not available for the specified correction type\n");
428  if (v.size() == 1) {
429  if (shift != MET::METUncertainty::NoShift)
430  throw cms::Exception(
431  "Unsupported",
432  "MET uncertainties not available for the specified correction type (only central value available)\n");
433  return sumEt() + v.front().dsumEt();
434  }
435  return sumEt() + v[shift].dsumEt();
436 }
437 
438 #include "DataFormats/Math/interface/libminifloat.h"
439 
440 void MET::PackedMETUncertainty::pack() {
441  packedDpx_ = MiniFloatConverter::float32to16(dpx_);
442  packedDpy_ = MiniFloatConverter::float32to16(dpy_);
443  packedDSumEt_ = MiniFloatConverter::float32to16(dsumEt_);
444 }
445 void MET::PackedMETUncertainty::unpack() const {
446  unpacked_ = true;
447  dpx_ = MiniFloatConverter::float16to32(packedDpx_);
448  dpy_ = MiniFloatConverter::float16to32(packedDpy_);
449  dsumEt_ = MiniFloatConverter::float16to32(packedDSumEt_);
450 }
personalPlayback.level
level
Definition: personalPlayback.py:22
pat::MET::Smear
Definition: MET.h:200
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:355
pat::MET::~MET
~MET() override
destructor
Definition: MET.cc:95
met_cff.sumPtUnclustered
sumPtUnclustered
Definition: met_cff.py:20
pat::MET::caloMETP2
Vector2 caloMETP2() const
Definition: MET.cc:360
pat::MET::TXYForT01Smear
Definition: MET.h:199
reco::Candidate::Vector
math::XYZVector Vector
point in the space
Definition: Candidate.h:42
mps_fire.i
i
Definition: mps_fire.py:355
pat::MET::PackedMETUncertainty::dpy
double dpy() const
Definition: MET.h:287
pat::MET::setMETSignificance
void setMETSignificance(const double &metSig)
Definition: MET.cc:124
L1TowerCalibrationProducer_cfi.calo
calo
Definition: L1TowerCalibrationProducer_cfi.py:59
pat::MET::genMET
const reco::GenMET * genMET() const
return the associated GenMET
Definition: MET.cc:115
pat::MET::DeepResolutionTune
Definition: MET.h:205
pat::MET::setCorShift
void setCorShift(double px, double py, double sumEt, METCorrectionType level)
Definition: MET.cc:352
pat::MET::corP2
Vector2 corP2(METCorrectionLevel level=Type1) const
Definition: MET.cc:326
pat::MET::setUncShift
void setUncShift(double px, double py, double sumEt, METUncertainty shift, bool isSmeared=false)
Definition: MET.cc:336
pat::MET::corP4
LorentzVector corP4(METCorrectionLevel level=Type1) const
Definition: MET.cc:328
pat::MET::shiftedP2_74x
Vector2 shiftedP2_74x(METUncertainty shift, METCorrectionLevel level) const
Definition: MET.cc:371
pat::MET::Type01XY
Definition: MET.h:179
multPhiCorr_741_25nsDY_cfi.py
py
Definition: multPhiCorr_741_25nsDY_cfi.py:12
pat::MET::uncertaintiesType1p2_
std::vector< PackedMETUncertainty > uncertaintiesType1p2_
Definition: MET.h:339
pat::MET::Type1Smear
Definition: MET.h:180
pat::MET::METUncertainty
METUncertainty
Definition: MET.h:152
pat::MET::caloMETSumEt
double caloMETSumEt() const
Definition: MET.cc:368
pat::MET::uncorSumEt
double uncorSumEt() const
Definition: MET.cc:334
reco::candidate::const_iterator
Definition: const_iterator.h:14
reco::MET::sumEt
double sumEt() const
Definition: MET.h:56
pat::MET::uncorP3
Vector uncorP3() const
Definition: MET.cc:332
pat::MET::Type01SmearXY
Definition: MET.h:183
pat::MET::T1
Definition: MET.h:193
pat::MET::Trk
Definition: MET.h:203
objects.METAnalyzer.sumEt
sumEt
Definition: METAnalyzer.py:97
pat::MET::shiftedP3
Vector shiftedP3(METUncertainty shift, METCorrectionLevel level=Type1) const
Definition: MET.cc:262
pat::MET::pfMET_
std::vector< SpecificPFMETData > pfMET_
Definition: MET.h:324
pat::MET::Vector2::phi
double phi() const
Definition: MET.h:212
edm::Ptr::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ptr.h:139
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
findQualityFiles.v
v
Definition: findQualityFiles.py:179
pat::MET::TXYForT1Smear
Definition: MET.h:198
createJobs.tmp
tmp
align.sh
Definition: createJobs.py:716
pat::MET::Vector2::pt
double pt() const
Definition: MET.h:211
pat::MET::metSumPtUnclustered
double metSumPtUnclustered() const
Definition: MET.cc:130
reco::CaloMET
Definition: CaloMET.h:21
pat::MET::shiftedSumEt
double shiftedSumEt(METUncertainty shift, METCorrectionLevel level=Type1) const
Definition: MET.cc:306
reco::MET::setSignificanceMatrix
void setSignificanceMatrix(const reco::METCovMatrix &matrix)
Definition: MET.cc:142
reco::MET
Definition: MET.h:41
pat::MET::PackedMETUncertainty::packedDSumEt_
uint16_t packedDSumEt_
Definition: MET.h:315
pat::MET::TXYForT01
Definition: MET.h:197
reco::GenMET
Definition: GenMET.h:20
pat::MET::Type01Smear
Definition: MET.h:181
pat::MET::shiftedP4_74x
LorentzVector shiftedP4_74x(METUncertainty shift, METCorrectionLevel level) const
Definition: MET.cc:404
pat::MET::RawDeepResponseTune
Definition: MET.h:187
pat::MET::Raw
Definition: MET.h:174
libminifloat.h
pat::MET::RawCalo
Definition: MET.h:184
pat::MET::METUncertaintySize
Definition: MET.h:168
pat::MET::PackedMETUncertainty::dsumEt
double dsumEt() const
Definition: MET.h:292
reco::LeafCandidate::py
double py() const final
y coordinate of momentum vector
Definition: LeafCandidate.h:142
pat::MET::shiftedP3_74x
Vector shiftedP3_74x(METUncertainty shift, METCorrectionLevel level) const
Definition: MET.cc:388
pat::MET::PackedMETUncertainty::dpx
double dpx() const
Definition: MET.h:282
pat::PATObject
Templated PAT object container.
Definition: PATObject.h:48
reco::LeafCandidate::y
double y() const final
rapidity
Definition: LeafCandidate.h:156
pat::MET::uncorP2
Vector2 uncorP2() const
Definition: MET.cc:331
pat::MET::PackedMETUncertainty::dpy_
float dpy_
Definition: MET.h:313
pat::MET::Chs
Definition: MET.h:202
edm::RefToBase::get
value_type const * get() const
Definition: RefToBase.h:209
pat::MET::shiftedP2
Vector2 shiftedP2(METUncertainty shift, METCorrectionLevel level=Type1) const
Definition: MET.cc:241
pat::MET::PackedMETUncertainty::dpx_
float dpx_
Definition: MET.h:313
pat::MET::setGenMET
void setGenMET(const reco::GenMET &gm)
set the associated GenMET
Definition: MET.cc:118
reco::PFMET
Definition: PFMET.h:18
pat::MET::JetResDown
Definition: MET.h:154
pat::MET::PackedMETUncertainty::dsumEt_
float dsumEt_
Definition: MET.h:313
pat::MET::RawTrk
Definition: MET.h:186
pat::MET::corrections_
std::vector< PackedMETUncertainty > corrections_
Definition: MET.h:342
pat::MET::shiftedSumEt_74x
double shiftedSumEt_74x(METUncertainty shift, METCorrectionLevel level) const
Definition: MET.cc:422
pat::MET::corP3
Vector corP3(METCorrectionLevel level=Type1) const
Definition: MET.cc:327
pat::MET::Type01
Definition: MET.h:176
pat::MET::caloPackedMet_
PackedMETUncertainty caloPackedMet_
Definition: MET.h:344
pat::MET::PackedMETUncertainty
this below should be private but Reflex doesn't like it
Definition: MET.h:270
pat::MET::Type1SmearXY
Definition: MET.h:182
pat::MET::caloMET_
std::vector< SpecificCaloMETData > caloMET_
Definition: MET.h:322
MiniFloatConverter::float16to32
static float float16to32(uint16_t h)
Definition: libminifloat.h:12
pat::MET::Type1
Definition: MET.h:175
pat::MET::RawChs
Definition: MET.h:185
pat::MET
Analysis-level MET class.
Definition: MET.h:40
pat::MET::PackedMETUncertainty::unpack
void unpack() const
Definition: MET.cc:445
pat::MET::initCorMap
void initCorMap()
Definition: MET.cc:132
pat
Definition: HeavyIon.h:7
pat::MET::operator=
MET & operator=(MET const &)
Definition: MET.cc:97
MET.h
pat::MET::genMET_
std::vector< reco::GenMET > genMET_
Definition: MET.h:320
pat::MET::uncertaintiesRaw_
std::vector< PackedMETUncertainty > uncertaintiesRaw_
Definition: MET.h:339
edm::Ptr< reco::MET >
pat::MET::PackedMETUncertainty::pack
void pack()
Definition: MET.cc:440
pat::MET::TypeXY
Definition: MET.h:177
pat::MET::MET
MET()
default constructor
Definition: MET.cc:9
pat::MET::METCorrectionLevel
METCorrectionLevel
Definition: MET.h:173
multPhiCorr_741_25nsDY_cfi.px
px
Definition: multPhiCorr_741_25nsDY_cfi.py:10
pat::MET::corSumEt
double corSumEt(METCorrectionLevel level=Type1) const
Definition: MET.cc:329
pat::MET::metSig_
double metSig_
Definition: MET.h:327
pat::MET::Vector2
Definition: MET.h:209
pat::MET::NoShift
Definition: MET.h:167
pat::MET::shiftedP4
LorentzVector shiftedP4(METUncertainty shift, METCorrectionLevel level=Type1) const
Definition: MET.cc:283
edm::shift
static unsigned const int shift
Definition: LuminosityBlockID.cc:7
pat::MET::caloMETPt
double caloMETPt() const
Definition: MET.cc:364
pat::MET::TXY
Definition: MET.h:195
packedPFCandidateRefMixer_cfi.pf
pf
Definition: packedPFCandidateRefMixer_cfi.py:4
pat::MET::METCorrectionType
METCorrectionType
Definition: MET.h:191
pat::MET::T0
Definition: MET.h:194
pat::MET::sumPtUnclustered_
double sumPtUnclustered_
Definition: MET.h:329
correctionTermsCaloMet_cff.srcMET
srcMET
Definition: correctionTermsCaloMet_cff.py:14
pat::MET::None
Definition: MET.h:192
Exception
Definition: hltDiff.cc:246
edm::RefToBase
Definition: AssociativeIterator.h:54
pat::MET::PackedMETUncertainty::add
void add(float dpx, float dpy, float dsumEt)
Definition: MET.h:304
pat::MET::PackedMETUncertainty::packedDpy_
uint16_t packedDpy_
Definition: MET.h:315
pat::MET::metSignificance
double metSignificance() const
Definition: MET.cc:126
pat::MET::caloMETPhi
double caloMETPhi() const
Definition: MET.cc:366
cms::Exception
Definition: Exception.h:70
pat::MET::findMETTotalShift
const PackedMETUncertainty findMETTotalShift(MET::METCorrectionLevel cor, MET::METUncertainty shift) const
Definition: MET.cc:208
reco::Candidate::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:36
pat::MET::corMap_
std::map< MET::METCorrectionLevel, std::vector< MET::METCorrectionType > > corMap_
Definition: MET.h:333
pat::MET::TXYForRaw
Definition: MET.h:196
pat::MET::uncertaintiesType1_
std::vector< PackedMETUncertainty > uncertaintiesType1_
Definition: MET.h:339
pat::MET::Type1XY
Definition: MET.h:178
pat::MET::uncertainties_
std::vector< PackedMETUncertainty > uncertainties_
Definition: MET.h:341
reco::LeafCandidate::px
double px() const final
x coordinate of momentum vector
Definition: LeafCandidate.h:140
pat::MET::PackedMETUncertainty::packedDpx_
uint16_t packedDpx_
Definition: MET.h:315
MiniFloatConverter::float32to16
static uint16_t float32to16(float x)
Definition: libminifloat.h:20
pat::MET::RawDeepResolutionTune
Definition: MET.h:188
reco::LeafCandidate::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: LeafCandidate.h:23
reco::MET::dsumEt
std::vector< double > dsumEt() const
Definition: MET.cc:117
pat::MET::uncorP4
LorentzVector uncorP4() const
Definition: MET.cc:333
pat::MET::DeepResponseTune
Definition: MET.h:204
pat::MET::Calo
Definition: MET.h:201
reco::LeafCandidate::Vector
math::XYZVector Vector
point in the space
Definition: LeafCandidate.h:29
pat::MET::setMETSumPtUnclustered
void setMETSumPtUnclustered(const double &sumPtUnclustered)
Definition: MET.cc:128
Generated for CMSSW Reference Manual by doxygen 1.8.16