HackAnalysis  2
Vectors.h
1 // -*- C++ -*-
2 //
3 // This file is part of HEPUtils -- https://bitbucket.org/andybuckley/heputils
4 // Copyright (C) 2013-2018 Andy Buckley <andy.buckley@cern.ch>
5 //
6 // Embedding of HEPUtils code in other projects is permitted provided this
7 // notice is retained and the HEPUtils namespace and include path are changed.
8 //
9 
10 // Duly: HEPUtils namespace changed to HEP
11 // Some edits by Mark Goodsell: changed everything round so that we use
12 // (px, py, pz, E) instead of the mass, because I want to use it for spacetime vectors!
13 // Necessary for production/decay vertices etc
14 //
15 
16 #pragma once
17 
18 #include "MathUtils.h"
19 #include "Utils.h"
20 #include <sstream>
21 #include <iostream>
22 #include <stdexcept>
23 #include <cmath>
24 #include "ExHEPUtils/Vectors3.h"
27 
29 
30 namespace HEP {
31 
32 
33 
34 
36 
37 
38 
44 
45  class P4 {
46  private:
47 
49 
50  double _x, _y, _z, _t;
52 
53 
54  public:
55 
57 
58 
60  P4()
61  : _x(0), _y(0), _z(0), _t(0) { }
62 
64  P4(double px, double py, double pz, double E) {
65  setPE(px, py, pz, E);
66  }
67 
69  P4(const P4& v)
70  : _x(v._x), _y(v._y), _z(v._z), _t(v._t) { }
71 
73  P4& operator = (const P4& v) {
74  _x = v._x;
75  _y = v._y;
76  _z = v._z;
77  _t = v._t;
78  return *this;
79  }
80 
82  void clear() {
83  _x = 0;
84  _y = 0;
85  _z = 0;
86  _t = 0;
87  }
88 
90 
91 
93 
94 
96  static P4 mkXYZE(double px, double py, double pz, double E) {
97  return P4().setPE(px, py, pz, E);
98  }
99 
101  static P4 mkXYZM(double px, double py, double pz, double mass) {
102  return P4().setPM(px, py, pz, mass);
103  }
104 
106  static P4 mkEtaPhiME(double eta, double phi, double mass, double E) {
107  return P4().setEtaPhiME(eta, phi, mass, E);
108  }
109 
111  static P4 mkEtaPhiMPt(double eta, double phi, double mass, double pt) {
112  return P4().setEtaPhiMPt(eta, phi, mass, pt);
113  }
114 
116  static P4 mkRapPhiME(double y, double phi, double mass, double E) {
117  return P4().setRapPhiME(y, phi, mass, E);
118  }
119 
121  static P4 mkRapPhiMPt(double y, double phi, double mass, double pt) {
122  return P4().setRapPhiMPt(y, phi, mass, pt);
123  }
124 
126  static P4 mkThetaPhiME(double theta, double phi, double mass, double E) {
127  return P4().setThetaPhiME(theta, phi, mass, E);
128  }
129 
131  static P4 mkThetaPhiMPt(double theta, double phi, double mass, double pt) {
132  return P4().setThetaPhiMPt(theta, phi, mass, pt);
133  }
134 
136  static P4 mkPtPhiME(double pt, double phi, double mass, double E) {
137  return P4().setPtPhiME(pt, phi, mass, E);
138  }
139 
141 
142 
144 
145 
147  P4& setPx(double px) {
148  _x = px;
149  return *this;
150  }
151 
153  P4& setPy(double py) {
154  _y = py;
155  return *this;
156  }
157 
159  P4& setPz(double pz) {
160  _z = pz;
161  return *this;
162  }
163 
164  P4& setT(double t) {
165  _t = t;
166  return *this;
167  }
168 
169  P4& setE(double E) {
170  _t = E;
171  return *this;
172  }
174  P4& setM(double mass) {
175  if (mass < 0)
176  throw std::invalid_argument("Negative mass given as argument");
177  _t=sqrt(sqr(mass)+sqr(_x)+ sqr(_y)+sqr(_z));
178  //_m = mass;
179  return *this;
180  }
181 
183  P4& setPM(double px, double py, double pz, double mass) {
184  if (mass < 0)
185  throw std::invalid_argument("Negative mass given as argument");
186  setPx(px); setPy(py); setPz(pz);
187  setM(mass);
188  return *this;
189  }
191  P4& setXYZM(double px, double py, double pz, double mass) {
192  return setPM(px, py, pz, mass);
193  }
194 
195 
196 
197 
198 
199  P4& SetVectM(const HEP::P3& vec, double mass)
200  {
201  return setPM(vec.px(),vec.py(),vec.pz(),mass);
202  }
203 
204 
205  // useful for Pileup stuff where we need to translate along the beamline (otherwise use the +/- operators)
206  P4& translate_zt(double dz, double dt)
207  {
208  _z+=dz;
209  _t+=dt;
210  return *this;
211  }
212 
215 
216  //P4& setPE(double px, double py, double pz, double E) {
217  // if (E < 0)
218  // throw std::invalid_argument("Negative energy given as argument");
219  // setPx(px); setPy(py); setPz(pz);
220  // const double mass = sqrt( sqr(E) - sqr(p()) );
221  // setM(mass);
222  // return *this;
223  //}
224  P4& setPE(double px, double py, double pz, double E) { // retain for legacy
225  //if (E < 0) // now I don't care
226  // throw std::invalid_argument("Negative energy given as argument");
227  _t=E;
228  _x=px;
229  _y=py;
230  _z=pz;
231  return *this;
232  }
234  P4& setXYZE(double px, double py, double pz, double E) {
235  return setPE(px, py, pz, E);
236  }
237 
238  P4& SetPxPyPzE(double px, double py, double pz, double mass) {
239  return setPM(px, py, pz, mass);
240  }
241 
246  P4& setEtaPhiME(double eta, double phi, double mass, double E) {
247  if (mass < 0)
248  throw std::invalid_argument("Negative mass given as argument");
249  if (E < 0)
250  throw std::invalid_argument("Negative energy given as argument");
251  const double theta = 2 * atan(exp(-eta));
252  if (theta < 0 || theta > M_PI)
253  throw std::domain_error("Polar angle outside 0..pi in calculation");
254  setThetaPhiME(theta, phi, mass, E);
255  return *this;
256  }
257 
262  P4& setEtaPhiMPt(double eta, double phi, double mass, double pt) {
263  if (mass < 0)
264  throw std::invalid_argument("Negative mass given as argument");
265  if (pt < 0)
266  throw std::invalid_argument("Negative transverse momentum given as argument");
267  const double theta = 2 * atan(exp(-eta));
268  if (theta < 0 || theta > M_PI)
269  throw std::domain_error("Polar angle outside 0..pi in calculation");
270  const double p = pt / sin(theta);
271  const double E = sqrt( sqr(p) + sqr(mass) );
272  setThetaPhiME(theta, phi, mass, E);
273  return *this;
274  }
275 
284  P4& setRapPhiME(double y, double phi, double mass, double E) {
285  if (mass < 0)
286  throw std::invalid_argument("Negative mass given as argument");
287  if (E < 0)
288  throw std::invalid_argument("Negative energy given as argument");
289  const double sqrt_pt2_m2 = E / cosh(y);
290  const double pt = sqrt( sqr(sqrt_pt2_m2) - sqr(mass) );
291  if (pt < 0)
292  throw std::domain_error("Negative transverse momentum in calculation");
293  const double pz = sqrt_pt2_m2 * sinh(y);
294  const double px = pt * cos(phi);
295  const double py = pt * sin(phi);
296  //setPM(px, py, pz, mass);
297  setPE(px, py, pz, E);
298  return *this;
299  }
300 
305  P4& setRapPhiMPt(double y, double phi, double mass, double pt) {
306  if (mass < 0)
307  throw std::invalid_argument("Negative mass given as argument");
308  if (pt < 0)
309  throw std::invalid_argument("Negative transverse mass given as argument");
310  const double E = sqrt( sqr(pt) + sqr(mass) ) * cosh(y);
311  if (E < 0)
312  throw std::domain_error("Negative energy in calculation");
313  setRapPhiME(y, phi, mass, E);
314  return *this;
315  }
316 
322  P4& setThetaPhiME(double theta, double phi, double mass, double E) {
323  if (theta < 0 || theta > M_PI)
324  throw std::invalid_argument("Polar angle outside 0..pi given as argument");
325  if (mass < 0)
326  throw std::invalid_argument("Negative mass given as argument");
327  if (E < 0)
328  throw std::invalid_argument("Negative energy given as argument");
329  const double p = sqrt( sqr(E) - sqr(mass) );
330  const double pz = p * cos(theta);
331  const double pt = p * sin(theta);
332  if (pt < 0)
333  throw std::invalid_argument("Negative transverse momentum in calculation");
334  const double px = pt * cos(phi);
335  const double py = pt * sin(phi);
336  //setPM(px, py, pz, mass);
337  setPE(px, py, pz, E);
338  return *this;
339  }
340 
346  P4& setThetaPhiMPt(double theta, double phi, double mass, double pt) {
347  if (theta < 0 || theta > M_PI)
348  throw std::invalid_argument("Polar angle outside 0..pi given as argument");
349  if (mass < 0)
350  throw std::invalid_argument("Negative mass given as argument");
351  if (pt < 0)
352  throw std::invalid_argument("Negative transverse momentum given as argument");
353  const double p = pt / sin(theta);
354  const double px = pt * cos(phi);
355  const double py = pt * sin(phi);
356  const double pz = p * cos(theta);
357  //const double E = sqrt( sqr(p) + sqr(mass) );
358  setPM(px, py, pz, mass);
359  return *this;
360  }
361 
365  P4& setPtPhiME(double pt, double phi, double mass, double E) {
366  if (pt < 0)
367  throw std::invalid_argument("Negative transverse momentum given as argument");
368  if (mass < 0)
369  throw std::invalid_argument("Negative mass given as argument");
370  if (E < 0)
371  throw std::invalid_argument("Negative energy given as argument");
372  const double px = pt * cos(phi);
373  const double py = pt * sin(phi);
374  const double pz = sqrt(sqr(E) - sqr(mass) - sqr(pt));
375  //setPM(px, py, pz, mass);
376  setPE(px, py, pz, E);
377  return *this;
378  }
379 
380 
381 
382 
383 
385 
386 
388 
389 
391  double px2() const { return sqr(_x); }
393  double px() const { return _x; }
395  double py2() const { return sqr(_y); }
397  double py() const { return _y; }
399  double pz2() const { return sqr(_z); }
401  double pz() const { return _z; }
402 
403 
404 
405 
407  //double m2() const { return sqr(_m); }
408  double m2() const {
409  double hm2=sqr(_t) - p2();
410  // if(hm2 < -0.1) throw std::domain_error("Negative mass squared appeared in vector");
411  // if(hm2 < 0.0) return 0.0; // this should only happen for values numerically close to zero
412  return hm2; }
414  double m() const {
415  double hm2=m2();
416  if(hm2 < 0.0) return 0.0;
417  return sqrt(hm2);
418  }
419  //double m() const { return _m; }
420  // convenience functions
421  double M() const { return m();}
422  double M2() const { return m2();}
423  double X() const { return _x; }
425  double Y() const { return _y; }
427  double Z() const { return _z; }
428 
429 
430 
431  double E() const { return _t;}
432  double E2() const { return (_t*_t);}
433 
434  double T() const { return _t;}
435  double T2() const { return E2();}
437  //double E2() const { return p2() + sqr(_m); }
439  //double E() const { return sqrt(E2()); }
441  double p2() const { return sqr(px()) + sqr(py()) + sqr(pz()); }
443  double p() const { return sqrt(p2()); }
445  double P() const { return sqrt(p2()); }
447  double rho2() const { return sqr(px()) + sqr(py()); }
449  double rho() const { return sqrt(rho2()); }
451  double pT2() const { return rho2(); }
453  double pT() const { return rho(); }
454 
455  // transverse mass
456  double mT2() const { return (sqr(_t) - sqr(_z));}
457  //double mT2() const {return m2() + rho2(); }
458  double mT() const {return sqrt(mT2());}
459 
461  double phi() const { if (rho2() == 0) return 0; else return atan2(py(),px()); }
463  double theta() const { if (p2() == 0) return 0; else if (pz() == 0) return M_PI; else return atan2(rho(),pz()); }
465  double eta() const { return -log(tan( 0.5 * theta() )); } //< Optimise with a trig reln on tan(x/2) to avoid tan(atan(..)/2)?
467  double abseta() const { return fabs(eta()); }
469  double rap() const { return 0.5 * (E() + pz()) / (E() - pz()); }
471  double absrap() const { return fabs(rap()); }
472 
474 
475 
477 
478 
480  double dot3(const P4& v) const { return px()*v.px() + py()*v.py() + pz()*v.pz(); }
482  double dot(const P4& v) const { return E()*v.E() - dot3(v); }
484  double angleTo(const P4& v) const { return acos( dot3(v) /p()/v.p() ); }
486  double deltaPhi(const P4& v) const { return deltaphi(phi(), v.phi()); }
488  double deltaEta(const P4& v) const { return fabs(eta() - v.eta()); }
490  double deltaRap(const P4& v) const { return fabs(rap() - v.rap()); }
492  double deltaR2_eta(const P4& v) const { return sqr(deltaEta(v)) + sqr(deltaPhi(v)); }
494  double deltaR_eta(const P4& v) const { return sqrt(deltaR2_eta(v)); }
496  double deltaR2_rap(const P4& v) const { return sqr(deltaRap(v)) + sqr(deltaPhi(v)); }
498  double deltaR_rap(const P4& v) const { return sqrt(deltaR2_rap(v)); }
499 
500  //hahahahaha
501  P4 cross(const P4& v) const { return P4(py()*v.pz()- pz()*v.py(),pz()*v.px()-px()-v.pz(),px()*v.py()-py()*v.px(),0.0);}
502 
504 
506 
507  //P4 operator - () const { P4 rtn; return rtn.setPM(-_x, -_y, -_z, _m); } //< Not self-modifying...
508  //P4& operator += (const P4& v) { double e = E() + v.E(); _x += v.px(); _y += v.py(); _z += v.pz(); _m = sqrt( sqr(e) - p2() ); return *this; }
509  //P4& operator -= (const P4& v) { double e = E() - v.E(); _x -= v.px(); _y -= v.py(); _z -= v.pz(); _m = sqrt( sqr(e) - p2() ); return *this; }
510  //P4& operator *= (double a) { _x *= a; _y *= a; _z *= a; _m *= a; return *this; }
511  //P4& operator /= (double a) { _x /= a; _y /= a; _z /= a; _m /= a; return *this; }
512 
513  P4 operator - () const { P4 rtn; return rtn.setPE(-_x, -_y, -_z, -_t); } //< Not self-modifying...
514  P4& operator += (const P4& v) { _x += v.px(); _y += v.py(); _z += v.pz(); _t+=v.T() ; return *this; }
515  P4& operator -= (const P4& v) { _x -= v.px(); _y -= v.py(); _z -= v.pz(); _t-=v.T() ; return *this; }
516  P4& operator *= (double a) { _x *= a; _y *= a; _z *= a; _t *= a; return *this; }
517  P4& operator /= (double a) { _x /= a; _y /= a; _z /= a; _t /= a; return *this; }
518 
519 
520 
521  P4& Boost(double bx, double by, double bz)
522  {
523  //Boost this Lorentz vector
524  double b2 = bx*bx + by*by + bz*bz;
525  double gamma = 1.0 / sqrt(1.0 - b2);
526  double bp = bx*X() + by*Y() + bz*Z();
527  double gamma2 = b2 > 0 ? (gamma - 1.0)/b2 : 0.0;
528 
529  setPx(X() + gamma2*bp*bx + gamma*bx*T());
530  setPy(Y() + gamma2*bp*by + gamma*by*T());
531  setPz(Z() + gamma2*bp*bz + gamma*bz*T());
532  setE(gamma*(T() + bp));
533 
534  return *this;
535  }
536 
537  P4& Boost(const HEP::P3 & b)
538  {
539  return Boost(b.px(),b.py(),b.pz());
540  }
541 
542 
543 
544 
546  // return a three-vector of the momentum
547  P3 Vect() const {return P3(px(),py(),pz());}
548 
549  P3 BoostVector() const { double t=T(); if (t==0.0) return P3(0.0,0.0,0.0); else return P3(px()/t,py()/t,pz()/t); }
550 
551  P4& Rotate(const double &angle, const P3& axis)
552  {
553  P3 newmom=Vect();
554  newmom.Rotate(angle,axis);
555  setPx(newmom.px()); setPy(newmom.py()); setPz(newmom.pz());
556  return *this;
557  }
558  };
559 
560 
562 
563 
565  inline std::string to_str(const P4& p4) {
566  std::stringstream ss;
567  ss << "(" << p4.px() << ", " << p4.py() << ", " << p4.pz() << "; " << p4.E() << ")";
568  return ss.str();
569  }
570 
572  inline std::ostream& operator <<(std::ostream& ostr, const P4& p4) {
573  ostr << to_str(p4);
574  return ostr;
575  }
576 
578 
579 
581 
582 
584  inline double dot(const P4& a, const P4& b) {
585  return a.dot(b);
586  }
587 
588 
590  inline double angle(const P4& a, const P4& b) {
591  return a.angleTo(b);
592  }
593 
594 
596  inline double deltaPhi(const P4& a, const P4& b) {
597  return a.deltaPhi(b);
598  }
599 
600 
602  inline double deltaEta(const P4& a, const P4& b) {
603  return a.deltaEta(b);
604  }
605 
606 
608  inline double deltaRap(const P4& a, const P4& b) {
609  return a.deltaRap(b);
610  }
611 
612 
614  inline double deltaR2_eta(const P4& a, const P4& b) {
615  return a.deltaR2_eta(b);
616  }
618  inline double deltaR_eta(const P4& a, const P4& b) {
619  return a.deltaR_eta(b);
620  }
621 
622 
624  inline double deltaR2_rap(const P4& a, const P4& b) {
625  return a.deltaR2_rap(b);
626  }
628  inline double deltaR_rap(const P4& a, const P4& b) {
629  return a.deltaR_rap(b);
630  }
631 
633 
634 
636 
637  inline P4 operator + (const P4& a, const P4& b) { P4 rtn = a; return rtn += b; }
638  inline P4 operator - (const P4& a, const P4& b) { P4 rtn = a; return rtn -= b; }
639  inline P4 operator * (const P4& a, double f) { P4 rtn = a; return rtn *= f; }
640  inline P4 operator * (double f, const P4& a) { P4 rtn = a; return rtn *= f; }
641  inline P4 operator / (const P4& a, double f) { P4 rtn = a; return rtn /= f; }
643 
644 
645 
646 
647 
648 
649 
650 
651 }
Definition: Vectors3.h:34
double pz() const
Get pz.
Definition: Vectors3.h:246
double px() const
Get px.
Definition: Vectors3.h:238
double py() const
Get py.
Definition: Vectors3.h:242
A 4-momentum class for vectors.
Definition: Vectors.h:45
static P4 mkThetaPhiMPt(double theta, double phi, double mass, double pt)
Make a vector from (theta,phi,pT) coordinates and the mass.
Definition: Vectors.h:131
double deltaR2_eta(const P4 &v) const
Difference in pseudorapidity-based R^2 between two vectors.
Definition: Vectors.h:492
P4 & setThetaPhiME(double theta, double phi, double mass, double E)
Definition: Vectors.h:322
P4 & setRapPhiMPt(double y, double phi, double mass, double pt)
Definition: Vectors.h:305
double px() const
Get px.
Definition: Vectors.h:393
static P4 mkXYZM(double px, double py, double pz, double mass)
Make a vector from (px,py,pz) coordinates and the mass.
Definition: Vectors.h:101
double p2() const
Get E^2.
Definition: Vectors.h:441
static P4 mkRapPhiME(double y, double phi, double mass, double E)
Make a vector from (y,phi,energy) coordinates and the mass.
Definition: Vectors.h:116
P4 & operator=(const P4 &v)
Copy assignment operator.
Definition: Vectors.h:73
P4 & setPx(double px)
Set the px coordinate.
Definition: Vectors.h:147
double eta() const
Get the spatial vector pseudorapidity.
Definition: Vectors.h:465
double py2() const
Get py^2.
Definition: Vectors.h:395
double m2() const
Get m^2.
Definition: Vectors.h:408
P4 & setPM(double px, double py, double pz, double mass)
Set the p coordinates and mass simultaneously.
Definition: Vectors.h:183
double absrap() const
Get the 4-momentum absolute rapidity.
Definition: Vectors.h:471
static P4 mkEtaPhiME(double eta, double phi, double mass, double E)
Make a vector from (eta,phi,energy) coordinates and the mass.
Definition: Vectors.h:106
double Y() const
Get py^2.
Definition: Vectors.h:425
double theta() const
Get the spatial theta.
Definition: Vectors.h:463
P4 & setPtPhiME(double pt, double phi, double mass, double E)
Definition: Vectors.h:365
static P4 mkRapPhiMPt(double y, double phi, double mass, double pt)
Make a vector from (y,phi,pT) coordinates and the mass.
Definition: Vectors.h:121
static P4 mkXYZE(double px, double py, double pz, double E)
Make a vector from (px,py,pz,E) coordinates.
Definition: Vectors.h:96
P4 & setEtaPhiME(double eta, double phi, double mass, double E)
Definition: Vectors.h:246
P4 & setPz(double pz)
Set the pz coordinate.
Definition: Vectors.h:159
double px2() const
Get px^2.
Definition: Vectors.h:391
double deltaEta(const P4 &v) const
Difference in pseudorapidity between two vectors.
Definition: Vectors.h:488
double pT() const
Get the transverse momentum (same as rho)
Definition: Vectors.h:453
double phi() const
Get the spatial phi.
Definition: Vectors.h:461
double deltaR_eta(const P4 &v) const
Difference in pseudorapidity-based R between two vectors.
Definition: Vectors.h:494
double m() const
Get m.
Definition: Vectors.h:414
static P4 mkPtPhiME(double pt, double phi, double mass, double E)
Make a vector from (pT,phi,energy) coordinates and the mass.
Definition: Vectors.h:136
double rho() const
Get the spatial 3-vector sqrt|px^2 + py^2|.
Definition: Vectors.h:449
P4 & setPE(double px, double py, double pz, double E)
Definition: Vectors.h:224
double pT2() const
Get the transverse momentum squared (same as rho2)
Definition: Vectors.h:451
double pz2() const
Get pz^2.
Definition: Vectors.h:399
double rho2() const
Get the spatial 3-vector |px^2 + py^2|.
Definition: Vectors.h:447
double abseta() const
Get the spatial vector absolute pseudorapidity.
Definition: Vectors.h:467
P4(const P4 &v)
Copy constructor.
Definition: Vectors.h:69
double pz() const
Get pz.
Definition: Vectors.h:401
double Z() const
Get pz^2.
Definition: Vectors.h:427
double dot(const P4 &v) const
Lorentz dot product with the positive metric term on E.
Definition: Vectors.h:482
double dot3(const P4 &v) const
Spatial dot product.
Definition: Vectors.h:480
static P4 mkEtaPhiMPt(double eta, double phi, double mass, double pt)
Make a vector from (eta,phi,pT) coordinates and the mass.
Definition: Vectors.h:111
P4()
Default constructor of a null vector.
Definition: Vectors.h:60
static P4 mkThetaPhiME(double theta, double phi, double mass, double E)
Make a vector from (theta,phi,energy) coordinates and the mass.
Definition: Vectors.h:126
double deltaR2_rap(const P4 &v) const
Difference in rapidity-based R^2 between two vectors.
Definition: Vectors.h:496
P4 & setM(double mass)
Set the mass // Mark: preserve momentum, update energy.
Definition: Vectors.h:174
double deltaRap(const P4 &v) const
Difference in rapidity between two vectors.
Definition: Vectors.h:490
double py() const
Get py.
Definition: Vectors.h:397
P4 & setXYZM(double px, double py, double pz, double mass)
Alias for setPM.
Definition: Vectors.h:191
P4 & setXYZE(double px, double py, double pz, double E)
Alias for setPE.
Definition: Vectors.h:234
double deltaR_rap(const P4 &v) const
Difference in rapidity-based R between two vectors.
Definition: Vectors.h:498
void clear()
Set the components to zero.
Definition: Vectors.h:82
P4(double px, double py, double pz, double E)
Constructor from Cartesian/Minkowski coordinates.
Definition: Vectors.h:64
P4 & setEtaPhiMPt(double eta, double phi, double mass, double pt)
Definition: Vectors.h:262
double deltaPhi(const P4 &v) const
Difference in phi between two vectors.
Definition: Vectors.h:486
P4 & setPy(double py)
Set the py coordinate.
Definition: Vectors.h:153
P4 & setRapPhiME(double y, double phi, double mass, double E)
Definition: Vectors.h:284
double angleTo(const P4 &v) const
Spatial angle to another P4 vector.
Definition: Vectors.h:484
double rap() const
Get the 4-momentum rapidity.
Definition: Vectors.h:469
double p() const
Get the spatial 3-vector |p|.
Definition: Vectors.h:443
double P() const
Get the spatial 3-vector |p|.
Definition: Vectors.h:445
P4 & setThetaPhiMPt(double theta, double phi, double mass, double pt)
Definition: Vectors.h:346
Modified by Mark Goodsell goodsell@lpthe.jussieu.fr
Definition: ATLAS_SUSY_2018_16.cc:27
std::string to_str(const P4 &p4)
Make a string representation of the vector.
Definition: Vectors.h:565
double dot(const P4 &a, const P4 &b)
Convenience "external" functions.
Definition: Vectors.h:584
double deltaR2_eta(const P4 &a, const P4 &b)
Difference in pseudorapidity-based R^2 between two vectors.
Definition: Vectors.h:614
double deltaR_rap(const P4 &a, const P4 &b)
Difference in rapidity-based R between two vectors.
Definition: Vectors.h:628
double deltaR2_rap(const P4 &a, const P4 &b)
Difference in rapidity-based R^2 between two vectors.
Definition: Vectors.h:624
double deltaR_eta(const P4 &a, const P4 &b)
Difference in pseudorapidity-based R between two vectors.
Definition: Vectors.h:618
std::ostream & operator<<(std::ostream &ostr, const P4 &p4)
Write a string representation of the vector to the provided stream.
Definition: Vectors.h:572
double deltaEta(const P4 &a, const P4 &b)
Difference in pseudorapidity between two vectors.
Definition: Vectors.h:602
double deltaPhi(const P4 &a, const P4 &b)
Difference in phi between two vectors.
Definition: Vectors.h:596
double deltaRap(const P4 &a, const P4 &b)
Difference in rapidity between two vectors.
Definition: Vectors.h:608
constexpr std::enable_if< std::is_arithmetic< N1 >::value, N1 >::type sqr(const N1 val)
Convenience function for squaring (better than repeating long expressions/calcs or using intermediate...
Definition: MathUtils.h:45
double angle(const P4 &a, const P4 &b)
Angle between two vectors.
Definition: Vectors.h:590