CMS 3D CMS Logo
ParametrizationHelper.cc
Go to the documentation of this file.
1 #include "DataFormats/PatCandidates/interface/ParametrizationHelper.h"
2 #include <cmath>
3 #include <Math/CylindricalEta3D.h>
4 #include <Math/Polar3D.h>
5 #include <Math/Cartesian3D.h>
6 #include <Math/DisplacementVector3D.h>
7 #include <Math/Functions.h>
8 
9 using namespace std;
10 
11 //pat::helper::ParametrizationHelper::POLAR_ZERO();
12 //pat::helper::ParametrizationHelper::CARTESIAN_ZERO();
13 
14 pat::CandKinResolution::Parametrization pat::helper::ParametrizationHelper::fromString(const std::string &name) {
15  using namespace std;
16 
17  typedef pat::CandKinResolution::Parametrization Parametrization;
18 
19  static map<string, Parametrization> const parMaps = {{"Cart", pat::CandKinResolution::Cart},
20  {"ECart", pat::CandKinResolution::ECart},
21  {"MCCart", pat::CandKinResolution::MCCart},
22  {"Spher", pat::CandKinResolution::Spher},
23  {"ESpher", pat::CandKinResolution::ESpher},
24  {"MCSpher", pat::CandKinResolution::MCSpher},
25  {"MCPInvSpher", pat::CandKinResolution::MCPInvSpher},
26  {"EtEtaPhi", pat::CandKinResolution::EtEtaPhi},
27  {"EtThetaPhi", pat::CandKinResolution::EtThetaPhi},
28  {"MomDev", pat::CandKinResolution::MomDev},
29  {"EMomDev", pat::CandKinResolution::EMomDev},
30  {"MCMomDev", pat::CandKinResolution::MCMomDev},
31  {"EScaledMomDev", pat::CandKinResolution::EScaledMomDev}};
32  map<string, Parametrization>::const_iterator itP = parMaps.find(name);
33  if (itP == parMaps.end()) {
34  throw cms::Exception("StringResolutionProvider") << "Bad parametrization '" << name.c_str() << "'";
35  }
36  return itP->second;
37 }
38 
39 const char *pat::helper::ParametrizationHelper::name(pat::CandKinResolution::Parametrization param) {
40  switch (param) {
41  case pat::CandKinResolution::Cart:
42  return "Cart";
43  case pat::CandKinResolution::ECart:
44  return "ECart";
45  case pat::CandKinResolution::MCCart:
46  return "MCCart";
47  case pat::CandKinResolution::Spher:
48  return "Spher";
49  case pat::CandKinResolution::ESpher:
50  return "ESpher";
51  case pat::CandKinResolution::MCSpher:
52  return "MCSpher";
53  case pat::CandKinResolution::MCPInvSpher:
54  return "MCPInvSpher";
55  case pat::CandKinResolution::EtEtaPhi:
56  return "EtEtaPhi";
57  case pat::CandKinResolution::EtThetaPhi:
58  return "EtThetaPhi";
59  case pat::CandKinResolution::MomDev:
60  return "MomDev";
61  case pat::CandKinResolution::EMomDev:
62  return "EMomDev";
63  case pat::CandKinResolution::MCMomDev:
64  return "MCMomDev";
65  case pat::CandKinResolution::EScaledMomDev:
66  return "EScaledMomDev";
67  case pat::CandKinResolution::Invalid:
68  return "Invalid";
69  default:
70  return "UNKNOWN";
71  }
72 }
73 
74 math::PtEtaPhiMLorentzVector pat::helper::ParametrizationHelper::polarP4fromParameters(
75  pat::CandKinResolution::Parametrization parametrization,
76  const AlgebraicVector4 &parameters,
77  const math::PtEtaPhiMLorentzVector &initialP4) {
78  math::PtEtaPhiMLorentzVector ret;
79  ROOT::Math::CylindricalEta3D<double> converter;
80  double m2;
81  switch (parametrization) {
82  // ======= CARTESIAN ==========
83  case pat::CandKinResolution::Cart:
84  ret = math::XYZTLorentzVector(parameters[0],
85  parameters[1],
86  parameters[2],
87  sqrt(parameters[0] * parameters[0] + parameters[1] * parameters[1] +
88  parameters[2] * parameters[2] + parameters[3] * parameters[3]));
89  ret.SetM(parameters[3]); // to be sure about roundoffs
90  break;
91  case pat::CandKinResolution::MCCart:
92  ret = math::XYZTLorentzVector(parameters[0],
93  parameters[1],
94  parameters[2],
95  sqrt(parameters[0] * parameters[0] + parameters[1] * parameters[1] +
96  parameters[2] * parameters[2] + initialP4.mass() * initialP4.mass()));
97  ret.SetM(initialP4.mass()); // to be sure about roundoffs
98  break;
99  case pat::CandKinResolution::ECart:
100  ret = math::XYZTLorentzVector(parameters[0], parameters[1], parameters[2], parameters[3]);
101  break;
102  // ======= SPHERICAL ==========
103  case pat::CandKinResolution::Spher:
104  converter = ROOT::Math::Polar3D<double>(parameters[0], parameters[1], 0);
105  ret.SetCoordinates(converter.Rho(), converter.Eta(), parameters[2], parameters[3]);
106  break;
107  case pat::CandKinResolution::MCSpher: // same as above
108  converter = ROOT::Math::Polar3D<double>(parameters[0], parameters[1], 0);
109  ret.SetCoordinates(converter.Rho(), converter.Eta(), parameters[2], initialP4.mass());
110  break;
111  case pat::CandKinResolution::ESpher: //
112  converter = ROOT::Math::Polar3D<double>(parameters[0], parameters[1], 0);
113  m2 = -parameters[0] * parameters[0] + parameters[3] * parameters[3];
114  ret.SetCoordinates(converter.Rho(), converter.Eta(), parameters[2], (m2 > 0 ? sqrt(m2) : 0.0));
115  break;
116  case pat::CandKinResolution::MCPInvSpher: //
117  converter = ROOT::Math::Polar3D<double>(1.0 / parameters[0], parameters[1], 0);
118  ret.SetCoordinates(converter.Rho(), converter.Eta(), parameters[2], initialP4.mass());
119  break;
120  // ======= HEP CYLINDRICAL ==========
121  case pat::CandKinResolution::EtThetaPhi:
122  converter = ROOT::Math::Polar3D<double>(1.0, parameters[1], 0);
123  ret.SetCoordinates(parameters[0], converter.Eta(), parameters[2], 0);
124  break;
125  case pat::CandKinResolution::EtEtaPhi: // as simple as that
126  ret.SetCoordinates(parameters[0], parameters[1], parameters[2], 0);
127  break;
128  // ======= MomentumDeviates ==========
129  case pat::CandKinResolution::MomDev:
130  case pat::CandKinResolution::EMomDev:
131  case pat::CandKinResolution::MCMomDev:
132  case pat::CandKinResolution::EScaledMomDev: {
133  ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double> > p = initialP4.Vect(), uz(0, 0, 1), uph, uth;
134  uph = uz.Cross(p).Unit();
135  uth = p.Cross(uph).Unit();
136  p *= parameters[0];
137  p += uth * parameters[1] + uph * parameters[2];
138  if (parametrization == pat::CandKinResolution::MomDev) {
139  ret.SetCoordinates(p.Rho(), p.Eta(), p.Phi(), initialP4.mass() * parameters[3]);
140  } else if (parametrization == pat::CandKinResolution::EMomDev) {
141  double m2 = ROOT::Math::Square(parameters[3] * initialP4.energy()) - p.Mag2();
142  ret.SetCoordinates(p.Rho(), p.Eta(), p.Phi(), (m2 > 0 ? sqrt(m2) : 0.0));
143  } else if (parametrization == pat::CandKinResolution::EScaledMomDev) {
144  double m2 = ROOT::Math::Square(p.R() * initialP4.E() / initialP4.P()) - p.Mag2();
145  ret.SetCoordinates(p.Rho(), p.Eta(), p.Phi(), (m2 > 0 ? sqrt(m2) : 0.0));
146  } else if (parametrization == pat::CandKinResolution::MCMomDev) {
147  ret.SetCoordinates(p.Rho(), p.Eta(), p.Phi(), initialP4.mass());
148  }
149  break;
150  }
151  // ======= OTHER ==========
152  case pat::CandKinResolution::Invalid:
153  throw cms::Exception("Invalid parametrization") << parametrization;
154  default:
155  throw cms::Exception("Not Implemented")
156  << "getResolEta not yet implemented for parametrization " << parametrization;
157  }
158  return ret;
159 }
160 
161 math::XYZTLorentzVector pat::helper::ParametrizationHelper::p4fromParameters(
162  pat::CandKinResolution::Parametrization parametrization,
163  const AlgebraicVector4 &parameters,
164  const math::XYZTLorentzVector &initialP4) {
165  math::XYZTLorentzVector ret;
166  switch (parametrization) {
167  // ======= CARTESIAN ==========
168  case pat::CandKinResolution::Cart:
169  ret.SetCoordinates(parameters[0],
170  parameters[1],
171  parameters[2],
172  sqrt(parameters[0] * parameters[0] + parameters[1] * parameters[1] +
173  parameters[2] * parameters[2] + parameters[3] * parameters[3]));
174  break;
175  case pat::CandKinResolution::MCCart: // same as above
176  ret.SetCoordinates(parameters[0],
177  parameters[1],
178  parameters[2],
179  sqrt(parameters[0] * parameters[0] + parameters[1] * parameters[1] +
180  parameters[2] * parameters[2] + initialP4.mass() * initialP4.mass()));
181  break;
182  case pat::CandKinResolution::ECart:
183  ret.SetCoordinates(parameters[0], parameters[1], parameters[2], parameters[3]);
184  break;
185  // ======= MomentumDeviates ==========
186  case pat::CandKinResolution::MomDev:
187  case pat::CandKinResolution::EMomDev:
188  case pat::CandKinResolution::MCMomDev:
189  case pat::CandKinResolution::EScaledMomDev: {
190  ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double> > p = initialP4.Vect(), uz(0, 0, 1), uph, uth;
191  uph = uz.Cross(p).Unit();
192  uth = p.Cross(uph).Unit();
193  p *= parameters[0];
194  p += uth * parameters[1] + uph * parameters[2];
195  if (parametrization == pat::CandKinResolution::MomDev) {
196  ret.SetCoordinates(p.X(), p.Y(), p.Z(), sqrt(p.Mag2() + ROOT::Math::Square(initialP4.mass() * parameters[3])));
197  } else if (parametrization == pat::CandKinResolution::EMomDev) {
198  ret.SetCoordinates(p.X(), p.Y(), p.Z(), parameters[3] * initialP4.energy());
199  } else if (parametrization == pat::CandKinResolution::EMomDev) {
200  ret.SetCoordinates(p.X(), p.Y(), p.Z(), p.R() * initialP4.E() / initialP4.P());
201  } else {
202  ret.SetCoordinates(p.X(), p.Y(), p.Z(), sqrt(p.Mag2() + initialP4.mass() * initialP4.mass()));
203  }
204  break;
205  }
206  // ======= ALL OTHERS ==========
207  default:
208  ret = polarP4fromParameters(parametrization, parameters, math::PtEtaPhiMLorentzVector(initialP4));
209  }
210  return ret;
211 }
212 
213 template <typename T>
214 void pat::helper::ParametrizationHelper::setParametersFromAnyVector(
215  pat::CandKinResolution::Parametrization parametrization, AlgebraicVector4 &ret, const T &p4) {
216  switch (parametrization) {
217  // ======= CARTESIAN ==========
218  case pat::CandKinResolution::Cart:
219  ret[0] = p4.px();
220  ret[1] = p4.py();
221  ret[2] = p4.pz();
222  ret[3] = p4.mass();
223  break;
224  case pat::CandKinResolution::MCCart:
225  ret[0] = p4.px();
226  ret[1] = p4.py();
227  ret[2] = p4.pz();
228  ret[3] = p4.mass();
229  break;
230  case pat::CandKinResolution::ECart:
231  ret[0] = p4.px();
232  ret[1] = p4.py();
233  ret[2] = p4.pz();
234  ret[3] = p4.energy();
235  break;
236  // ======= SPHERICAL ==========
237  case pat::CandKinResolution::Spher:
238  ret[0] = p4.P();
239  ret[1] = p4.theta();
240  ret[2] = p4.phi();
241  ret[3] = p4.mass();
242  break;
243  case pat::CandKinResolution::MCSpher:
244  ret[0] = p4.P();
245  ret[1] = p4.theta();
246  ret[2] = p4.phi();
247  ret[3] = p4.mass();
248  break;
249  case pat::CandKinResolution::ESpher:
250  ret[0] = p4.P();
251  ret[1] = p4.theta();
252  ret[2] = p4.phi();
253  ret[3] = p4.energy();
254  break;
255  case pat::CandKinResolution::MCPInvSpher:
256  ret[0] = 1.0 / p4.P();
257  ret[1] = p4.theta();
258  ret[2] = p4.phi();
259  ret[3] = p4.mass();
260  break;
261  // ======= HEP CYLINDRICAL ==========
262  case pat::CandKinResolution::EtThetaPhi:
263  ret[0] = p4.pt();
264  ret[1] = p4.theta();
265  ret[2] = p4.phi();
266  ret[3] = 0;
267  break;
268  case pat::CandKinResolution::EtEtaPhi:
269  ret[0] = p4.pt();
270  ret[1] = p4.eta();
271  ret[2] = p4.phi();
272  ret[3] = 0;
273  break;
274  // ======= DEVIATES ==========
275  case pat::CandKinResolution::MomDev:
276  case pat::CandKinResolution::EMomDev:
277  ret[0] = 1.0;
278  ret[1] = 0.0;
279  ret[2] = 0.0;
280  ret[3] = 1.0;
281  break;
282  case pat::CandKinResolution::MCMomDev:
283  ret[0] = 1.0;
284  ret[1] = 0.0;
285  ret[2] = 0.0;
286  ret[3] = p4.mass();
287  break;
288  case pat::CandKinResolution::EScaledMomDev:
289  ret[0] = 1.0;
290  ret[1] = 0.0;
291  ret[2] = 0.0;
292  ret[3] = p4.E() / p4.P();
293  break;
294  // ======= OTHER ==========
295  case pat::CandKinResolution::Invalid:
296  throw cms::Exception("Invalid parametrization") << parametrization;
297  default:
298  throw cms::Exception("Not Implemented")
299  << "getResolEta not yet implemented for parametrization " << parametrization;
300  }
301 }
302 
303 void pat::helper::ParametrizationHelper::setParametersFromP4(pat::CandKinResolution::Parametrization parametrization,
304  AlgebraicVector4 &v,
305  const math::PtEtaPhiMLorentzVector &p4) {
306  setParametersFromAnyVector(parametrization, v, p4);
307 }
308 
309 void pat::helper::ParametrizationHelper::setParametersFromP4(pat::CandKinResolution::Parametrization parametrization,
310  AlgebraicVector4 &v,
311  const math::XYZTLorentzVector &p4) {
312  setParametersFromAnyVector(parametrization, v, p4);
313 }
314 
315 AlgebraicVector4 pat::helper::ParametrizationHelper::parametersFromP4(
316  pat::CandKinResolution::Parametrization parametrization, const math::PtEtaPhiMLorentzVector &p4) {
317  AlgebraicVector4 ret;
318  setParametersFromP4(parametrization, ret, p4);
319  return ret;
320 }
321 
322 AlgebraicVector4 pat::helper::ParametrizationHelper::parametersFromP4(
323  pat::CandKinResolution::Parametrization parametrization, const math::XYZTLorentzVector &p4) {
324  AlgebraicVector4 ret;
325  setParametersFromP4(parametrization, ret, p4);
326  return ret;
327 }
328 
329 AlgebraicVector4 pat::helper::ParametrizationHelper::diffToParameters(
330  pat::CandKinResolution::Parametrization parametrization,
331  const math::PtEtaPhiMLorentzVector &p4ini,
332  const math::PtEtaPhiMLorentzVector &p4fin) {
333  AlgebraicVector4 ret;
334  switch (parametrization) {
335  case pat::CandKinResolution::Cart:
336  case pat::CandKinResolution::ECart:
337  case pat::CandKinResolution::MCCart:
338  ret = parametersFromP4(parametrization, p4fin) - parametersFromP4(parametrization, p4ini);
339  break;
340  case pat::CandKinResolution::Spher:
341  case pat::CandKinResolution::ESpher:
342  case pat::CandKinResolution::MCSpher:
343  case pat::CandKinResolution::MCPInvSpher:
344  case pat::CandKinResolution::EtThetaPhi:
345  case pat::CandKinResolution::EtEtaPhi:
346  ret = parametersFromP4(parametrization, p4fin) - parametersFromP4(parametrization, p4ini);
347  while (ret[2] > +M_PI)
348  ret[2] -= (2 * M_PI);
349  while (ret[2] < -M_PI)
350  ret[2] += (2 * M_PI);
351  break;
352  case pat::CandKinResolution::MCMomDev:
353  case pat::CandKinResolution::MomDev:
354  case pat::CandKinResolution::EMomDev:
355  case pat::CandKinResolution::EScaledMomDev:
356  return diffToParameters(parametrization, math::XYZTLorentzVector(p4ini), math::XYZTLorentzVector(p4fin));
357  case pat::CandKinResolution::Invalid:
358  throw cms::Exception("Invalid parametrization") << parametrization;
359  default:
360  throw cms::Exception("Not Implemented")
361  << "diffToParameters not yet implemented for parametrization " << parametrization;
362  }
363  return ret;
364 }
365 
366 AlgebraicVector4 pat::helper::ParametrizationHelper::diffToParameters(
367  pat::CandKinResolution::Parametrization parametrization,
368  const math::XYZTLorentzVector &p4ini,
369  const math::XYZTLorentzVector &p4fin) {
370  AlgebraicVector4 ret;
371  switch (parametrization) {
372  case pat::CandKinResolution::Cart:
373  case pat::CandKinResolution::ECart:
374  case pat::CandKinResolution::MCCart:
375  case pat::CandKinResolution::Spher:
376  ret = parametersFromP4(parametrization, p4fin) - parametersFromP4(parametrization, p4ini);
377  break;
378  case pat::CandKinResolution::ESpher:
379  case pat::CandKinResolution::MCSpher:
380  case pat::CandKinResolution::MCPInvSpher:
381  case pat::CandKinResolution::EtThetaPhi:
382  case pat::CandKinResolution::EtEtaPhi:
383  ret = parametersFromP4(parametrization, p4fin) - parametersFromP4(parametrization, p4ini);
384  while (ret[2] > +M_PI)
385  ret[2] -= (2 * M_PI);
386  while (ret[2] < -M_PI)
387  ret[2] += (2 * M_PI);
388  break;
389  case pat::CandKinResolution::MCMomDev:
390  case pat::CandKinResolution::MomDev:
391  case pat::CandKinResolution::EMomDev:
392  case pat::CandKinResolution::EScaledMomDev: {
393  typedef ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double> > V3Cart;
394  V3Cart p1 = p4ini.Vect(), p2 = p4fin.Vect();
395  V3Cart ur = p1.Unit();
396  V3Cart uz(0, 0, 1);
397  V3Cart uph = uz.Cross(ur).Unit();
398  V3Cart uth = ur.Cross(uph).Unit();
399  ret[0] = p2.Dot(ur) / p1.R() - 1.0;
400  ret[1] = (p2 - p1).Dot(uth);
401  ret[2] = (p2 - p1).Dot(uph);
402  if (parametrization == pat::CandKinResolution::MomDev) {
403  ret[3] = p4fin.mass() / p4ini.mass() - 1.0;
404  } else if (parametrization == pat::CandKinResolution::EMomDev) {
405  ret[3] = p4fin.energy() / p4ini.energy() - 1.0;
406  }
407  } break;
408  case pat::CandKinResolution::Invalid:
409  throw cms::Exception("Invalid parametrization") << parametrization;
410  default:
411  throw cms::Exception("Not Implemented")
412  << "diffToParameters not yet implemented for parametrization " << parametrization;
413  }
414  return ret;
415 }
416 
417 bool pat::helper::ParametrizationHelper::isAlwaysMassless(pat::CandKinResolution::Parametrization parametrization) {
418  switch (parametrization) {
419  case pat::CandKinResolution::Cart:
420  case pat::CandKinResolution::ECart:
421  case pat::CandKinResolution::MCCart:
422  case pat::CandKinResolution::Spher:
423  case pat::CandKinResolution::ESpher:
424  case pat::CandKinResolution::MCSpher:
425  case pat::CandKinResolution::MCPInvSpher:
426  case pat::CandKinResolution::MCMomDev:
427  case pat::CandKinResolution::MomDev:
428  case pat::CandKinResolution::EMomDev:
429  case pat::CandKinResolution::EScaledMomDev:
430  return false;
431  case pat::CandKinResolution::EtThetaPhi:
432  case pat::CandKinResolution::EtEtaPhi:
433  return true;
434  case pat::CandKinResolution::Invalid:
435  throw cms::Exception("Invalid parametrization") << parametrization;
436  default:
437  throw cms::Exception("Not Implemented")
438  << "isAlwaysMassless not yet implemented for parametrization " << parametrization;
439  }
440 }
441 
442 bool pat::helper::ParametrizationHelper::isAlwaysMassive(pat::CandKinResolution::Parametrization parametrization) {
443  switch (parametrization) {
444  case pat::CandKinResolution::Cart:
445  case pat::CandKinResolution::ECart:
446  case pat::CandKinResolution::MCCart:
447  case pat::CandKinResolution::Spher:
448  case pat::CandKinResolution::ESpher:
449  case pat::CandKinResolution::MCSpher:
450  case pat::CandKinResolution::MCPInvSpher:
451  case pat::CandKinResolution::MCMomDev:
452  case pat::CandKinResolution::EMomDev:
453  case pat::CandKinResolution::EScaledMomDev:
454  case pat::CandKinResolution::EtThetaPhi:
455  case pat::CandKinResolution::EtEtaPhi:
456  return false;
457  case pat::CandKinResolution::MomDev:
458  return true;
459  case pat::CandKinResolution::Invalid:
460  throw cms::Exception("Invalid parametrization") << parametrization;
461  default:
462  throw cms::Exception("Not Implemented")
463  << "isAlwaysMassless not yet implemented for parametrization " << parametrization;
464  }
465 }
466 
467 bool pat::helper::ParametrizationHelper::isMassConstrained(pat::CandKinResolution::Parametrization parametrization) {
468  switch (parametrization) {
469  case pat::CandKinResolution::Cart:
470  case pat::CandKinResolution::ECart:
471  case pat::CandKinResolution::Spher:
472  case pat::CandKinResolution::ESpher:
473  case pat::CandKinResolution::EMomDev:
474  case pat::CandKinResolution::EScaledMomDev:
475  case pat::CandKinResolution::EtThetaPhi:
476  case pat::CandKinResolution::EtEtaPhi:
477  case pat::CandKinResolution::MomDev:
478  return false;
479  case pat::CandKinResolution::MCCart:
480  case pat::CandKinResolution::MCSpher:
481  case pat::CandKinResolution::MCPInvSpher:
482  case pat::CandKinResolution::MCMomDev:
483  return true;
484  case pat::CandKinResolution::Invalid:
485  throw cms::Exception("Invalid parametrization") << parametrization;
486  default:
487  throw cms::Exception("Not Implemented")
488  << "isAlwaysMassless not yet implemented for parametrization " << parametrization;
489  }
490 }
491 
492 bool pat::helper::ParametrizationHelper::isPhysical(pat::CandKinResolution::Parametrization parametrization,
493  const AlgebraicVector4 &parameters,
494  const math::PtEtaPhiMLorentzVector &initialP4) {
495  switch (parametrization) {
496  // ======= CARTESIAN ==========
497  case pat::CandKinResolution::Cart:
498  return parameters[3] >= 0; // M >= 0
499  case pat::CandKinResolution::MCCart:
500  return true;
501  case pat::CandKinResolution::ECart:
502  return (parameters[0] * parameters[0] + parameters[1] * parameters[1] + parameters[2] * parameters[2] <=
503  parameters[3] * parameters[3]); // E >= P
504  case pat::CandKinResolution::Spher:
505  return (parameters[0] >= 0) && // P >= 0
506  (parameters[3] >= 0) && // M >= 0
507  (parameters[1] >= 0) && // theta >= 0
508  (parameters[1] <= M_PI); // theta <= pi
509  case pat::CandKinResolution::MCSpher:
510  return (parameters[0] >= 0) && // P >= 0
511  (parameters[1] >= 0) && // theta >= 0
512  (parameters[1] <= M_PI); // theta <= pi
513  case pat::CandKinResolution::ESpher: //
514  return (parameters[0] >= 0) && // P >= 0
515  (parameters[3] >= parameters[0]) && // E >= P
516  (parameters[1] >= 0) && // theta >= 0
517  (parameters[1] <= M_PI); // theta <= PI
518  case pat::CandKinResolution::MCPInvSpher: //
519  return (parameters[0] > 0) && // 1/P > 0
520  (parameters[1] >= 0) && // theta >= 0
521  (parameters[1] <= M_PI); // theta <= pi
522  // ======= HEP CYLINDRICAL ==========
523  case pat::CandKinResolution::EtThetaPhi:
524  return (parameters[0] > 0) && // Et >= 0
525  (parameters[1] >= 0) && // theta >= 0
526  (parameters[1] <= M_PI); // theta <= pi
527  case pat::CandKinResolution::EtEtaPhi: // as simple as that
528  return (parameters[0] > 0); // Et >= 0
529  // ======= MomentumDeviates ==========
530  case pat::CandKinResolution::MomDev:
531  return (parameters[0] >= 0) && // P >= 0
532  (parameters[3] >= 0); // m/M0 >= 0
533  case pat::CandKinResolution::MCMomDev:
534  return (parameters[0] >= 0); // P >= 0
535  case pat::CandKinResolution::EMomDev:
536  case pat::CandKinResolution::EScaledMomDev: {
537  if (parameters[0] <= 0)
538  return false;
539  ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double> > p = initialP4.Vect(), uz(0, 0, 1), uph, uth;
540  uph = uz.Cross(p).Unit();
541  uth = p.Cross(uph).Unit();
542  p *= parameters[0];
543  p += uth * parameters[1] + uph * parameters[2];
544  if (parametrization == pat::CandKinResolution::EMomDev) {
545  if (parameters[3] < 0)
546  return false;
547  double m2 = ROOT::Math::Square(parameters[3] * initialP4.energy()) - p.Mag2();
548  if (m2 < 0)
549  return false;
550  } else if (parametrization == pat::CandKinResolution::EScaledMomDev) {
551  if (parameters[3] < 0)
552  return false;
553  double m2 = ROOT::Math::Square(p.R() * initialP4.E() / initialP4.P()) - p.Mag2();
554  if (m2 < 0)
555  return false;
556  }
557  return true;
558  }
559  // ======= OTHER ==========
560  case pat::CandKinResolution::Invalid:
561  throw cms::Exception("Invalid parametrization") << parametrization;
562  default:
563  throw cms::Exception("Not Implemented")
564  << "getResolEta not yet implemented for parametrization " << parametrization;
565  }
566 }
pat::helper::ParametrizationHelper::diffToParameters
AlgebraicVector4 diffToParameters(pat::CandKinResolution::Parametrization parametrization, const math::XYZTLorentzVector &p4ini, const math::XYZTLorentzVector &p4fin)
Expresses the difference between two 4-momentum vectors as a shift in coordinates in a given frame.
Definition: ParametrizationHelper.cc:366
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:367
BeamSpotPI::parameters
parameters
Definition: BeamSpotPayloadInspectorHelper.h:29
converter
Definition: CandidateProducer.h:25
pat::CandKinResolution::MCPInvSpher
Definition: CandKinResolution.h:47
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
pat::helper::ParametrizationHelper::setParametersFromAnyVector
void setParametersFromAnyVector(pat::CandKinResolution::Parametrization parametrization, AlgebraicVector4 &pars, const T &p4)
For internal use only, so we provide only the interface. Use the 'setParametersFromP4'.
Definition: ParametrizationHelper.cc:214
pat::helper::ParametrizationHelper::setParametersFromP4
void setParametersFromP4(pat::CandKinResolution::Parametrization parametrization, AlgebraicVector4 &pars, const math::XYZTLorentzVector &p4)
Set the values of the parameters for a given 4-momentum.
Definition: ParametrizationHelper.cc:309
findQualityFiles.v
v
Definition: findQualityFiles.py:179
pat::helper::ParametrizationHelper::isMassConstrained
bool isMassConstrained(pat::CandKinResolution::Parametrization parametrization)
If this parametrization has a mass constraint (including the 'isAlwaysMassless' case)
Definition: ParametrizationHelper.cc:467
pat::helper::ParametrizationHelper::p4fromParameters
math::XYZTLorentzVector p4fromParameters(pat::CandKinResolution::Parametrization parametrization, const AlgebraicVector4 &parameters, const math::XYZTLorentzVector &initialP4)
Definition: ParametrizationHelper.cc:161
ParametrizationHelper.h
pat::helper::ParametrizationHelper::isAlwaysMassive
bool isAlwaysMassive(pat::CandKinResolution::Parametrization parametrization)
Is this parametrization usable only with massive objects?
Definition: ParametrizationHelper.cc:442
pat::helper::ParametrizationHelper::fromString
pat::CandKinResolution::Parametrization fromString(const std::string &name)
Convert a name into a parametrization code.
Definition: ParametrizationHelper.cc:14
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
pat::CandKinResolution::Parametrization
Parametrization
Definition: CandKinResolution.h:35
pat::helper::ParametrizationHelper::name
const char * name(pat::CandKinResolution::Parametrization param)
Convert a number into a string.
Definition: ParametrizationHelper.cc:39
p2
double p2[4]
Definition: TauolaWrapper.h:90
pat::CandKinResolution::EMomDev
Definition: CandKinResolution.h:43
HGCalGeometryMode::Square
Definition: HGCalGeometryMode.h:26
pat::CandKinResolution::Cart
Definition: CandKinResolution.h:38
stringResolutionProvider_cfi.parametrization
parametrization
specify parametrization (see SWGuidePATKinematicResolutions for more details)
Definition: stringResolutionProvider_cfi.py:6
pat::helper::ParametrizationHelper::parametersFromP4
AlgebraicVector4 parametersFromP4(pat::CandKinResolution::Parametrization parametrization, const math::XYZTLorentzVector &p4)
Returns a vector of coordinates values given a coordinate frame and a 4-vector.
Definition: ParametrizationHelper.cc:322
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
pat::CandKinResolution::Spher
Definition: CandKinResolution.h:40
pat::CandKinResolution::MCSpher
Definition: CandKinResolution.h:46
pat::CandKinResolution::EScaledMomDev
Definition: CandKinResolution.h:51
pat::helper::ParametrizationHelper::isPhysical
bool isPhysical(pat::CandKinResolution::Parametrization parametrization, const AlgebraicVector4 &v4, const math::PtEtaPhiMLorentzVector &initialP4)
Definition: ParametrizationHelper.cc:492
pat::CandKinResolution::MCCart
Definition: CandKinResolution.h:45
pat::CandKinResolution::MCMomDev
Definition: CandKinResolution.h:50
pat::CandKinResolution::ESpher
Definition: CandKinResolution.h:41
p4
double p4[4]
Definition: TauolaWrapper.h:92
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:49
p1
double p1[4]
Definition: TauolaWrapper.h:89
pat::helper::ParametrizationHelper::isAlwaysMassless
bool isAlwaysMassless(pat::CandKinResolution::Parametrization parametrization)
Is this parametrization usable only with massless objects?
Definition: ParametrizationHelper.cc:417
pat::CandKinResolution::ECart
Definition: CandKinResolution.h:39
AlgebraicVector4
ROOT::Math::SVector< double, 4 > AlgebraicVector4
Definition: AlgebraicROOTObjects.h:13
std
Definition: JetResolutionObject.h:76
pat::CandKinResolution::MomDev
Definition: CandKinResolution.h:42
pat::CandKinResolution::Invalid
Definition: CandKinResolution.h:36
T
long double T
Definition: Basic3DVectorLD.h:48
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
pat::CandKinResolution::EtThetaPhi
Definition: CandKinResolution.h:49
Exception
Definition: hltDiff.cc:246
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
pat::CandKinResolution::EtEtaPhi
Definition: CandKinResolution.h:48
math::PtEtaPhiMLorentzVector
PtEtaPhiMLorentzVectorD PtEtaPhiMLorentzVector
Lorentz vector with cartesian internal representation.
Definition: LorentzVector.h:25
pat::helper::ParametrizationHelper::polarP4fromParameters
math::PtEtaPhiMLorentzVector polarP4fromParameters(pat::CandKinResolution::Parametrization parametrization, const AlgebraicVector4 &parameters, const math::PtEtaPhiMLorentzVector &initialP4)
Definition: ParametrizationHelper.cc:74
Generated for CMSSW Reference Manual by doxygen 1.8.16