Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Classes | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Friends | List of all members
CLHEP::HepLorentzRotation Class Reference

#include <LorentzRotation.h>

Classes

class  HepLorentzRotation_row
 

Public Member Functions

 HepLorentzRotation ()
 
 HepLorentzRotation (const HepLorentzRotation &r)
 
 HepLorentzRotation (HepLorentzRotation &&r)=default
 
 HepLorentzRotation (const HepRotation &r)
 
 HepLorentzRotation (const HepRotationX &r)
 
 HepLorentzRotation (const HepRotationY &r)
 
 HepLorentzRotation (const HepRotationZ &r)
 
 HepLorentzRotation (const HepBoost &b)
 
 HepLorentzRotation (const HepBoostX &b)
 
 HepLorentzRotation (const HepBoostY &b)
 
 HepLorentzRotation (const HepBoostZ &b)
 
HepLorentzRotation & operator= (HepLorentzRotation &&m)=default
 
HepLorentzRotation & operator= (const HepLorentzRotation &m)
 
HepLorentzRotation & operator= (const HepRotation &m)
 
HepLorentzRotation & operator= (const HepBoost &m)
 
HepLorentzRotation & set (double bx, double by, double bz)
 
HepLorentzRotation & set (const Hep3Vector &p)
 
HepLorentzRotation & set (const HepRotation &r)
 
HepLorentzRotation & set (const HepRotationX &r)
 
HepLorentzRotation & set (const HepRotationY &r)
 
HepLorentzRotation & set (const HepRotationZ &r)
 
HepLorentzRotation & set (const HepBoost &boost)
 
HepLorentzRotation & set (const HepBoostX &boost)
 
HepLorentzRotation & set (const HepBoostY &boost)
 
HepLorentzRotation & set (const HepBoostZ &boost)
 
 HepLorentzRotation (double bx, double by, double bz)
 
 HepLorentzRotation (const Hep3Vector &p)
 
HepLorentzRotation & set (const HepBoost &B, const HepRotation &R)
 
 HepLorentzRotation (const HepBoost &B, const HepRotation &R)
 
HepLorentzRotation & set (const HepRotation &R, const HepBoost &B)
 
 HepLorentzRotation (const HepRotation &R, const HepBoost &B)
 
 HepLorentzRotation (const HepLorentzVector &col1, const HepLorentzVector &col2, const HepLorentzVector &col3, const HepLorentzVector &col4)
 
HepLorentzRotation & set (const HepLorentzVector &col1, const HepLorentzVector &col2, const HepLorentzVector &col3, const HepLorentzVector &col4)
 
HepLorentzRotation & setRows (const HepLorentzVector &row1, const HepLorentzVector &row2, const HepLorentzVector &row3, const HepLorentzVector &row4)
 
HepLorentzRotation & set (const HepRep4x4 &rep)
 
 HepLorentzRotation (const HepRep4x4 &rep)
 
double xx () const
 
double xy () const
 
double xz () const
 
double xt () const
 
double yx () const
 
double yy () const
 
double yz () const
 
double yt () const
 
double zx () const
 
double zy () const
 
double zz () const
 
double zt () const
 
double tx () const
 
double ty () const
 
double tz () const
 
double tt () const
 
HepLorentzVector col1 () const
 
HepLorentzVector col2 () const
 
HepLorentzVector col3 () const
 
HepLorentzVector col4 () const
 
HepLorentzVector row1 () const
 
HepLorentzVector row2 () const
 
HepLorentzVector row3 () const
 
HepLorentzVector row4 () const
 
HepRep4x4 rep4x4 () const
 
const HepLorentzRotation_row operator[] (int) const
 
double operator() (int, int) const
 
void decompose (Hep3Vector &boost, HepAxisAngle &rotation) const
 
void decompose (HepBoost &boost, HepRotation &rotation) const
 
void decompose (HepAxisAngle &rotation, Hep3Vector &boost) const
 
void decompose (HepRotation &rotation, HepBoost &boost) const
 
int compare (const HepLorentzRotation &m) const
 
bool operator== (const HepLorentzRotation &) const
 
bool operator!= (const HepLorentzRotation &) const
 
bool operator<= (const HepLorentzRotation &) const
 
bool operator>= (const HepLorentzRotation &) const
 
bool operator< (const HepLorentzRotation &) const
 
bool operator> (const HepLorentzRotation &) const
 
bool isIdentity () const
 
double distance2 (const HepBoost &b) const
 
double distance2 (const HepRotation &r) const
 
double distance2 (const HepLorentzRotation &lt) const
 
double howNear (const HepBoost &b) const
 
double howNear (const HepRotation &r) const
 
double howNear (const HepLorentzRotation &lt) const
 
bool isNear (const HepBoost &b, double epsilon=Hep4RotationInterface::tolerance) const
 
bool isNear (const HepRotation &r, double epsilon=Hep4RotationInterface::tolerance) const
 
bool isNear (const HepLorentzRotation &lt, double epsilon=Hep4RotationInterface::tolerance) const
 
double norm2 () const
 
void rectify ()
 
HepLorentzVector vectorMultiplication (const HepLorentzVector &) const
 
HepLorentzVector operator() (const HepLorentzVector &w) const
 
HepLorentzVector operator* (const HepLorentzVector &p) const
 
HepLorentzRotation matrixMultiplication (const HepRep4x4 &m) const
 
HepLorentzRotation operator* (const HepBoost &b) const
 
HepLorentzRotation operator* (const HepRotation &r) const
 
HepLorentzRotation operator* (const HepLorentzRotation &lt) const
 
HepLorentzRotation & operator*= (const HepBoost &b)
 
HepLorentzRotation & operator*= (const HepRotation &r)
 
HepLorentzRotation & operator*= (const HepLorentzRotation &lt)
 
HepLorentzRotation & transform (const HepBoost &b)
 
HepLorentzRotation & transform (const HepRotation &r)
 
HepLorentzRotation & transform (const HepLorentzRotation &lt)
 
HepLorentzRotation & rotateX (double delta)
 
HepLorentzRotation & rotateY (double delta)
 
HepLorentzRotation & rotateZ (double delta)
 
HepLorentzRotation & rotate (double delta, const Hep3Vector &axis)
 
HepLorentzRotation & rotate (double delta, const Hep3Vector *axis)
 
HepLorentzRotation & boostX (double beta)
 
HepLorentzRotation & boostY (double beta)
 
HepLorentzRotation & boostZ (double beta)
 
HepLorentzRotation & boost (double, double, double)
 
HepLorentzRotation & boost (const Hep3Vector &)
 
HepLorentzRotation inverse () const
 
HepLorentzRotation & invert ()
 
std::ostream & print (std::ostream &os) const
 

Static Public Member Functions

static double getTolerance ()
 
static double setTolerance (double tol)
 

Static Public Attributes

static DLL_API const HepLorentzRotation IDENTITY
 

Protected Member Functions

 HepLorentzRotation (double mxx, double mxy, double mxz, double mxt, double myx, double myy, double myz, double myt, double mzx, double mzy, double mzz, double mzt, double mtx, double mty, double mtz, double mtt)
 
void setBoost (double, double, double)
 

Protected Attributes

double mxx
 
double mxy
 
double mxz
 
double mxt
 
double myx
 
double myy
 
double myz
 
double myt
 
double mzx
 
double mzy
 
double mzz
 
double mzt
 
double mtx
 
double mty
 
double mtz
 
double mtt
 

Friends

HepLorentzRotation inverseOf (const HepLorentzRotation &lt)
 

Detailed Description

Author

Definition at line 48 of file LorentzRotation.h.

Constructor & Destructor Documentation

◆ HepLorentzRotation() [1/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( )
inline

Referenced by matrixMultiplication(), and set().

◆ HepLorentzRotation() [2/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepLorentzRotation &  r)
inline

◆ HepLorentzRotation() [3/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( HepLorentzRotation &&  r)
inlinedefault

◆ HepLorentzRotation() [4/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepRotation &  r)
inline

◆ HepLorentzRotation() [5/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepRotationX &  r)
inlineexplicit

◆ HepLorentzRotation() [6/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepRotationY &  r)
inlineexplicit

◆ HepLorentzRotation() [7/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepRotationZ &  r)
inlineexplicit

◆ HepLorentzRotation() [8/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepBoost &  b)
inline

◆ HepLorentzRotation() [9/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepBoostX &  b)
inlineexplicit

◆ HepLorentzRotation() [10/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepBoostY &  b)
inlineexplicit

◆ HepLorentzRotation() [11/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepBoostZ &  b)
inlineexplicit

◆ HepLorentzRotation() [12/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( double  bx,
double  by,
double  bz 
)
inline

◆ HepLorentzRotation() [13/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const Hep3Vector &  p)
inline

◆ HepLorentzRotation() [14/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepBoost &  B,
const HepRotation &  R 
)
inline

◆ HepLorentzRotation() [15/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepRotation &  R,
const HepBoost &  B 
)
inline

◆ HepLorentzRotation() [16/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepLorentzVector &  col1,
const HepLorentzVector &  col2,
const HepLorentzVector &  col3,
const HepLorentzVector &  col4 
)

Definition at line 195 of file LorentzRotationC.cc.

199{
200 set ( ccol1, ccol2, ccol3, ccol4 );
201}
CLHEP::HepLorentzRotation::set
HepLorentzRotation & set(double bx, double by, double bz)
Definition: LorentzRotation.cc:23

◆ HepLorentzRotation() [17/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( const HepRep4x4 &  rep)
inline

◆ HepLorentzRotation() [18/18]

CLHEP::HepLorentzRotation::HepLorentzRotation ( double  mxx,
double  mxy,
double  mxz,
double  mxt,
double  myx,
double  myy,
double  myz,
double  myt,
double  mzx,
double  mzy,
double  mzz,
double  mzt,
double  mtx,
double  mty,
double  mtz,
double  mtt 
)
inlineprotected

Member Function Documentation

◆ boost() [1/2]

HepLorentzRotation & CLHEP::HepLorentzRotation::boost ( const Hep3Vector &  )
inline

◆ boost() [2/2]

HepLorentzRotation & CLHEP::HepLorentzRotation::boost ( double  ,
double  ,
double   
)
inline

◆ boostX()

HepLorentzRotation & CLHEP::HepLorentzRotation::boostX ( double  beta)

Definition at line 182 of file LorentzRotation.cc.

182 {
183 double b2 = beta*beta;
184// if (b2 >= 1) {
185// std::cerr << "HepLorentzRotation::boostX() - "
186// << "Beta supplied to HepLorentzRotation::boostX represents speed >= c."
187// << std::endl;
188// }
189 double g1 = 1.0/std::sqrt(1.0-b2);
190 double bg = beta*g1;
191 HepLorentzVector rowx = row1();
192 HepLorentzVector rowt = row4();
193 HepLorentzVector r1 = g1 * rowx + bg * rowt;
194 HepLorentzVector r4 = bg * rowx + g1 * rowt;
195 mxx = r1.x(); mxy = r1.y(); mxz = r1.z(); mxt = r1.t();
196 mtx = r4.x(); mty = r4.y(); mtz = r4.z(); mtt = r4.t();
197 return *this;
198}
CLHEP::HepLorentzRotation::row1
HepLorentzVector row1() const
CLHEP::HepLorentzRotation::row4
HepLorentzVector row4() const

◆ boostY()

HepLorentzRotation & CLHEP::HepLorentzRotation::boostY ( double  beta)

Definition at line 200 of file LorentzRotation.cc.

200 {
201 double b2 = beta*beta;
202// if (b2 >= 1) {
203// std::cerr << "HepLorentzRotation::boostY() - "
204// << "Beta supplied to HepLorentzRotation::boostY represents speed >= c."
205// << std::endl;
206// }
207 double g1 = 1.0/std::sqrt(1.0-b2);
208 double bg = beta*g1;
209 HepLorentzVector rowy = row2();
210 HepLorentzVector rowt = row4();
211 HepLorentzVector r2 = g1 * rowy + bg * rowt;
212 HepLorentzVector r4 = bg * rowy + g1 * rowt;
213 myx = r2.x(); myy = r2.y(); myz = r2.z(); myt = r2.t();
214 mtx = r4.x(); mty = r4.y(); mtz = r4.z(); mtt = r4.t();
215 return *this;
216}
CLHEP::HepLorentzRotation::row2
HepLorentzVector row2() const

◆ boostZ()

HepLorentzRotation & CLHEP::HepLorentzRotation::boostZ ( double  beta)

Definition at line 218 of file LorentzRotation.cc.

218 {
219 double b2 = beta*beta;
220// if (b2 >= 1) {
221// std::cerr << "HepLorentzRotation::boostZ() - "
222// << "Beta supplied to HepLorentzRotation::boostZ represents speed >= c."
223// << std::endl;
224// }
225 double g1 = 1.0/std::sqrt(1.0-b2);
226 double bg = beta*g1;
227 HepLorentzVector rowz = row3();
228 HepLorentzVector rowt = row4();
229 HepLorentzVector r3 = g1 * rowz + bg * rowt;
230 HepLorentzVector r4 = bg * rowz + g1 * rowt;
231 mtx = r4.x(); mty = r4.y(); mtz = r4.z(); mtt = r4.t();
232 mzx = r3.x(); mzy = r3.y(); mzz = r3.z(); mzt = r3.t();
233 return *this;
234}
CLHEP::HepLorentzRotation::row3
HepLorentzVector row3() const

◆ col1()

HepLorentzVector CLHEP::HepLorentzRotation::col1 ( ) const
inline

◆ col2()

HepLorentzVector CLHEP::HepLorentzRotation::col2 ( ) const
inline

◆ col3()

HepLorentzVector CLHEP::HepLorentzRotation::col3 ( ) const
inline

◆ col4()

HepLorentzVector CLHEP::HepLorentzRotation::col4 ( ) const
inline

◆ compare()

int CLHEP::HepLorentzRotation::compare ( const HepLorentzRotation &  m) const

Definition at line 95 of file LorentzRotation.cc.

95 {
96 if (mtt<m1.mtt) return -1; else if (mtt>m1.mtt) return 1;
97 else if (mtz<m1.mtz) return -1; else if (mtz>m1.mtz) return 1;
98 else if (mty<m1.mty) return -1; else if (mty>m1.mty) return 1;
99 else if (mtx<m1.mtx) return -1; else if (mtx>m1.mtx) return 1;
100
101 else if (mzt<m1.mzt) return -1; else if (mzt>m1.mzt) return 1;
102 else if (mzz<m1.mzz) return -1; else if (mzz>m1.mzz) return 1;
103 else if (mzy<m1.mzy) return -1; else if (mzy>m1.mzy) return 1;
104 else if (mzx<m1.mzx) return -1; else if (mzx>m1.mzx) return 1;
105
106 else if (myt<m1.myt) return -1; else if (myt>m1.myt) return 1;
107 else if (myz<m1.myz) return -1; else if (myz>m1.myz) return 1;
108 else if (myy<m1.myy) return -1; else if (myy>m1.myy) return 1;
109 else if (myx<m1.myx) return -1; else if (myx>m1.myx) return 1;
110
111 else if (mxt<m1.mxt) return -1; else if (mxt>m1.mxt) return 1;
112 else if (mxz<m1.mxz) return -1; else if (mxz>m1.mxz) return 1;
113 else if (mxy<m1.mxy) return -1; else if (mxy>m1.mxy) return 1;
114 else if (mxx<m1.mxx) return -1; else if (mxx>m1.mxx) return 1;
115
116 else return 0;
117}

◆ decompose() [1/4]

void CLHEP::HepLorentzRotation::decompose ( Hep3Vector &  boost,
HepAxisAngle &  rotation 
) const

Definition at line 45 of file LorentzRotationD.cc.

46 {
47 HepRotation r;
48 HepBoost b;
49 decompose(b,r);
50 bboost = b.boostVector();
51 rotation = r.axisAngle();
52 return;
53}
CLHEP::HepLorentzRotation::decompose
void decompose(Hep3Vector &boost, HepAxisAngle &rotation) const
Definition: LorentzRotationD.cc:46

Referenced by decompose(), distance2(), CLHEP::HepBoost::distance2(), CLHEP::HepBoostX::distance2(), CLHEP::HepBoostY::distance2(), CLHEP::HepBoostZ::distance2(), CLHEP::HepRotation::distance2(), CLHEP::HepRotationX::distance2(), CLHEP::HepRotationY::distance2(), CLHEP::HepRotationZ::distance2(), isNear(), CLHEP::HepBoost::isNear(), CLHEP::HepBoostX::isNear(), CLHEP::HepBoostY::isNear(), CLHEP::HepBoostZ::isNear(), and norm2().

◆ decompose() [2/4]

void CLHEP::HepLorentzRotation::decompose ( HepAxisAngle &  rotation,
Hep3Vector &  boost 
) const

Definition at line 78 of file LorentzRotationD.cc.

79 {
80 HepRotation r;
81 HepBoost b;
82 decompose(r,b);
83 rotation = r.axisAngle();
84 bboost = b.boostVector();
85 return;
86}

◆ decompose() [3/4]

void CLHEP::HepLorentzRotation::decompose ( HepBoost &  boost,
HepRotation &  rotation 
) const

Definition at line 18 of file LorentzRotationD.cc.

19 {
20
21 // The boost will be the pure boost based on column 4 of the transformation
22 // matrix. Since the constructor takes the beta vector, and not beta*gamma,
23 // we first divide through by gamma = the tt element. This of course can
24 // never be zero since the last row has t**2 - v**2 = +1.
25
26 Hep3Vector betaVec ( xt(), yt(), zt() );
27 betaVec *= 1.0 / tt();
28 bboost.set( betaVec );
29
30 // The rotation will be inverse of B times T.
31
32 HepBoost B( -betaVec );
33 HepLorentzRotation R( B * *this );
34
35 HepRep3x3 m1 ( R.xx(), R.xy(), R.xz(),
36 R.yx(), R.yy(), R.yz(),
37 R.zx(), R.zy(), R.zz() );
38 rotation.set( m1 );
39 rotation.rectify();
40
41 return;
42
43}
B
double B(double temperature)
Definition: G4DNAElectronHoleRecombination.cc:69

◆ decompose() [4/4]

void CLHEP::HepLorentzRotation::decompose ( HepRotation &  rotation,
HepBoost &  boost 
) const

Definition at line 55 of file LorentzRotationD.cc.

56 {
57
58 // In this case the pure boost is based on row 4 of the matrix.
59
60 Hep3Vector betaVec( tx(), ty(), tz() );
61 betaVec *= 1.0 / tt();
62 bboost.set( betaVec );
63
64 // The rotation will be T times the inverse of B.
65
66 HepBoost B( -betaVec );
67 HepLorentzRotation R( *this * B );
68
69 HepRep3x3 m1 ( R.xx(), R.xy(), R.xz(),
70 R.yx(), R.yy(), R.yz(),
71 R.zx(), R.zy(), R.zz() );
72 rotation.set( m1 );
73 rotation.rectify();
74 return;
75
76}

◆ distance2() [1/3]

double CLHEP::HepLorentzRotation::distance2 ( const HepBoost &  b) const

Definition at line 88 of file LorentzRotationD.cc.

88 {
89 HepBoost b1;
90 HepRotation r1;
91 decompose( b1, r1 );
92 double db2 = b1.distance2( b );
93 double dr2 = r1.norm2();
94 return ( db2 + dr2 );
95}

Referenced by howNear().

◆ distance2() [2/3]

double CLHEP::HepLorentzRotation::distance2 ( const HepLorentzRotation &  lt) const

Definition at line 106 of file LorentzRotationD.cc.

107 {
108 HepBoost b1;
109 HepRotation r1;
110 decompose( b1, r1 );
111 HepBoost b2;
112 HepRotation r2;
113 lt.decompose (b2, r2);
114 double db2 = b1.distance2( b2 );
115 double dr2 = r1.distance2( r2 );
116 return ( db2 + dr2 );
117}

◆ distance2() [3/3]

double CLHEP::HepLorentzRotation::distance2 ( const HepRotation &  r) const

Definition at line 97 of file LorentzRotationD.cc.

97 {
98 HepBoost b1;
99 HepRotation r1;
100 decompose( b1, r1 );
101 double db2 = b1.norm2( );
102 double dr2 = r1.distance2( r );
103 return ( db2 + dr2 );
104}

◆ getTolerance()

static double CLHEP::HepLorentzRotation::getTolerance ( )
inlinestatic

◆ howNear() [1/3]

double CLHEP::HepLorentzRotation::howNear ( const HepBoost &  b) const

Definition at line 119 of file LorentzRotationD.cc.

119 {
120 return std::sqrt( distance2( b ) );
121}
CLHEP::HepLorentzRotation::distance2
double distance2(const HepBoost &b) const
Definition: LorentzRotationD.cc:88

◆ howNear() [2/3]

double CLHEP::HepLorentzRotation::howNear ( const HepLorentzRotation &  lt) const

Definition at line 125 of file LorentzRotationD.cc.

125 {
126 return std::sqrt( distance2( lt ) );
127}

◆ howNear() [3/3]

double CLHEP::HepLorentzRotation::howNear ( const HepRotation &  r) const

Definition at line 122 of file LorentzRotationD.cc.

122 {
123 return std::sqrt( distance2( r ) );
124}

◆ inverse()

HepLorentzRotation CLHEP::HepLorentzRotation::inverse ( ) const
inline

Referenced by G4FTFAnnihilation::Annihilate(), G4BinaryLightIonReaction::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4DiffractiveExcitation::CreateStrings(), G4QGSParticipants::DeterminePartonMomenta(), G4ElasticHNScattering::ElasticScattering(), G4QuarkExchange::ExciteParticipants(), G4SingleDiffractiveExcitation::ExciteParticipants(), G4QGSDiffractiveExcitation::ExciteParticipants(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4QGSMFragmentation::FragmentString(), G4ExcitedStringDecay::FragmentStrings(), G4MesonAbsorption::GetFinalState(), G4ParticleHPEnAngCorrelation::Sample(), and G4VPartonStringModel::Scatter().

◆ invert()

HepLorentzRotation & CLHEP::HepLorentzRotation::invert ( )
inline

◆ isIdentity()

bool CLHEP::HepLorentzRotation::isIdentity ( ) const
inline

◆ isNear() [1/3]

bool CLHEP::HepLorentzRotation::isNear ( const HepBoost &  b,
double  epsilon = Hep4RotationInterface::tolerance 
) const

Definition at line 129 of file LorentzRotationD.cc.

130 {
131 HepBoost b1;
132 HepRotation r1;
133 decompose( b1, r1 );
134 double db2 = b1.distance2(b);
135 if ( db2 > epsilon*epsilon ) {
136 return false; // Saves the time-consuming Rotation::norm2
137 }
138 double dr2 = r1.norm2();
139 return ( (db2 + dr2) <= epsilon*epsilon );
140}
epsilon
double epsilon(double density, double temperature)
Definition: G4DNAElectronHoleRecombination.cc:96

◆ isNear() [2/3]

bool CLHEP::HepLorentzRotation::isNear ( const HepLorentzRotation &  lt,
double  epsilon = Hep4RotationInterface::tolerance 
) const

Definition at line 155 of file LorentzRotationD.cc.

156 {
157 HepBoost b1;
158 HepRotation r1;
159 decompose( b1, r1 );
160 HepBoost b2;
161 HepRotation r2;
162 lt.decompose (b2, r2);
163 double db2 = b1.distance2(b2);
164 if ( db2 > epsilon*epsilon ) {
165 return false; // Saves the time-consuming Rotation::distance2
166 }
167 double dr2 = r1.distance2(r2);
168 return ( (db2 + dr2) <= epsilon*epsilon );
169}

◆ isNear() [3/3]

bool CLHEP::HepLorentzRotation::isNear ( const HepRotation &  r,
double  epsilon = Hep4RotationInterface::tolerance 
) const

Definition at line 142 of file LorentzRotationD.cc.

143 {
144 HepBoost b1;
145 HepRotation r1;
146 decompose( b1, r1 );
147 double db2 = b1.norm2();
148 if ( db2 > epsilon*epsilon ) {
149 return false; // Saves the time-consuming Rotation::distance2
150 }
151 double dr2 = r1.distance2(r);
152 return ( (db2 + dr2) <= epsilon*epsilon );
153}

◆ matrixMultiplication()

HepLorentzRotation CLHEP::HepLorentzRotation::matrixMultiplication ( const HepRep4x4 &  m) const

Definition at line 123 of file LorentzRotation.cc.

123 {
124 return HepLorentzRotation(
125 mxx*m1.xx_ + mxy*m1.yx_ + mxz*m1.zx_ + mxt*m1.tx_,
126 mxx*m1.xy_ + mxy*m1.yy_ + mxz*m1.zy_ + mxt*m1.ty_,
127 mxx*m1.xz_ + mxy*m1.yz_ + mxz*m1.zz_ + mxt*m1.tz_,
128 mxx*m1.xt_ + mxy*m1.yt_ + mxz*m1.zt_ + mxt*m1.tt_,
129
130 myx*m1.xx_ + myy*m1.yx_ + myz*m1.zx_ + myt*m1.tx_,
131 myx*m1.xy_ + myy*m1.yy_ + myz*m1.zy_ + myt*m1.ty_,
132 myx*m1.xz_ + myy*m1.yz_ + myz*m1.zz_ + myt*m1.tz_,
133 myx*m1.xt_ + myy*m1.yt_ + myz*m1.zt_ + myt*m1.tt_,
134
135 mzx*m1.xx_ + mzy*m1.yx_ + mzz*m1.zx_ + mzt*m1.tx_,
136 mzx*m1.xy_ + mzy*m1.yy_ + mzz*m1.zy_ + mzt*m1.ty_,
137 mzx*m1.xz_ + mzy*m1.yz_ + mzz*m1.zz_ + mzt*m1.tz_,
138 mzx*m1.xt_ + mzy*m1.yt_ + mzz*m1.zt_ + mzt*m1.tt_,
139
140 mtx*m1.xx_ + mty*m1.yx_ + mtz*m1.zx_ + mtt*m1.tx_,
141 mtx*m1.xy_ + mty*m1.yy_ + mtz*m1.zy_ + mtt*m1.ty_,
142 mtx*m1.xz_ + mty*m1.yz_ + mtz*m1.zz_ + mtt*m1.tz_,
143 mtx*m1.xt_ + mty*m1.yt_ + mtz*m1.zt_ + mtt*m1.tt_ );
144}

Referenced by set().

◆ norm2()

double CLHEP::HepLorentzRotation::norm2 ( ) const

Definition at line 171 of file LorentzRotationD.cc.

171 {
172 HepBoost b;
173 HepRotation r;
174 decompose( b, r );
175 return b.norm2() + r.norm2();
176}

◆ operator!=()

bool CLHEP::HepLorentzRotation::operator!= ( const HepLorentzRotation &  ) const
inline

◆ operator()() [1/2]

HepLorentzVector CLHEP::HepLorentzRotation::operator() ( const HepLorentzVector &  w) const
inline

◆ operator()() [2/2]

double CLHEP::HepLorentzRotation::operator() ( int  i,
int  j 
) const

Definition at line 63 of file LorentzRotation.cc.

63 {
64 if (i == 0) {
65 if (j == 0) { return xx(); }
66 if (j == 1) { return xy(); }
67 if (j == 2) { return xz(); }
68 if (j == 3) { return xt(); }
69 } else if (i == 1) {
70 if (j == 0) { return yx(); }
71 if (j == 1) { return yy(); }
72 if (j == 2) { return yz(); }
73 if (j == 3) { return yt(); }
74 } else if (i == 2) {
75 if (j == 0) { return zx(); }
76 if (j == 1) { return zy(); }
77 if (j == 2) { return zz(); }
78 if (j == 3) { return zt(); }
79 } else if (i == 3) {
80 if (j == 0) { return tx(); }
81 if (j == 1) { return ty(); }
82 if (j == 2) { return tz(); }
83 if (j == 3) { return tt(); }
84 }
85 std::cerr << "HepLorentzRotation subscripting: bad indices "
86 << "(" << i << "," << j << ")\n";
87 return 0.0;
88}

◆ operator*() [1/4]

HepLorentzRotation CLHEP::HepLorentzRotation::operator* ( const HepBoost &  b) const
inline

◆ operator*() [2/4]

HepLorentzRotation CLHEP::HepLorentzRotation::operator* ( const HepLorentzRotation &  lt) const
inline

◆ operator*() [3/4]

HepLorentzVector CLHEP::HepLorentzRotation::operator* ( const HepLorentzVector &  p) const
inline

◆ operator*() [4/4]

HepLorentzRotation CLHEP::HepLorentzRotation::operator* ( const HepRotation &  r) const
inline

◆ operator*=() [1/3]

HepLorentzRotation & CLHEP::HepLorentzRotation::operator*= ( const HepBoost &  b)
inline

◆ operator*=() [2/3]

HepLorentzRotation & CLHEP::HepLorentzRotation::operator*= ( const HepLorentzRotation &  lt)
inline

◆ operator*=() [3/3]

HepLorentzRotation & CLHEP::HepLorentzRotation::operator*= ( const HepRotation &  r)
inline

◆ operator<()

bool CLHEP::HepLorentzRotation::operator< ( const HepLorentzRotation &  ) const
inline

◆ operator<=()

bool CLHEP::HepLorentzRotation::operator<= ( const HepLorentzRotation &  ) const
inline

◆ operator=() [1/4]

HepLorentzRotation & CLHEP::HepLorentzRotation::operator= ( const HepBoost &  m)
inline

◆ operator=() [2/4]

HepLorentzRotation & CLHEP::HepLorentzRotation::operator= ( const HepLorentzRotation &  m)
inline

◆ operator=() [3/4]

HepLorentzRotation & CLHEP::HepLorentzRotation::operator= ( const HepRotation &  m)
inline

◆ operator=() [4/4]

HepLorentzRotation & CLHEP::HepLorentzRotation::operator= ( HepLorentzRotation &&  m)
inlinedefault

◆ operator==()

bool CLHEP::HepLorentzRotation::operator== ( const HepLorentzRotation &  ) const
inline

◆ operator>()

bool CLHEP::HepLorentzRotation::operator> ( const HepLorentzRotation &  ) const
inline

◆ operator>=()

bool CLHEP::HepLorentzRotation::operator>= ( const HepLorentzRotation &  ) const
inline

◆ operator[]()

const HepLorentzRotation_row CLHEP::HepLorentzRotation::operator[] ( int  ) const
inline

◆ print()

std::ostream & CLHEP::HepLorentzRotation::print ( std::ostream &  os) const

Definition at line 236 of file LorentzRotation.cc.

236 {
237 os << "\n [ ( " <<
238 std::setw(11) << std::setprecision(6) << xx() << " " <<
239 std::setw(11) << std::setprecision(6) << xy() << " " <<
240 std::setw(11) << std::setprecision(6) << xz() << " " <<
241 std::setw(11) << std::setprecision(6) << xt() << ")\n"
242 << " ( " <<
243 std::setw(11) << std::setprecision(6) << yx() << " " <<
244 std::setw(11) << std::setprecision(6) << yy() << " " <<
245 std::setw(11) << std::setprecision(6) << yz() << " " <<
246 std::setw(11) << std::setprecision(6) << yt() << ")\n"
247 << " ( " <<
248 std::setw(11) << std::setprecision(6) << zx() << " " <<
249 std::setw(11) << std::setprecision(6) << zy() << " " <<
250 std::setw(11) << std::setprecision(6) << zz() << " " <<
251 std::setw(11) << std::setprecision(6) << zt() << ")\n"
252 << " ( " <<
253 std::setw(11) << std::setprecision(6) << tx() << " " <<
254 std::setw(11) << std::setprecision(6) << ty() << " " <<
255 std::setw(11) << std::setprecision(6) << tz() << " " <<
256 std::setw(11) << std::setprecision(6) << tt() << ") ]\n";
257 return os;
258}

◆ rectify()

void CLHEP::HepLorentzRotation::rectify ( )

Definition at line 178 of file LorentzRotationD.cc.

178 {
179
180 // Assuming the representation of this is close to a true LT,
181 // but may have drifted due to round-off error from many operations,
182 // this forms an "exact" orthosymplectic matrix for the LT again.
183
184 // There are several ways to do this, all equivalent to lowest order in
185 // the corrected error. We choose to form an LT based on the inverse boost
186 // extracted from row 4, and left-multiply by LT to form what would be
187 // a rotation if the LT were kosher. We drop the possibly non-zero t
188 // components of that, rectify that rotation and multiply back by the boost.
189
190 Hep3Vector beta (tx(), ty(), tz());
191 double gam = tt(); // NaN-proofing
192 if ( gam <= 0 ) {
193 std::cerr << "HepLorentzRotation::rectify() - "
194 << "rectify() on a transformation with tt() <= 0 - will not help!"
195 << std::endl;
196 gam = 1;
197 }
198 beta *= 1.0/gam;
199 HepLorentzRotation R = (*this) * HepBoost(-beta);
200
201 HepRep3x3 m1 ( R.xx(), R.xy(), R.xz(),
202 R.yx(), R.yy(), R.yz(),
203 R.zx(), R.zy(), R.zz() );
204
205 HepRotation Rgood (m1);
206 Rgood.rectify();
207
208 set ( Rgood, HepBoost(beta) );
209}

◆ rep4x4()

HepRep4x4 CLHEP::HepLorentzRotation::rep4x4 ( ) const
inline

Referenced by CLHEP::HepBoost::operator*(), and CLHEP::operator*().

◆ rotate() [1/2]

HepLorentzRotation & CLHEP::HepLorentzRotation::rotate ( double  delta,
const Hep3Vector &  axis 
)
inline

◆ rotate() [2/2]

HepLorentzRotation & CLHEP::HepLorentzRotation::rotate ( double  delta,
const Hep3Vector *  axis 
)
inline

◆ rotateX()

HepLorentzRotation & CLHEP::HepLorentzRotation::rotateX ( double  delta)

Definition at line 146 of file LorentzRotation.cc.

146 {
147 double c1 = std::cos (delta);
148 double s1 = std::sin (delta);
149 HepLorentzVector rowy = row2();
150 HepLorentzVector rowz = row3();
151 HepLorentzVector r2 = c1 * rowy - s1 * rowz;
152 HepLorentzVector r3 = s1 * rowy + c1 * rowz;
153 myx = r2.x(); myy = r2.y(); myz = r2.z(); myt = r2.t();
154 mzx = r3.x(); mzy = r3.y(); mzz = r3.z(); mzt = r3.t();
155 return *this;
156}

◆ rotateY()

HepLorentzRotation & CLHEP::HepLorentzRotation::rotateY ( double  delta)

Definition at line 158 of file LorentzRotation.cc.

158 {
159 double c1 = std::cos (delta);
160 double s1 = std::sin (delta);
161 HepLorentzVector rowx = row1();
162 HepLorentzVector rowz = row3();
163 HepLorentzVector r1 = c1 * rowx + s1 * rowz;
164 HepLorentzVector r3 = -s1 * rowx + c1 * rowz;
165 mxx = r1.x(); mxy = r1.y(); mxz = r1.z(); mxt = r1.t();
166 mzx = r3.x(); mzy = r3.y(); mzz = r3.z(); mzt = r3.t();
167 return *this;
168}

Referenced by G4FTFAnnihilation::Annihilate(), G4BinaryLightIonReaction::ApplyYourself(), G4DiffractiveExcitation::CreateStrings(), G4QGSParticipants::DeterminePartonMomenta(), G4ElasticHNScattering::ElasticScattering(), G4QuarkExchange::ExciteParticipants(), G4SingleDiffractiveExcitation::ExciteParticipants(), G4QGSDiffractiveExcitation::ExciteParticipants(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4MesonAbsorption::GetFinalState(), G4ParticleHPEnAngCorrelation::Sample(), G4VPartonStringModel::Scatter(), G4FragmentingString::TransformToAlignedCms(), and G4ExcitedString::TransformToAlignedCms().

◆ rotateZ()

HepLorentzRotation & CLHEP::HepLorentzRotation::rotateZ ( double  delta)

Definition at line 170 of file LorentzRotation.cc.

170 {
171 double c1 = std::cos (delta);
172 double s1 = std::sin (delta);
173 HepLorentzVector rowx = row1();
174 HepLorentzVector rowy = row2();
175 HepLorentzVector r1 = c1 * rowx - s1 * rowy;
176 HepLorentzVector r2 = s1 * rowx + c1 * rowy;
177 mxx = r1.x(); mxy = r1.y(); mxz = r1.z(); mxt = r1.t();
178 myx = r2.x(); myy = r2.y(); myz = r2.z(); myt = r2.t();
179 return *this;
180}

Referenced by G4FTFAnnihilation::Annihilate(), G4BinaryLightIonReaction::ApplyYourself(), G4DiffractiveExcitation::CreateStrings(), G4QGSParticipants::DeterminePartonMomenta(), G4ElasticHNScattering::ElasticScattering(), G4QuarkExchange::ExciteParticipants(), G4SingleDiffractiveExcitation::ExciteParticipants(), G4QGSDiffractiveExcitation::ExciteParticipants(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4MesonAbsorption::GetFinalState(), G4ParticleHPEnAngCorrelation::Sample(), G4VPartonStringModel::Scatter(), G4FragmentingString::TransformToAlignedCms(), and G4ExcitedString::TransformToAlignedCms().

◆ row1()

HepLorentzVector CLHEP::HepLorentzRotation::row1 ( ) const
inline

Referenced by boostX(), rotateY(), and rotateZ().

◆ row2()

HepLorentzVector CLHEP::HepLorentzRotation::row2 ( ) const
inline

Referenced by boostY(), rotateX(), and rotateZ().

◆ row3()

HepLorentzVector CLHEP::HepLorentzRotation::row3 ( ) const
inline

Referenced by boostZ(), rotateX(), and rotateY().

◆ row4()

HepLorentzVector CLHEP::HepLorentzRotation::row4 ( ) const
inline

Referenced by boostX(), boostY(), and boostZ().

◆ set() [1/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const Hep3Vector &  p)
inline

◆ set() [2/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepBoost &  B,
const HepRotation &  R 
)

Definition at line 45 of file LorentzRotation.cc.

46 {
47 set (B.rep4x4());
48 *this = matrixMultiplication ( R.rep4x4() );
49 return *this;
50}
CLHEP::HepLorentzRotation::matrixMultiplication
HepLorentzRotation matrixMultiplication(const HepRep4x4 &m) const
Definition: LorentzRotation.cc:123

◆ set() [3/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepBoost &  boost)
inline

◆ set() [4/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepBoostX &  boost)
inline

◆ set() [5/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepBoostY &  boost)
inline

◆ set() [6/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepBoostZ &  boost)
inline

◆ set() [7/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepLorentzVector &  col1,
const HepLorentzVector &  col2,
const HepLorentzVector &  col3,
const HepLorentzVector &  col4 
)

Definition at line 20 of file LorentzRotationC.cc.

23 {
24 // First, test that the four cols do represent something close to a
25 // true LT:
26
27 ZMpvMetric_t savedMetric = HepLorentzVector::setMetric (TimePositive);
28
29 if ( ccol4.getT() < 0 ) {
30 std::cerr << "HepLorentzRotation::set() - "
31 << "column 4 supplied to define transformation has negative T component"
32 << std::endl;
33 *this = HepLorentzRotation();
34 return *this;
35 }
36/*
37 double u1u1 = ccol1.dot(ccol1);
38 double f11 = std::fabs(u1u1 + 1.0);
39 if ( f11 > Hep4RotationInterface::tolerance ) {
40 std::cerr << "HepLorentzRotation::set() - "
41 << "column 1 supplied for HepLorentzRotation has w*w != -1" << std::endl;
42 }
43 double u2u2 = ccol2.dot(ccol2);
44 double f22 = std::fabs(u2u2 + 1.0);
45 if ( f22 > Hep4RotationInterface::tolerance ) {
46 std::cerr << "HepLorentzRotation::set() - "
47 << "column 2 supplied for HepLorentzRotation has w*w != -1" << std::endl;
48 }
49 double u3u3 = ccol3.dot(ccol3);
50 double f33 = std::fabs(u3u3 + 1.0);
51 if ( f33 > Hep4RotationInterface::tolerance ) {
52 std::cerr << "HepLorentzRotation::set() - "
53 << "column 3 supplied for HepLorentzRotation has w*w != -1" << std::endl;
54 }
55 double u4u4 = ccol4.dot(ccol4);
56 double f44 = std::fabs(u4u4 - 1.0);
57 if ( f44 > Hep4RotationInterface::tolerance ) {
58 std::cerr << "HepLorentzRotation::set() - "
59 << "column 4 supplied for HepLorentzRotation has w*w != +1" << std::endl;
60 }
61
62 double u1u2 = ccol1.dot(ccol2);
63 double f12 = std::fabs(u1u2);
64 if ( f12 > Hep4RotationInterface::tolerance ) {
65 std::cerr << "HepLorentzRotation::set() - "
66 << "columns 1 and 2 supplied for HepLorentzRotation have non-zero dot" << std::endl;
67 }
68 double u1u3 = ccol1.dot(ccol3);
69 double f13 = std::fabs(u1u3);
70
71 if ( f13 > Hep4RotationInterface::tolerance ) {
72 std::cerr << "HepLorentzRotation::set() - "
73 << "columns 1 and 3 supplied for HepLorentzRotation have non-zero dot" << std::endl;
74 }
75 double u1u4 = ccol1.dot(ccol4);
76 double f14 = std::fabs(u1u4);
77 if ( f14 > Hep4RotationInterface::tolerance ) {
78 std::cerr << "HepLorentzRotation::set() - "
79 << "columns 1 and 4 supplied for HepLorentzRotation have non-zero dot" << std::endl;
80 }
81 double u2u3 = ccol2.dot(ccol3);
82 double f23 = std::fabs(u2u3);
83 if ( f23 > Hep4RotationInterface::tolerance ) {
84 std::cerr << "HepLorentzRotation::set() - "
85 << "columns 2 and 3 supplied for HepLorentzRotation have non-zero dot" << std::endl;
86 }
87 double u2u4 = ccol2.dot(ccol4);
88 double f24 = std::fabs(u2u4);
89 if ( f24 > Hep4RotationInterface::tolerance ) {
90 std::cerr << "HepLorentzRotation::set() - "
91 << "columns 2 and 4 supplied for HepLorentzRotation have non-zero dot" << std::endl;
92 }
93 double u3u4 = ccol3.dot(ccol4);
94 double f34 = std::fabs(u3u4);
95 if ( f34 > Hep4RotationInterface::tolerance ) {
96 std::cerr << "HepLorentzRotation::set() - "
97 << "columns 3 and 4 supplied for HepLorentzRotation have non-zero dot" << std::endl;
98 }
99*/
100 // Our strategy will be to order the cols, then do gram-schmidt on them
101 // (that is, remove the components of col d that make it non-orthogonal to
102 // col c, normalize that, then remove the components of b that make it
103 // non-orthogonal to d and to c, normalize that, etc.
104
105 // Because col4, the time col, is most likely to be computed directly, we
106 // will start from there and work left-ward.
107
108 HepLorentzVector a, b, c, d;
109 bool isLorentzTransformation = true;
110 double norm;
111
112 d = ccol4;
113 norm = d.dot(d);
114 if (norm <= 0.0) {
115 isLorentzTransformation = false;
116 if (norm == 0.0) {
117 d = T_HAT4; // Moot, but let's keep going...
118 norm = 1.0;
119 }
120 }
121 d /= norm;
122
123 c = ccol3 - ccol3.dot(d) * d;
124 norm = -c.dot(c);
125 if (norm <= 0.0) {
126 isLorentzTransformation = false;
127 if (norm == 0.0) {
128 c = Z_HAT4; // Moot
129 norm = 1.0;
130 }
131 }
132 c /= norm;
133
134 b = ccol2 + ccol2.dot(c) * c - ccol2.dot(d) * d;
135 norm = -b.dot(b);
136 if (norm <= 0.0) {
137 isLorentzTransformation = false;
138 if (norm == 0.0) {
139 b = Y_HAT4; // Moot
140 norm = 1.0;
141 }
142 }
143 b /= norm;
144
145 a = ccol1 + ccol1.dot(b) * b + ccol1.dot(c) * c - ccol1.dot(d) * d;
146 norm = -a.dot(a);
147 if (norm <= 0.0) {
148 isLorentzTransformation = false;
149 if (norm == 0.0) {
150 a = X_HAT4; // Moot
151 norm = 1.0;
152 }
153 }
154 a /= norm;
155
156 if ( !isLorentzTransformation ) {
157 std::cerr << "HepLorentzRotation::set() - "
158 << "cols 1-4 supplied to define transformation form either \n"
159 << " a boosted reflection or a tachyonic transformation -- \n"
160 << " transformation will be set to Identity " << std::endl;
161
162 *this = HepLorentzRotation();
163 }
164
165 if ( isLorentzTransformation ) {
166 mxx = a.x(); myx = a.y(); mzx = a.z(); mtx = a.t();
167 mxy = b.x(); myy = b.y(); mzy = b.z(); mty = b.t();
168 mxz = c.x(); myz = c.y(); mzz = c.z(); mtz = c.t();
169 mxt = d.x(); myt = d.y(); mzt = d.z(); mtt = d.t();
170 }
171
172 HepLorentzVector::setMetric (savedMetric);
173 return *this;
174
175} // set ( col1, col2, col3, col4 )
CLHEP::HepLorentzVector::setMetric
static ZMpvMetric_t setMetric(ZMpvMetric_t met)
Definition: LorentzVectorK.cc:22
CLHEP::TimePositive
@ TimePositive
Definition: LorentzVector.h:59

◆ set() [8/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepRep4x4 &  rep)
inline

◆ set() [9/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepRotation &  r)
inline

◆ set() [10/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepRotation &  R,
const HepBoost &  B 
)

Definition at line 52 of file LorentzRotation.cc.

53 {
54 set (R.rep4x4());
55 *this = matrixMultiplication ( B.rep4x4() );
56 return *this;
57}

◆ set() [11/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepRotationX &  r)
inline

◆ set() [12/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepRotationY &  r)
inline

◆ set() [13/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( const HepRotationZ &  r)
inline

◆ set() [14/14]

HepLorentzRotation & CLHEP::HepLorentzRotation::set ( double  bx,
double  by,
double  bz 
)

Definition at line 22 of file LorentzRotation.cc.

23 {
24 double bp2 = bx*bx + by*by + bz*bz;
25// if (bp2 >= 1) {
26// std::cerr << "HepLorentzRotation::set() - "
27// << "Boost Vector supplied to set HepLorentzRotation represents speed >= c."
28// << std::endl;
29// }
30 double gamma = 1.0 / std::sqrt(1.0 - bp2);
31 double bgamma = gamma * gamma / (1.0 + gamma);
32 mxx = 1.0 + bgamma * bx * bx;
33 myy = 1.0 + bgamma * by * by;
34 mzz = 1.0 + bgamma * bz * bz;
35 mxy = myx = bgamma * bx * by;
36 mxz = mzx = bgamma * bx * bz;
37 myz = mzy = bgamma * by * bz;
38 mxt = mtx = gamma * bx;
39 myt = mty = gamma * by;
40 mzt = mtz = gamma * bz;
41 mtt = gamma;
42 return *this;
43}

Referenced by HepLorentzRotation(), rectify(), set(), and setRows().

◆ setBoost()

void CLHEP::HepLorentzRotation::setBoost ( double  ,
double  ,
double   
)
inlineprotected

◆ setRows()

HepLorentzRotation & CLHEP::HepLorentzRotation::setRows ( const HepLorentzVector &  row1,
const HepLorentzVector &  row2,
const HepLorentzVector &  row3,
const HepLorentzVector &  row4 
)

Definition at line 177 of file LorentzRotationC.cc.

181 {
182 // Set based on using those rows as columns:
183 set (rrow1, rrow2, rrow3, rrow4);
184 // Now transpose in place:
185 double q1, q2, q3;
186 q1 = mxy; q2 = mxz; q3 = mxt;
187 mxy = myx; mxz = mzx; mxt = mtx;
188 myx = q1; mzx = q2; mtx = q3;
189 q1 = myz; q2 = myt; q3 = mzt;
190 myz = mzy; myt = mty; mzt = mtz;
191 mzy = q1; mty = q2; mtz = q3;
192 return *this;
193} // LorentzTransformation::setRows(row1 ... row4)

◆ setTolerance()

static double CLHEP::HepLorentzRotation::setTolerance ( double  tol)
inlinestatic

◆ transform() [1/3]

HepLorentzRotation & CLHEP::HepLorentzRotation::transform ( const HepBoost &  b)
inline

◆ transform() [2/3]

HepLorentzRotation & CLHEP::HepLorentzRotation::transform ( const HepLorentzRotation &  lt)
inline

◆ transform() [3/3]

HepLorentzRotation & CLHEP::HepLorentzRotation::transform ( const HepRotation &  r)
inline

◆ tt()

double CLHEP::HepLorentzRotation::tt ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ tx()

double CLHEP::HepLorentzRotation::tx ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ ty()

double CLHEP::HepLorentzRotation::ty ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ tz()

double CLHEP::HepLorentzRotation::tz ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ vectorMultiplication()

HepLorentzVector CLHEP::HepLorentzRotation::vectorMultiplication ( const HepLorentzVector &  ) const
inline

Referenced by CLHEP::HepLorentzVector::operator*=(), and CLHEP::HepLorentzVector::transform().

◆ xt()

double CLHEP::HepLorentzRotation::xt ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), and print().

◆ xx()

double CLHEP::HepLorentzRotation::xx ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ xy()

double CLHEP::HepLorentzRotation::xy ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ xz()

double CLHEP::HepLorentzRotation::xz ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ yt()

double CLHEP::HepLorentzRotation::yt ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), and print().

◆ yx()

double CLHEP::HepLorentzRotation::yx ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ yy()

double CLHEP::HepLorentzRotation::yy ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ yz()

double CLHEP::HepLorentzRotation::yz ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ zt()

double CLHEP::HepLorentzRotation::zt ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), and print().

◆ zx()

double CLHEP::HepLorentzRotation::zx ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ zy()

double CLHEP::HepLorentzRotation::zy ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

◆ zz()

double CLHEP::HepLorentzRotation::zz ( ) const
inline

Referenced by decompose(), operator()(), CLHEP::operator*(), print(), and rectify().

Friends And Related Function Documentation

◆ inverseOf

HepLorentzRotation inverseOf ( const HepLorentzRotation &  lt)
friend

Member Data Documentation

◆ IDENTITY

const HepLorentzRotation CLHEP::HepLorentzRotation::IDENTITY
static

Definition at line 53 of file LorentzRotation.h.

◆ mtt

double CLHEP::HepLorentzRotation::mtt
protected

Definition at line 339 of file LorentzRotation.h.

Referenced by boostX(), boostY(), boostZ(), compare(), matrixMultiplication(), and set().

◆ mtx

double CLHEP::HepLorentzRotation::mtx
protected

Definition at line 339 of file LorentzRotation.h.

Referenced by boostX(), boostY(), boostZ(), compare(), matrixMultiplication(), set(), and setRows().

◆ mty

double CLHEP::HepLorentzRotation::mty
protected

Definition at line 339 of file LorentzRotation.h.

Referenced by boostX(), boostY(), boostZ(), compare(), matrixMultiplication(), set(), and setRows().

◆ mtz

double CLHEP::HepLorentzRotation::mtz
protected

Definition at line 339 of file LorentzRotation.h.

Referenced by boostX(), boostY(), boostZ(), compare(), matrixMultiplication(), set(), and setRows().

◆ mxt

double CLHEP::HepLorentzRotation::mxt
protected

Definition at line 336 of file LorentzRotation.h.

Referenced by boostX(), compare(), matrixMultiplication(), rotateY(), rotateZ(), set(), and setRows().

◆ mxx

double CLHEP::HepLorentzRotation::mxx
protected

Definition at line 336 of file LorentzRotation.h.

Referenced by boostX(), compare(), matrixMultiplication(), rotateY(), rotateZ(), and set().

◆ mxy

double CLHEP::HepLorentzRotation::mxy
protected

Definition at line 336 of file LorentzRotation.h.

Referenced by boostX(), compare(), matrixMultiplication(), rotateY(), rotateZ(), set(), and setRows().

◆ mxz

double CLHEP::HepLorentzRotation::mxz
protected

Definition at line 336 of file LorentzRotation.h.

Referenced by boostX(), compare(), matrixMultiplication(), rotateY(), rotateZ(), set(), and setRows().

◆ myt

double CLHEP::HepLorentzRotation::myt
protected

Definition at line 337 of file LorentzRotation.h.

Referenced by boostY(), compare(), matrixMultiplication(), rotateX(), rotateZ(), set(), and setRows().

◆ myx

double CLHEP::HepLorentzRotation::myx
protected

Definition at line 337 of file LorentzRotation.h.

Referenced by boostY(), compare(), matrixMultiplication(), rotateX(), rotateZ(), set(), and setRows().

◆ myy

double CLHEP::HepLorentzRotation::myy
protected

Definition at line 337 of file LorentzRotation.h.

Referenced by boostY(), compare(), matrixMultiplication(), rotateX(), rotateZ(), and set().

◆ myz

double CLHEP::HepLorentzRotation::myz
protected

Definition at line 337 of file LorentzRotation.h.

Referenced by boostY(), compare(), matrixMultiplication(), rotateX(), rotateZ(), set(), and setRows().

◆ mzt

double CLHEP::HepLorentzRotation::mzt
protected

Definition at line 338 of file LorentzRotation.h.

Referenced by boostZ(), compare(), matrixMultiplication(), rotateX(), rotateY(), set(), and setRows().

◆ mzx

double CLHEP::HepLorentzRotation::mzx
protected

Definition at line 338 of file LorentzRotation.h.

Referenced by boostZ(), compare(), matrixMultiplication(), rotateX(), rotateY(), set(), and setRows().

◆ mzy

double CLHEP::HepLorentzRotation::mzy
protected

Definition at line 338 of file LorentzRotation.h.

Referenced by boostZ(), compare(), matrixMultiplication(), rotateX(), rotateY(), set(), and setRows().

◆ mzz

double CLHEP::HepLorentzRotation::mzz
protected

Definition at line 338 of file LorentzRotation.h.

Referenced by boostZ(), compare(), matrixMultiplication(), rotateX(), rotateY(), and set().

The documentation for this class was generated from the following files: