Geant4  10.01.p03
BoostZ.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 // ---------------------------------------------------------------------------
3 //
4 // This file is a part of the CLHEP - a Class Library for High Energy Physics.
5 //
6 // This is the implementation of the HepBoostZ class.
7 //
8 
9 #ifdef GNUPRAGMA
10 #pragma implementation
11 #endif
12 
13 #include "CLHEP/Vector/BoostZ.h"
14 #include "CLHEP/Vector/Boost.h"
15 #include "CLHEP/Vector/Rotation.h"
16 #include "CLHEP/Vector/LorentzRotation.h"
17 
18 namespace CLHEP {
19 
20 // ---------- Constructors and Assignment:
21 
22 HepBoostZ & HepBoostZ::set (double bbeta) {
23  double b2 = bbeta*bbeta;
24  if (b2 >= 1) {
25  std::cerr << "HepBoostZ::set() - "
26  << "Beta supplied to set HepBoostZ represents speed >= c." << std::endl;
27  beta_ = 1.0 - 1.0E-8; // NaN-proofing
28  gamma_ = 1.0 / std::sqrt(1.0 - b2);
29  return *this;
30  }
31  beta_ = bbeta;
32  gamma_ = 1.0 / std::sqrt(1.0 - b2);
33  return *this;
34 }
35 
36 // ---------- Accessors:
37 
38 HepRep4x4 HepBoostZ::rep4x4() const {
39  double bg = beta_*gamma_;
40  return HepRep4x4( 1, 0, 0, 0,
41  0, 1, 0, 0,
42  0, 0, gamma_, bg,
43  0, 0, bg, gamma_ );
44 }
45 
46 HepRep4x4Symmetric HepBoostZ::rep4x4Symmetric() const {
47  double bg = beta_*gamma_;
48  return HepRep4x4Symmetric( 1, 0, 0, 0,
49  1, 0, 0,
50  gamma_, bg,
51  gamma_ );
52 }
53 
54 // ---------- Decomposition:
55 
56 void HepBoostZ::decompose (HepRotation & rotation, HepBoost & boost) const {
57  HepAxisAngle vdelta = HepAxisAngle();
58  rotation = HepRotation(vdelta);
59  Hep3Vector bbeta = boostVector();
60  boost = HepBoost(bbeta);
61 }
62 
63 void HepBoostZ::decompose (HepAxisAngle & rotation, Hep3Vector & boost) const {
64  rotation = HepAxisAngle();
65  boost = boostVector();
66 }
67 
68 void HepBoostZ::decompose (HepBoost & boost, HepRotation & rotation) const {
69  HepAxisAngle vdelta = HepAxisAngle();
70  rotation = HepRotation(vdelta);
71  Hep3Vector bbeta = boostVector();
72  boost = HepBoost(bbeta);
73 }
74 
75 void HepBoostZ::decompose (Hep3Vector & boost, HepAxisAngle & rotation) const {
76  rotation = HepAxisAngle();
77  boost = boostVector();
78 }
79 
80 // ---------- Comparisons:
81 
82 double HepBoostZ::distance2( const HepBoost & b ) const {
83  return b.distance2(*this);
84 }
85 
86 double HepBoostZ::distance2( const HepRotation & r ) const {
87  double db2 = norm2();
88  double dr2 = r.norm2();
89  return (db2 + dr2);
90 }
91 
92 double HepBoostZ::distance2( const HepLorentzRotation & lt ) const {
93  HepBoost b1;
94  HepRotation r1;
95  lt.decompose(b1,r1);
96  double db2 = distance2(b1);
97  double dr2 = r1.norm2();
98  return (db2 + dr2);
99 }
100 
101 bool HepBoostZ::isNear (const HepRotation & r, double epsilon) const {
102  double db2 = norm2();
103  if (db2 > epsilon*epsilon) return false;
104  double dr2 = r.norm2();
105  return (db2+dr2 <= epsilon*epsilon);
106 }
107 
108 bool HepBoostZ::isNear ( const HepLorentzRotation & lt,
109  double epsilon ) const {
110  HepBoost b1;
111  HepRotation r1;
112  double db2 = distance2(b1);
113  lt.decompose(b1,r1);
114  if (db2 > epsilon*epsilon) return false;
115  double dr2 = r1.norm2();
116  return (db2 + dr2);
117 }
118 
119 // ---------- Properties:
120 
121 void HepBoostZ::rectify() {
122  // Assuming the representation of this is close to a true pure boost,
123  // but may have drifted due to round-off error from many operations,
124  // this forms an "exact" pure BoostZ matrix for again.
125 
126  double b2 = beta_*beta_;
127  if (b2 >= 1) {
128  beta_ = 1.0 - 1.0e-8; // NaN-proofing
129  b2 = beta_*beta_;
130  }
131  gamma_ = 1.0 / std::sqrt(1.0 - b2);
132 }
133 
134 // ---------- Application:
135 
136 // ---------- Operations in the group of 4-Rotations
137 
138 HepBoostZ HepBoostZ::operator * (const HepBoostZ & b) const {
139  return HepBoostZ ( (beta()+b.beta()) / (1+beta()*b.beta()) );
140 }
141 HepLorentzRotation HepBoostZ::operator * (const HepBoost & b) const {
142  HepLorentzRotation me (*this);
143  return me*b;
144 }
145 HepLorentzRotation HepBoostZ::operator * (const HepRotation & r) const {
146  HepLorentzRotation me (*this);
147  return me*r;
148 }
149 HepLorentzRotation HepBoostZ::operator * (const HepLorentzRotation & lt) const {
150  HepLorentzRotation me (*this);
151  return me*lt;
152 }
153 
154 // ---------- I/O
155 
156 std::ostream & HepBoostZ::print( std::ostream & os ) const {
157  os << "Boost in Z direction (beta = " << beta_
158  << ", gamma = " << gamma_ << ") ";
159  return os;
160 }
161 
162 } // namespace CLHEP
G4ErrorMatrix operator*(const G4ErrorMatrix &m1, const G4ErrorMatrix &m2)
static const G4double b2
static const G4double b1
void print(const std::vector< T > &data)
Definition: DicomRun.hh:109