Geant4 9.6.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 (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= (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 53 of file LorentzRotation.h.

Constructor & Destructor Documentation

◆ HepLorentzRotation() [1/17]

CLHEP::HepLorentzRotation::HepLorentzRotation ( )
inline

Referenced by matrixMultiplication(), and set().

◆ HepLorentzRotation() [2/17]

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

◆ HepLorentzRotation() [3/17]

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

◆ HepLorentzRotation() [4/17]

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

◆ HepLorentzRotation() [5/17]

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

◆ HepLorentzRotation() [6/17]

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

◆ HepLorentzRotation() [7/17]

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

◆ HepLorentzRotation() [8/17]

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

◆ HepLorentzRotation() [9/17]

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

◆ HepLorentzRotation() [10/17]

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

◆ HepLorentzRotation() [11/17]

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

◆ HepLorentzRotation() [12/17]

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

◆ HepLorentzRotation() [13/17]

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

◆ HepLorentzRotation() [14/17]

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

◆ HepLorentzRotation() [15/17]

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

Definition at line 198 of file LorentzRotationC.cc.

202{
203 set ( ccol1, ccol2, ccol3, ccol4 );
204}
CLHEP::HepLorentzRotation::set
HepLorentzRotation & set(double bx, double by, double bz)
Definition: LorentzRotation.cc:27

◆ HepLorentzRotation() [16/17]

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

◆ HepLorentzRotation() [17/17]

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 186 of file LorentzRotation.cc.

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

◆ boostY()

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

Definition at line 204 of file LorentzRotation.cc.

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

◆ boostZ()

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

Definition at line 222 of file LorentzRotation.cc.

222 {
223 double b2 = beta*beta;
224// if (b2 >= 1) {
225// std::cerr << "HepLorentzRotation::boostZ() - "
226// << "Beta supplied to HepLorentzRotation::boostZ represents speed >= c."
227// << std::endl;
228// }
229 double g1 = 1.0/std::sqrt(1.0-b2);
230 double bg = beta*g1;
231 HepLorentzVector rowz = row3();
232 HepLorentzVector rowt = row4();
233 HepLorentzVector r3 = g1 * rowz + bg * rowt;
234 HepLorentzVector r4 = bg * rowz + g1 * rowt;
235 mtx = r4.x(); mty = r4.y(); mtz = r4.z(); mtt = r4.t();
236 mzx = r3.x(); mzy = r3.y(); mzz = r3.z(); mzt = r3.t();
237 return *this;
238}
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 99 of file LorentzRotation.cc.

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

◆ decompose() [1/4]

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

Definition at line 46 of file LorentzRotationD.cc.

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

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 79 of file LorentzRotationD.cc.

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

◆ decompose() [3/4]

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

Definition at line 19 of file LorentzRotationD.cc.

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

◆ decompose() [4/4]

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

Definition at line 56 of file LorentzRotationD.cc.

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

◆ distance2() [1/3]

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

Definition at line 89 of file LorentzRotationD.cc.

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

Referenced by howNear().

◆ distance2() [2/3]

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

Definition at line 107 of file LorentzRotationD.cc.

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

◆ distance2() [3/3]

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

Definition at line 98 of file LorentzRotationD.cc.

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

◆ getTolerance()

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

◆ howNear() [1/3]

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

Definition at line 120 of file LorentzRotationD.cc.

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

◆ howNear() [2/3]

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

Definition at line 126 of file LorentzRotationD.cc.

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

◆ howNear() [3/3]

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

Definition at line 123 of file LorentzRotationD.cc.

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

◆ inverse()

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

Referenced by G4FTFAnnihilation::Annihilate(), G4BinaryLightIonReaction::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4DiffractiveExcitation::CreateStrings(), G4ElasticHNScattering::ElasticScattering(), G4QFragmentation::ExciteDiffParticipants(), G4QIonIonCollision::ExciteDiffParticipants(), G4QGSDiffractiveExcitation::ExciteParticipants(), G4SingleDiffractiveExcitation::ExciteParticipants(), G4DiffractiveExcitation::ExciteParticipants(), G4QFragmentation::ExciteSingDiffParticipants(), G4QIonIonCollision::ExciteSingDiffParticipants(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4LundStringFragmentation::FragmentString(), G4QGSMFragmentation::FragmentString(), G4QString::FragmentString(), G4HadProjectile::G4HadProjectile(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), G4MesonAbsorption::GetFinalState(), G4HadProjectile::Initialise(), G4StringChipsInterface::Propagate(), G4NeutronHPEnAngCorrelation::Sample(), and G4VPartonStringModel::Scatter().

◆ invert()

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

Referenced by G4CascadeInterface::createBullet().

◆ 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 130 of file LorentzRotationD.cc.

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

◆ isNear() [2/3]

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

Definition at line 156 of file LorentzRotationD.cc.

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

◆ isNear() [3/3]

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

Definition at line 143 of file LorentzRotationD.cc.

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

◆ matrixMultiplication()

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

Definition at line 127 of file LorentzRotation.cc.

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

Referenced by set().

◆ norm2()

double CLHEP::HepLorentzRotation::norm2 ( ) const

Definition at line 172 of file LorentzRotationD.cc.

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

◆ 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 67 of file LorentzRotation.cc.

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

◆ 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/3]

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

◆ operator=() [2/3]

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

◆ operator=() [3/3]

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

◆ 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 240 of file LorentzRotation.cc.

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

◆ rectify()

void CLHEP::HepLorentzRotation::rectify ( )

Definition at line 179 of file LorentzRotationD.cc.

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

◆ 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 150 of file LorentzRotation.cc.

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

◆ rotateY()

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

Definition at line 162 of file LorentzRotation.cc.

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

Referenced by G4FTFAnnihilation::Annihilate(), G4BinaryLightIonReaction::ApplyYourself(), G4CascadeInterface::createBullet(), G4DiffractiveExcitation::CreateStrings(), G4ElasticHNScattering::ElasticScattering(), G4QFragmentation::ExciteDiffParticipants(), G4QIonIonCollision::ExciteDiffParticipants(), G4QGSDiffractiveExcitation::ExciteParticipants(), G4SingleDiffractiveExcitation::ExciteParticipants(), G4DiffractiveExcitation::ExciteParticipants(), G4QFragmentation::ExciteSingDiffParticipants(), G4QIonIonCollision::ExciteSingDiffParticipants(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4QString::FragmentString(), G4HadProjectile::G4HadProjectile(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), G4MesonAbsorption::GetFinalState(), G4HadProjectile::Initialise(), G4StringChipsInterface::Propagate(), G4NeutronHPEnAngCorrelation::Sample(), G4VPartonStringModel::Scatter(), and G4ExcitedString::TransformToAlignedCms().

◆ rotateZ()

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

Definition at line 174 of file LorentzRotation.cc.

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

Referenced by G4FTFAnnihilation::Annihilate(), G4BinaryLightIonReaction::ApplyYourself(), G4CascadeInterface::createBullet(), G4DiffractiveExcitation::CreateStrings(), G4ElasticHNScattering::ElasticScattering(), G4QFragmentation::ExciteDiffParticipants(), G4QIonIonCollision::ExciteDiffParticipants(), G4QGSDiffractiveExcitation::ExciteParticipants(), G4SingleDiffractiveExcitation::ExciteParticipants(), G4DiffractiveExcitation::ExciteParticipants(), G4QFragmentation::ExciteSingDiffParticipants(), G4QIonIonCollision::ExciteSingDiffParticipants(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4QString::FragmentString(), G4HadProjectile::G4HadProjectile(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), G4MesonAbsorption::GetFinalState(), G4HadProjectile::Initialise(), G4StringChipsInterface::Propagate(), G4NeutronHPEnAngCorrelation::Sample(), G4VPartonStringModel::Scatter(), 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 49 of file LorentzRotation.cc.

50 {
51 set (B.rep4x4());
52 *this = matrixMultiplication ( R.rep4x4() );
53 return *this;
54}
CLHEP::HepLorentzRotation::matrixMultiplication
HepLorentzRotation matrixMultiplication(const HepRep4x4 &m) const
Definition: LorentzRotation.cc:127

◆ 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 23 of file LorentzRotationC.cc.

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

◆ 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 56 of file LorentzRotation.cc.

57 {
58 set (R.rep4x4());
59 *this = matrixMultiplication ( B.rep4x4() );
60 return *this;
61}

◆ 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 26 of file LorentzRotation.cc.

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

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 180 of file LorentzRotationC.cc.

184 {
185 // Set based on using those rows as columns:
186 set (rrow1, rrow2, rrow3, rrow4);
187 // Now transpose in place:
188 register double q1, q2, q3;
189 q1 = mxy; q2 = mxz; q3 = mxt;
190 mxy = myx; mxz = mzx; mxt = mtx;
191 myx = q1; mzx = q2; mtx = q3;
192 q1 = myz; q2 = myt; q3 = mzt;
193 myz = mzy; myt = mty; mzt = mtz;
194 mzy = q1; mty = q2; mtz = q3;
195 return *this;
196} // 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 58 of file LorentzRotation.h.

Referenced by G4CascadeInterface::createBullet().

◆ mtt

double CLHEP::HepLorentzRotation::mtt
protected

Definition at line 342 of file LorentzRotation.h.

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

◆ mtx

double CLHEP::HepLorentzRotation::mtx
protected

Definition at line 342 of file LorentzRotation.h.

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

◆ mty

double CLHEP::HepLorentzRotation::mty
protected

Definition at line 342 of file LorentzRotation.h.

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

◆ mtz

double CLHEP::HepLorentzRotation::mtz
protected

Definition at line 342 of file LorentzRotation.h.

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

◆ mxt

double CLHEP::HepLorentzRotation::mxt
protected

Definition at line 339 of file LorentzRotation.h.

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

◆ mxx

double CLHEP::HepLorentzRotation::mxx
protected

Definition at line 339 of file LorentzRotation.h.

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

◆ mxy

double CLHEP::HepLorentzRotation::mxy
protected

Definition at line 339 of file LorentzRotation.h.

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

◆ mxz

double CLHEP::HepLorentzRotation::mxz
protected

Definition at line 339 of file LorentzRotation.h.

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

◆ myt

double CLHEP::HepLorentzRotation::myt
protected

Definition at line 340 of file LorentzRotation.h.

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

◆ myx

double CLHEP::HepLorentzRotation::myx
protected

Definition at line 340 of file LorentzRotation.h.

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

◆ myy

double CLHEP::HepLorentzRotation::myy
protected

Definition at line 340 of file LorentzRotation.h.

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

◆ myz

double CLHEP::HepLorentzRotation::myz
protected

Definition at line 340 of file LorentzRotation.h.

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

◆ mzt

double CLHEP::HepLorentzRotation::mzt
protected

Definition at line 341 of file LorentzRotation.h.

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

◆ mzx

double CLHEP::HepLorentzRotation::mzx
protected

Definition at line 341 of file LorentzRotation.h.

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

◆ mzy

double CLHEP::HepLorentzRotation::mzy
protected

Definition at line 341 of file LorentzRotation.h.

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

◆ mzz

double CLHEP::HepLorentzRotation::mzz
protected

Definition at line 341 of file LorentzRotation.h.

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

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