/usr/include/Rivet/Math/LorentzTrans.hh is in librivet-dev 1.8.3-1.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | #ifndef RIVET_MATH_LORENTZTRANS
#define RIVET_MATH_LORENTZTRANS
#include <iostream>
#include "Rivet/Math/MathHeader.hh"
#include "Rivet/Math/MathUtils.hh"
#include "Rivet/Math/MatrixN.hh"
#include "Rivet/Math/Matrix3.hh"
#include "Rivet/Math/Vector4.hh"
namespace Rivet {
inline double lorentzGamma(const double beta) {
return 1.0 / sqrt(1 - beta*beta);
}
/// @brief Object implementing Lorentz transform calculations and boosts.
class LorentzTransform {
friend string toString(const LorentzTransform& lt);
public:
LorentzTransform() {
_boostMatrix = Matrix<4>::mkIdentity();
}
LorentzTransform(const Vector3& boost) {
setBoost(boost);
}
LorentzTransform(const double betaX, const double betaY, const double betaZ) {
setBoost(betaX, betaY, betaZ);
}
LorentzTransform& setBoost(const Vector3& boost) {
assert(boost.mod2() < 1);
const double beta = boost.mod();
const double gamma = lorentzGamma(beta);
_boostMatrix = Matrix<4>::mkIdentity();
_boostMatrix.set(0, 0, gamma);
_boostMatrix.set(1, 1, gamma);
// Positive coeff since these are active boosts
_boostMatrix.set(0, 1, +beta*gamma);
_boostMatrix.set(1, 0, +beta*gamma);
_boostMatrix = rotate(Vector3::mkX(), boost)._boostMatrix;
return *this;
}
// LorentzTransform& setBoost(const Vector3& boostdirection, const double beta) {
// const Vector3 boost = boostdirection.unit() * beta;
// return setBoost(boost);
// }
LorentzTransform& setBoost(const double betaX, const double betaY, const double betaZ) {
return setBoost(Vector3(betaX, betaY, betaZ));
}
Vector3 boost() const {
FourMomentum boost(_boostMatrix.getColumn(0));
//cout << "!!!" << boost << endl;
if (boost.isZero()) return boost;
assert(boost.E() > 0);
const double beta = boost.p().mod() / boost.E();
return boost.p().unit() * beta;
}
double beta() const {
return boost().mod();
}
double gamma() const {
return lorentzGamma(beta());
}
LorentzTransform rotate(const Vector3& from, const Vector3& to) const {
return rotate(Matrix3(from, to));
}
LorentzTransform rotate(const Vector3& axis, const double angle) const {
return rotate(Matrix3(axis, angle));
}
LorentzTransform rotate(const Matrix3& rot) const {
LorentzTransform lt = *this;
const Matrix4 rot4 = mkMatrix4(rot);
const Matrix4 newlt = rot4 * _boostMatrix * rot4.inverse();
lt._boostMatrix = newlt;
return lt;
}
FourVector transform(const FourVector& v4) const {
return multiply(_boostMatrix, v4);
}
LorentzTransform inverse() const {
LorentzTransform rtn;
rtn._boostMatrix = _boostMatrix.inverse();
return rtn;
}
/// Combine LTs, treating @a this as the LH matrix.
LorentzTransform combine(const LorentzTransform& lt) const {
LorentzTransform rtn;
rtn._boostMatrix = _boostMatrix * lt._boostMatrix;
return rtn;
}
Matrix4 toMatrix() const {
return _boostMatrix;
}
LorentzTransform operator*(const LorentzTransform& lt) const {
return combine(lt);
}
LorentzTransform preMult(const Matrix3 & m3) {
_boostMatrix = multiply(mkMatrix4(m3),_boostMatrix);
return *this;
}
LorentzTransform postMult(const Matrix3 & m3) {
_boostMatrix *= mkMatrix4(m3);
return *this;
}
private:
Matrix4 mkMatrix4(const Matrix3& m3) const {
Matrix4 m4 = Matrix4::mkIdentity();
for (size_t i = 0; i < 3; ++i) {
for (size_t j = 0; j < 3; ++j) {
m4.set(i+1, j+1, m3.get(i, j));
}
}
return m4;
}
private:
Matrix4 _boostMatrix;
};
inline LorentzTransform inverse(const LorentzTransform& lt) {
return lt.inverse();
}
inline LorentzTransform combine(const LorentzTransform& a, const LorentzTransform& b) {
return a.combine(b);
}
inline FourVector transform(const LorentzTransform& lt, const FourVector& v4) {
return lt.transform(v4);
}
//////////////////////////
inline string toString(const LorentzTransform& lt) {
return toString(lt._boostMatrix);
}
inline ostream& operator<<(std::ostream& out, const LorentzTransform& lt) {
out << toString(lt);
return out;
}
}
#endif
|