```// @(#)root/mathcore:\$Id: 04c6d98020d7178ed5f0884f9466bca32b031565 \$
// Authors: W. Brown, M. Fischler, L. Moneta    2005

/**********************************************************************
*                                                                    *
* Copyright (c) 2005 , LCG ROOT MathLib Team                         *
*                                                                    *
*                                                                    *
**********************************************************************/

// Header file for class PxPyPzE4D
//
// Created by: fischler at Wed Jul 20   2005
//   (starting from PxPyPzE4D by moneta)
//
// Last update: \$Id: 04c6d98020d7178ed5f0884f9466bca32b031565 \$
//
#ifndef ROOT_Math_GenVector_PxPyPzE4D
#define ROOT_Math_GenVector_PxPyPzE4D  1

#ifndef ROOT_Math_GenVector_eta
#include "Math/GenVector/eta.h"
#endif

#ifndef ROOT_Math_GenVector_GenVector_exception
#include "Math/GenVector/GenVector_exception.h"
#endif

#include <cmath>

namespace ROOT {

namespace Math {

//__________________________________________________________________________________________
/**
Class describing a 4D cartesian coordinate system (x, y, z, t coordinates)
or momentum-energy vectors stored as (Px, Py, Pz, E).
The metric used is (-,-,-,+)

@ingroup GenVector
*/

template <class ScalarType = double>
class PxPyPzE4D {

public :

typedef ScalarType Scalar;

// --------- Constructors ---------------

/**
Default constructor  with x=y=z=t=0
*/
PxPyPzE4D() : fX(0.0), fY(0.0), fZ(0.0), fT(0.0) { }

/**
Constructor  from x, y , z , t values
*/
PxPyPzE4D(Scalar px, Scalar py, Scalar pz, Scalar e) :
fX(px), fY(py), fZ(pz), fT(e) { }

/**
construct from any vector or  coordinate system class
implementing x(), y() and z() and t()
*/
template <class CoordSystem>
explicit PxPyPzE4D(const CoordSystem & v) :
fX( v.x() ), fY( v.y() ), fZ( v.z() ), fT( v.t() )  { }

// for g++  3.2 and 3.4 on 32 bits found that the compiler generated copy ctor and assignment are much slower
// so we decided to re-implement them ( there is no no need to have them with g++4)
/**
copy constructor
*/
PxPyPzE4D(const PxPyPzE4D & v) :
fX(v.fX), fY(v.fY), fZ(v.fZ), fT(v.fT) { }

/**
assignment operator
*/
PxPyPzE4D & operator = (const PxPyPzE4D & v) {
fX = v.fX;
fY = v.fY;
fZ = v.fZ;
fT = v.fT;
return *this;
}

/**
Set internal data based on an array of 4 Scalar numbers
*/
void SetCoordinates( const Scalar src[] )
{ fX=src[0]; fY=src[1]; fZ=src[2]; fT=src[3]; }

/**
get internal data into an array of 4 Scalar numbers
*/
void GetCoordinates( Scalar dest[] ) const
{ dest[0] = fX; dest[1] = fY; dest[2] = fZ; dest[3] = fT; }

/**
Set internal data based on 4 Scalar numbers
*/
void SetCoordinates(Scalar  px, Scalar  py, Scalar  pz, Scalar e)
{ fX=px; fY=py; fZ=pz; fT=e;}

/**
get internal data into 4 Scalar numbers
*/
void GetCoordinates(Scalar& px, Scalar& py, Scalar& pz, Scalar& e) const
{ px=fX; py=fY; pz=fZ; e=fT;}

// --------- Coordinates and Coordinate-like Scalar properties -------------

// cartesian (Minkowski)coordinate accessors

Scalar Px() const { return fX;}
Scalar Py() const { return fY;}
Scalar Pz() const { return fZ;}
Scalar E()  const { return fT;}

Scalar X() const { return fX;}
Scalar Y() const { return fY;}
Scalar Z() const { return fZ;}
Scalar T() const { return fT;}

// other coordinate representation

/**
squared magnitude of spatial components
*/
Scalar P2() const { return fX*fX + fY*fY + fZ*fZ; }

/**
magnitude of spatial components (magnitude of 3-momentum)
*/
Scalar P() const { return std::sqrt(P2()); }
Scalar R() const { return P(); }

/**
vector magnitude squared (or mass squared)
*/
Scalar M2() const   { return fT*fT - fX*fX - fY*fY - fZ*fZ;}
Scalar Mag2() const { return M2(); }

/**
invariant mass
*/
Scalar M() const    {
Scalar mm = M2();
if (mm >= 0) {
return std::sqrt(mm);
} else {
GenVector::Throw ("PxPyPzE4D::M() - Tachyonic:\n"
"    P^2 > E^2 so the mass would be imaginary");
return -std::sqrt(-mm);
}
}
Scalar Mag() const    { return M(); }

/**
transverse spatial component squared
*/
Scalar Pt2()   const { return fX*fX + fY*fY;}
Scalar Perp2() const { return Pt2();}

/**
Transverse spatial component (P_perp or rho)
*/
Scalar Pt()   const { return std::sqrt(Perp2());}
Scalar Perp() const { return Pt();}
Scalar Rho()  const { return Pt();}

/**
transverse mass squared
*/
Scalar Mt2() const { return fT*fT - fZ*fZ; }

/**
transverse mass
*/
Scalar Mt() const {
Scalar mm = Mt2();
if (mm >= 0) {
return std::sqrt(mm);
} else {
GenVector::Throw ("PxPyPzE4D::Mt() - Tachyonic:\n"
"    Pz^2 > E^2 so the transverse mass would be imaginary");
return -std::sqrt(-mm);
}
}

/**
transverse energy squared
*/
Scalar Et2() const {  // is (E^2 * pt ^2) / p^2
// but it is faster to form p^2 from pt^2
Scalar pt2 = Pt2();
return pt2 == 0 ? 0 : fT*fT * pt2/( pt2 + fZ*fZ );
}

/**
transverse energy
*/
Scalar Et() const {
Scalar etet = Et2();
return fT < 0.0 ? -std::sqrt(etet) : std::sqrt(etet);
}

/**
azimuthal angle
*/
Scalar Phi() const  {
return (fX == 0.0 && fY == 0.0) ? 0 : std::atan2(fY,fX);
}

/**
polar angle
*/
Scalar Theta() const {
return (fX == 0.0 && fY == 0.0 && fZ == 0.0) ? 0 : std::atan2(Pt(),fZ);
}

/**
pseudorapidity
*/
Scalar Eta() const {
return Impl::Eta_FromRhoZ ( Pt(), fZ);
}

// --------- Set Coordinates of this system  ---------------

/**
set X value
*/
void SetPx( Scalar  px) {
fX = px;
}
/**
set Y value
*/
void SetPy( Scalar  py) {
fY = py;
}
/**
set Z value
*/
void SetPz( Scalar  pz) {
fZ = pz;
}
/**
set T value
*/
void SetE( Scalar  e) {
fT = e;
}

/**
set all values using cartesian coordinates
*/
void SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e) {
fX=px;
fY=py;
fZ=pz;
fT=e;
}

// ------ Manipulations -------------

/**
negate the 4-vector
*/
void Negate( ) { fX = -fX; fY = -fY;  fZ = -fZ; fT = -fT;}

/**
scale coordinate values by a scalar quantity a
*/
void Scale( const Scalar & a) {
fX *= a;
fY *= a;
fZ *= a;
fT *= a;
}

/**
Assignment from a generic coordinate system implementing
x(), y(), z() and t()
*/
template <class AnyCoordSystem>
PxPyPzE4D & operator = (const AnyCoordSystem & v) {
fX = v.x();
fY = v.y();
fZ = v.z();
fT = v.t();
return *this;
}

/**
Exact equality
*/
bool operator == (const PxPyPzE4D & rhs) const {
return fX == rhs.fX && fY == rhs.fY && fZ == rhs.fZ && fT == rhs.fT;
}
bool operator != (const PxPyPzE4D & rhs) const {return !(operator==(rhs));}

// ============= Compatibility section ==================

// The following make this coordinate system look enough like a CLHEP
// vector that an assignment member template can work with either
Scalar x() const { return fX; }
Scalar y() const { return fY; }
Scalar z() const { return fZ; }
Scalar t() const { return fT; }

#if defined(__MAKECINT__) || defined(G__DICTIONARY)

// ====== Set member functions for coordinates in other systems =======

void SetPt(Scalar pt);

void SetEta(Scalar eta);

void SetPhi(Scalar phi);

void SetM(Scalar m);

#endif

private:

/**
(contigous) data containing the coordinate values x,y,z,t
*/

ScalarType fX;
ScalarType fY;
ScalarType fZ;
ScalarType fT;

};

} // end namespace Math
} // end namespace ROOT

#if defined(__MAKECINT__) || defined(G__DICTIONARY)
// move implementations here to avoid circle dependencies

#ifndef ROOT_Math_GenVector_PtEtaPhiE4D
#include "Math/GenVector/PtEtaPhiE4D.h"
#endif
#ifndef ROOT_Math_GenVector_PtEtaPhiM4D
#include "Math/GenVector/PtEtaPhiM4D.h"
#endif

namespace ROOT {

namespace Math {

// ====== Set member functions for coordinates in other systems =======
// throw always exceptions  in this case

template <class ScalarType>
void PxPyPzE4D<ScalarType>::SetPt(Scalar pt) {
GenVector_exception e("PxPyPzE4D::SetPt() is not supposed to be called");
throw e;
PtEtaPhiE4D<Scalar> v(*this); v.SetPt(pt); *this = PxPyPzE4D<Scalar>(v);
}
template <class ScalarType>
void PxPyPzE4D<ScalarType>::SetEta(Scalar eta) {
GenVector_exception e("PxPyPzE4D::SetEta() is not supposed to be called");
throw e;
PtEtaPhiE4D<Scalar> v(*this); v.SetEta(eta); *this = PxPyPzE4D<Scalar>(v);
}
template <class ScalarType>
void PxPyPzE4D<ScalarType>::SetPhi(Scalar phi) {
GenVector_exception e("PxPyPzE4D::SetPhi() is not supposed to be called");
throw e;
PtEtaPhiE4D<Scalar> v(*this); v.SetPhi(phi); *this = PxPyPzE4D<Scalar>(v);
}

template <class ScalarType>
void PxPyPzE4D<ScalarType>::SetM(Scalar m) {
GenVector_exception e("PxPyPzE4D::SetM() is not supposed to be called");
throw e;
PtEtaPhiM4D<Scalar> v(*this); v.SetM(m);
*this = PxPyPzE4D<Scalar>(v);
}

} // end namespace Math

} // end namespace ROOT

#endif  // endif __MAKE__CINT || G__DICTIONARY

#endif // ROOT_Math_GenVector_PxPyPzE4D
```
PxPyPzE4D.h:1
PxPyPzE4D.h:2
PxPyPzE4D.h:3
PxPyPzE4D.h:4
PxPyPzE4D.h:5
PxPyPzE4D.h:6
PxPyPzE4D.h:7
PxPyPzE4D.h:8
PxPyPzE4D.h:9
PxPyPzE4D.h:10
PxPyPzE4D.h:11
PxPyPzE4D.h:12
PxPyPzE4D.h:13
PxPyPzE4D.h:14
PxPyPzE4D.h:15
PxPyPzE4D.h:16
PxPyPzE4D.h:17
PxPyPzE4D.h:18
PxPyPzE4D.h:19
PxPyPzE4D.h:20
PxPyPzE4D.h:21
PxPyPzE4D.h:22
PxPyPzE4D.h:23
PxPyPzE4D.h:24
PxPyPzE4D.h:25
PxPyPzE4D.h:26
PxPyPzE4D.h:27
PxPyPzE4D.h:28
PxPyPzE4D.h:29
PxPyPzE4D.h:30
PxPyPzE4D.h:31
PxPyPzE4D.h:32
PxPyPzE4D.h:33
PxPyPzE4D.h:34
PxPyPzE4D.h:35
PxPyPzE4D.h:36
PxPyPzE4D.h:37
PxPyPzE4D.h:38
PxPyPzE4D.h:39
PxPyPzE4D.h:40
PxPyPzE4D.h:41
PxPyPzE4D.h:42
PxPyPzE4D.h:43
PxPyPzE4D.h:44
PxPyPzE4D.h:45
PxPyPzE4D.h:46
PxPyPzE4D.h:47
PxPyPzE4D.h:48
PxPyPzE4D.h:49
PxPyPzE4D.h:50
PxPyPzE4D.h:51
PxPyPzE4D.h:52
PxPyPzE4D.h:53
PxPyPzE4D.h:54
PxPyPzE4D.h:55
PxPyPzE4D.h:56
PxPyPzE4D.h:57
PxPyPzE4D.h:58
PxPyPzE4D.h:59
PxPyPzE4D.h:60
PxPyPzE4D.h:61
PxPyPzE4D.h:62
PxPyPzE4D.h:63
PxPyPzE4D.h:64
PxPyPzE4D.h:65
PxPyPzE4D.h:66
PxPyPzE4D.h:67
PxPyPzE4D.h:68
PxPyPzE4D.h:69
PxPyPzE4D.h:70
PxPyPzE4D.h:71
PxPyPzE4D.h:72
PxPyPzE4D.h:73
PxPyPzE4D.h:74
PxPyPzE4D.h:75
PxPyPzE4D.h:76
PxPyPzE4D.h:77
PxPyPzE4D.h:78
PxPyPzE4D.h:79
PxPyPzE4D.h:80
PxPyPzE4D.h:81
PxPyPzE4D.h:82
PxPyPzE4D.h:83
PxPyPzE4D.h:84
PxPyPzE4D.h:85
PxPyPzE4D.h:86
PxPyPzE4D.h:87
PxPyPzE4D.h:88
PxPyPzE4D.h:89
PxPyPzE4D.h:90
PxPyPzE4D.h:91
PxPyPzE4D.h:92
PxPyPzE4D.h:93
PxPyPzE4D.h:94
PxPyPzE4D.h:95
PxPyPzE4D.h:96
PxPyPzE4D.h:97
PxPyPzE4D.h:98
PxPyPzE4D.h:99
PxPyPzE4D.h:100
PxPyPzE4D.h:101
PxPyPzE4D.h:102
PxPyPzE4D.h:103
PxPyPzE4D.h:104
PxPyPzE4D.h:105
PxPyPzE4D.h:106
PxPyPzE4D.h:107
PxPyPzE4D.h:108
PxPyPzE4D.h:109
PxPyPzE4D.h:110
PxPyPzE4D.h:111
PxPyPzE4D.h:112
PxPyPzE4D.h:113
PxPyPzE4D.h:114
PxPyPzE4D.h:115
PxPyPzE4D.h:116
PxPyPzE4D.h:117
PxPyPzE4D.h:118
PxPyPzE4D.h:119
PxPyPzE4D.h:120
PxPyPzE4D.h:121
PxPyPzE4D.h:122
PxPyPzE4D.h:123
PxPyPzE4D.h:124
PxPyPzE4D.h:125
PxPyPzE4D.h:126
PxPyPzE4D.h:127
PxPyPzE4D.h:128
PxPyPzE4D.h:129
PxPyPzE4D.h:130
PxPyPzE4D.h:131
PxPyPzE4D.h:132
PxPyPzE4D.h:133
PxPyPzE4D.h:134
PxPyPzE4D.h:135
PxPyPzE4D.h:136
PxPyPzE4D.h:137
PxPyPzE4D.h:138
PxPyPzE4D.h:139
PxPyPzE4D.h:140
PxPyPzE4D.h:141
PxPyPzE4D.h:142
PxPyPzE4D.h:143
PxPyPzE4D.h:144
PxPyPzE4D.h:145
PxPyPzE4D.h:146
PxPyPzE4D.h:147
PxPyPzE4D.h:148
PxPyPzE4D.h:149
PxPyPzE4D.h:150
PxPyPzE4D.h:151
PxPyPzE4D.h:152
PxPyPzE4D.h:153
PxPyPzE4D.h:154
PxPyPzE4D.h:155
PxPyPzE4D.h:156
PxPyPzE4D.h:157
PxPyPzE4D.h:158
PxPyPzE4D.h:159
PxPyPzE4D.h:160
PxPyPzE4D.h:161
PxPyPzE4D.h:162
PxPyPzE4D.h:163
PxPyPzE4D.h:164
PxPyPzE4D.h:165
PxPyPzE4D.h:166
PxPyPzE4D.h:167
PxPyPzE4D.h:168
PxPyPzE4D.h:169
PxPyPzE4D.h:170
PxPyPzE4D.h:171
PxPyPzE4D.h:172
PxPyPzE4D.h:173
PxPyPzE4D.h:174
PxPyPzE4D.h:175
PxPyPzE4D.h:176
PxPyPzE4D.h:177
PxPyPzE4D.h:178
PxPyPzE4D.h:179
PxPyPzE4D.h:180
PxPyPzE4D.h:181
PxPyPzE4D.h:182
PxPyPzE4D.h:183
PxPyPzE4D.h:184
PxPyPzE4D.h:185
PxPyPzE4D.h:186
PxPyPzE4D.h:187
PxPyPzE4D.h:188
PxPyPzE4D.h:189
PxPyPzE4D.h:190
PxPyPzE4D.h:191
PxPyPzE4D.h:192
PxPyPzE4D.h:193
PxPyPzE4D.h:194
PxPyPzE4D.h:195
PxPyPzE4D.h:196
PxPyPzE4D.h:197
PxPyPzE4D.h:198
PxPyPzE4D.h:199
PxPyPzE4D.h:200
PxPyPzE4D.h:201
PxPyPzE4D.h:202
PxPyPzE4D.h:203
PxPyPzE4D.h:204
PxPyPzE4D.h:205
PxPyPzE4D.h:206
PxPyPzE4D.h:207
PxPyPzE4D.h:208
PxPyPzE4D.h:209
PxPyPzE4D.h:210
PxPyPzE4D.h:211
PxPyPzE4D.h:212
PxPyPzE4D.h:213
PxPyPzE4D.h:214
PxPyPzE4D.h:215
PxPyPzE4D.h:216
PxPyPzE4D.h:217
PxPyPzE4D.h:218
PxPyPzE4D.h:219
PxPyPzE4D.h:220
PxPyPzE4D.h:221
PxPyPzE4D.h:222
PxPyPzE4D.h:223
PxPyPzE4D.h:224
PxPyPzE4D.h:225
PxPyPzE4D.h:226
PxPyPzE4D.h:227
PxPyPzE4D.h:228
PxPyPzE4D.h:229
PxPyPzE4D.h:230
PxPyPzE4D.h:231
PxPyPzE4D.h:232
PxPyPzE4D.h:233
PxPyPzE4D.h:234
PxPyPzE4D.h:235
PxPyPzE4D.h:236
PxPyPzE4D.h:237
PxPyPzE4D.h:238
PxPyPzE4D.h:239
PxPyPzE4D.h:240
PxPyPzE4D.h:241
PxPyPzE4D.h:242
PxPyPzE4D.h:243
PxPyPzE4D.h:244
PxPyPzE4D.h:245
PxPyPzE4D.h:246
PxPyPzE4D.h:247
PxPyPzE4D.h:248
PxPyPzE4D.h:249
PxPyPzE4D.h:250
PxPyPzE4D.h:251
PxPyPzE4D.h:252
PxPyPzE4D.h:253
PxPyPzE4D.h:254
PxPyPzE4D.h:255
PxPyPzE4D.h:256
PxPyPzE4D.h:257
PxPyPzE4D.h:258
PxPyPzE4D.h:259
PxPyPzE4D.h:260
PxPyPzE4D.h:261
PxPyPzE4D.h:262
PxPyPzE4D.h:263
PxPyPzE4D.h:264
PxPyPzE4D.h:265
PxPyPzE4D.h:266
PxPyPzE4D.h:267
PxPyPzE4D.h:268
PxPyPzE4D.h:269
PxPyPzE4D.h:270
PxPyPzE4D.h:271
PxPyPzE4D.h:272
PxPyPzE4D.h:273
PxPyPzE4D.h:274
PxPyPzE4D.h:275
PxPyPzE4D.h:276
PxPyPzE4D.h:277
PxPyPzE4D.h:278
PxPyPzE4D.h:279
PxPyPzE4D.h:280
PxPyPzE4D.h:281
PxPyPzE4D.h:282
PxPyPzE4D.h:283
PxPyPzE4D.h:284
PxPyPzE4D.h:285
PxPyPzE4D.h:286
PxPyPzE4D.h:287
PxPyPzE4D.h:288
PxPyPzE4D.h:289
PxPyPzE4D.h:290
PxPyPzE4D.h:291
PxPyPzE4D.h:292
PxPyPzE4D.h:293
PxPyPzE4D.h:294
PxPyPzE4D.h:295
PxPyPzE4D.h:296
PxPyPzE4D.h:297
PxPyPzE4D.h:298
PxPyPzE4D.h:299
PxPyPzE4D.h:300
PxPyPzE4D.h:301
PxPyPzE4D.h:302
PxPyPzE4D.h:303
PxPyPzE4D.h:304
PxPyPzE4D.h:305
PxPyPzE4D.h:306
PxPyPzE4D.h:307
PxPyPzE4D.h:308
PxPyPzE4D.h:309
PxPyPzE4D.h:310
PxPyPzE4D.h:311
PxPyPzE4D.h:312
PxPyPzE4D.h:313
PxPyPzE4D.h:314
PxPyPzE4D.h:315
PxPyPzE4D.h:316
PxPyPzE4D.h:317
PxPyPzE4D.h:318
PxPyPzE4D.h:319
PxPyPzE4D.h:320
PxPyPzE4D.h:321
PxPyPzE4D.h:322
PxPyPzE4D.h:323
PxPyPzE4D.h:324
PxPyPzE4D.h:325
PxPyPzE4D.h:326
PxPyPzE4D.h:327
PxPyPzE4D.h:328
PxPyPzE4D.h:329
PxPyPzE4D.h:330
PxPyPzE4D.h:331
PxPyPzE4D.h:332
PxPyPzE4D.h:333
PxPyPzE4D.h:334
PxPyPzE4D.h:335
PxPyPzE4D.h:336
PxPyPzE4D.h:337
PxPyPzE4D.h:338
PxPyPzE4D.h:339
PxPyPzE4D.h:340
PxPyPzE4D.h:341
PxPyPzE4D.h:342
PxPyPzE4D.h:343
PxPyPzE4D.h:344
PxPyPzE4D.h:345
PxPyPzE4D.h:346
PxPyPzE4D.h:347
PxPyPzE4D.h:348
PxPyPzE4D.h:349
PxPyPzE4D.h:350
PxPyPzE4D.h:351
PxPyPzE4D.h:352
PxPyPzE4D.h:353
PxPyPzE4D.h:354
PxPyPzE4D.h:355
PxPyPzE4D.h:356
PxPyPzE4D.h:357
PxPyPzE4D.h:358
PxPyPzE4D.h:359
PxPyPzE4D.h:360
PxPyPzE4D.h:361
PxPyPzE4D.h:362
PxPyPzE4D.h:363
PxPyPzE4D.h:364
PxPyPzE4D.h:365
PxPyPzE4D.h:366
PxPyPzE4D.h:367
PxPyPzE4D.h:368
PxPyPzE4D.h:369
PxPyPzE4D.h:370
PxPyPzE4D.h:371
PxPyPzE4D.h:372
PxPyPzE4D.h:373
PxPyPzE4D.h:374
PxPyPzE4D.h:375
PxPyPzE4D.h:376
PxPyPzE4D.h:377
PxPyPzE4D.h:378
PxPyPzE4D.h:379
PxPyPzE4D.h:380
PxPyPzE4D.h:381
PxPyPzE4D.h:382
PxPyPzE4D.h:383
PxPyPzE4D.h:384
PxPyPzE4D.h:385
PxPyPzE4D.h:386
PxPyPzE4D.h:387
PxPyPzE4D.h:388
PxPyPzE4D.h:389
PxPyPzE4D.h:390
PxPyPzE4D.h:391
PxPyPzE4D.h:392
PxPyPzE4D.h:393
PxPyPzE4D.h:394
PxPyPzE4D.h:395
PxPyPzE4D.h:396
PxPyPzE4D.h:397
PxPyPzE4D.h:398
PxPyPzE4D.h:399
PxPyPzE4D.h:400
PxPyPzE4D.h:401
PxPyPzE4D.h:402
PxPyPzE4D.h:403
PxPyPzE4D.h:404
PxPyPzE4D.h:405
PxPyPzE4D.h:406
PxPyPzE4D.h:407
PxPyPzE4D.h:408
PxPyPzE4D.h:409
PxPyPzE4D.h:410
PxPyPzE4D.h:411