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

/**********************************************************************
*                                                                    *
* Copyright (c) 2005 ROOT FNAL MathLib Team                          *
*                                                                    *
*                                                                    *
**********************************************************************/

//
// Created by: Mark Fischler  Mon Nov 1  2005
//
// Last update: \$Id\$
//
#ifndef ROOT_Math_GenVector_BoostZ
#define ROOT_Math_GenVector_BoostZ 1

#include "Math/GenVector/LorentzVector.h"
#include "Math/GenVector/PxPyPzE4D.h"
#include "Math/GenVector/DisplacementVector3D.h"
#include "Math/GenVector/Cartesian3D.h"

namespace ROOT {

namespace Math {

//__________________________________________________________________________________________
/**
Class representing a Lorentz Boost along the Z axis, by beta.
For efficiency, gamma is held as well.

@ingroup GenVector
*/

class BoostZ {

public:

typedef double Scalar;

enum ELorentzRotationMatrixIndex {
kLXX =  0, kLXY =  1, kLXZ =  2, kLXT =  3
, kLYX =  4, kLYY =  5, kLYZ =  6, kLYT =  7
, kLZX =  8, kLZY =  9, kLZZ = 10, kLZT = 11
, kLTX = 12, kLTY = 13, kLTZ = 14, kLTT = 15
};

enum EBoostMatrixIndex {
kXX =  0, kXY =  1, kXZ =  2, kXT =  3
, kYY =  4, kYZ =  5, kYT =  6
, kZZ =  7, kZT =  8
, kTT =  9
};

// ========== Constructors and Assignment =====================

/**
Default constructor (identity transformation)
*/
BoostZ();

/**
Construct given a Scalar beta_z
*/
explicit BoostZ(Scalar beta_z) { SetComponents(beta_z); }

// The compiler-generated copy ctor, copy assignment, and dtor are OK.

/**
Re-adjust components to eliminate small deviations from a perfect
orthosyplectic matrix.
*/
void Rectify();

// ======== Components ==============

/**
Set components from a Scalar beta_z
*/
void
SetComponents (Scalar beta_z);

/**
Get components into a Scalar beta_z
*/
void
GetComponents (Scalar& beta_z) const;

/**
Retrieve the beta of the Boost
*/
Scalar Beta() const { return fBeta; }

/**
Retrieve the gamma of the Boost
*/
Scalar Gamma() const { return fGamma; }

/**
Set the given beta of the Boost
*/
void  SetBeta(Scalar beta) { SetComponents(beta); }

/**
The beta vector for this boost
*/
typedef  DisplacementVector3D<Cartesian3D<double>, DefaultCoordinateSystemTag > XYZVector;
XYZVector BetaVector() const;

/**
Get elements of internal 4x4 symmetric representation, into a data
array suitable for direct use as the components of a LorentzRotation
Note -- 16 Scalars will be written into the array; if the array is not
that large, then this will lead to undefined behavior.
*/
void
GetLorentzRotation (Scalar r[]) const;

// =========== operations ==============

/**
Lorentz transformation operation on a Minkowski ('Cartesian')
LorentzVector
*/
LorentzVector< ROOT::Math::PxPyPzE4D<double> >
operator() (const LorentzVector< ROOT::Math::PxPyPzE4D<double> > & v) const;

/**
Lorentz transformation operation on a LorentzVector in any
coordinate system
*/
template <class CoordSystem>
LorentzVector<CoordSystem>
operator() (const LorentzVector<CoordSystem> & v) const {
LorentzVector< PxPyPzE4D<double> > xyzt(v);
LorentzVector< PxPyPzE4D<double> > r_xyzt = operator()(xyzt);
return LorentzVector<CoordSystem> ( r_xyzt );
}

/**
Lorentz transformation operation on an arbitrary 4-vector v.
Preconditions:  v must implement methods x(), y(), z(), and t()
and the arbitrary vector type must have a constructor taking (x,y,z,t)
*/
template <class Foreign4Vector>
Foreign4Vector
operator() (const Foreign4Vector & v) const {
LorentzVector< PxPyPzE4D<double> > xyzt(v);
LorentzVector< PxPyPzE4D<double> > r_xyzt = operator()(xyzt);
return Foreign4Vector ( r_xyzt.X(), r_xyzt.Y(), r_xyzt.Z(), r_xyzt.T() );
}

/**
Overload operator * for boost on a vector
*/
template <class A4Vector>
inline
A4Vector operator* (const A4Vector & v) const
{
return operator()(v);
}

/**
Invert a BoostZ in place
*/
void Invert();

/**
Return inverse of  a BoostZ
*/
BoostZ Inverse() const;

/**
Equality/inequality operators
*/
bool operator == (const BoostZ & rhs) const {
if( fBeta  != rhs.fBeta  ) return false;
if( fGamma != rhs.fGamma ) return false;
return true;
}
bool operator != (const BoostZ & rhs) const {
return ! operator==(rhs);
}

private:

Scalar fBeta;    // boost beta z
Scalar fGamma;   // boost gamma

};  // BoostZ

// ============ Class BoostZ ends here ============

/**
Stream Output and Input
*/
// TODO - I/O should be put in the manipulator form

std::ostream & operator<< (std::ostream & os, const BoostZ & b);

} //namespace Math
} //namespace ROOT

#endif /* ROOT_Math_GenVector_BoostZ  */
```
BoostZ.h:1
BoostZ.h:2
BoostZ.h:3
BoostZ.h:4
BoostZ.h:5
BoostZ.h:6
BoostZ.h:7
BoostZ.h:8
BoostZ.h:9
BoostZ.h:10
BoostZ.h:11
BoostZ.h:12
BoostZ.h:13
BoostZ.h:14
BoostZ.h:15
BoostZ.h:16
BoostZ.h:17
BoostZ.h:18
BoostZ.h:19
BoostZ.h:20
BoostZ.h:21
BoostZ.h:22
BoostZ.h:23
BoostZ.h:24
BoostZ.h:25
BoostZ.h:26
BoostZ.h:27
BoostZ.h:28
BoostZ.h:29
BoostZ.h:30
BoostZ.h:31
BoostZ.h:32
BoostZ.h:33
BoostZ.h:34
BoostZ.h:35
BoostZ.h:36
BoostZ.h:37
BoostZ.h:38
BoostZ.h:39
BoostZ.h:40
BoostZ.h:41
BoostZ.h:42
BoostZ.h:43
BoostZ.h:44
BoostZ.h:45
BoostZ.h:46
BoostZ.h:47
BoostZ.h:48
BoostZ.h:49
BoostZ.h:50
BoostZ.h:51
BoostZ.h:52
BoostZ.h:53
BoostZ.h:54
BoostZ.h:55
BoostZ.h:56
BoostZ.h:57
BoostZ.h:58
BoostZ.h:59
BoostZ.h:60
BoostZ.h:61
BoostZ.h:62
BoostZ.h:63
BoostZ.h:64
BoostZ.h:65
BoostZ.h:66
BoostZ.h:67
BoostZ.h:68
BoostZ.h:69
BoostZ.h:70
BoostZ.h:71
BoostZ.h:72
BoostZ.h:73
BoostZ.h:74
BoostZ.h:75
BoostZ.h:76
BoostZ.h:77
BoostZ.h:78
BoostZ.h:79
BoostZ.h:80
BoostZ.h:81
BoostZ.h:82
BoostZ.h:83
BoostZ.h:84
BoostZ.h:85
BoostZ.h:86
BoostZ.h:87
BoostZ.h:88
BoostZ.h:89
BoostZ.h:90
BoostZ.h:91
BoostZ.h:92
BoostZ.h:93
BoostZ.h:94
BoostZ.h:95
BoostZ.h:96
BoostZ.h:97
BoostZ.h:98
BoostZ.h:99
BoostZ.h:100
BoostZ.h:101
BoostZ.h:102
BoostZ.h:103
BoostZ.h:104
BoostZ.h:105
BoostZ.h:106
BoostZ.h:107
BoostZ.h:108
BoostZ.h:109
BoostZ.h:110
BoostZ.h:111
BoostZ.h:112
BoostZ.h:113
BoostZ.h:114
BoostZ.h:115
BoostZ.h:116
BoostZ.h:117
BoostZ.h:118
BoostZ.h:119
BoostZ.h:120
BoostZ.h:121
BoostZ.h:122
BoostZ.h:123
BoostZ.h:124
BoostZ.h:125
BoostZ.h:126
BoostZ.h:127
BoostZ.h:128
BoostZ.h:129
BoostZ.h:130
BoostZ.h:131
BoostZ.h:132
BoostZ.h:133
BoostZ.h:134
BoostZ.h:135
BoostZ.h:136
BoostZ.h:137
BoostZ.h:138
BoostZ.h:139
BoostZ.h:140
BoostZ.h:141
BoostZ.h:142
BoostZ.h:143
BoostZ.h:144
BoostZ.h:145
BoostZ.h:146
BoostZ.h:147
BoostZ.h:148
BoostZ.h:149
BoostZ.h:150
BoostZ.h:151
BoostZ.h:152
BoostZ.h:153
BoostZ.h:154
BoostZ.h:155
BoostZ.h:156
BoostZ.h:157
BoostZ.h:158
BoostZ.h:159
BoostZ.h:160
BoostZ.h:161
BoostZ.h:162
BoostZ.h:163
BoostZ.h:164
BoostZ.h:165
BoostZ.h:166
BoostZ.h:167
BoostZ.h:168
BoostZ.h:169
BoostZ.h:170
BoostZ.h:171
BoostZ.h:172
BoostZ.h:173
BoostZ.h:174
BoostZ.h:175
BoostZ.h:176
BoostZ.h:177
BoostZ.h:178
BoostZ.h:179
BoostZ.h:180
BoostZ.h:181
BoostZ.h:182
BoostZ.h:183
BoostZ.h:184
BoostZ.h:185
BoostZ.h:186
BoostZ.h:187
BoostZ.h:188
BoostZ.h:189
BoostZ.h:190
BoostZ.h:191
BoostZ.h:192
BoostZ.h:193
BoostZ.h:194
BoostZ.h:195
BoostZ.h:196
BoostZ.h:197
BoostZ.h:198
BoostZ.h:199
BoostZ.h:200
BoostZ.h:201
BoostZ.h:202
BoostZ.h:203
BoostZ.h:204
BoostZ.h:205
BoostZ.h:206
BoostZ.h:207
BoostZ.h:208
BoostZ.h:209
BoostZ.h:210
BoostZ.h:211
BoostZ.h:212
BoostZ.h:213
BoostZ.h:214
BoostZ.h:215