Geant4  10.00.p03
BoostY.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 HepBoostY class.
7 //
8 
9 #ifdef GNUPRAGMA
10 #pragma implementation
11 #endif
12 
13 #include "CLHEP/Vector/BoostY.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 HepBoostY & HepBoostY::set (double bbeta) {
23  double b2 = bbeta*bbeta;
24  if (b2 >= 1) {
25  std::cerr << "HepBoostY::set() - "
26  << "Beta supplied to set HepBoostY 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 HepBoostY::rep4x4() const {
39  double bg = beta_*gamma_;
40  return HepRep4x4( 1, 0, 0, 0,
41  0, gamma_, 0, bg,
42  0, 0, 1, 0,
43  0, bg, 0, gamma_ );
44 }
45 
46 HepRep4x4Symmetric HepBoostY::rep4x4Symmetric() const {
47  double bg = beta_*gamma_;
48  return HepRep4x4Symmetric ( 1, 0, 0, 0,
49  gamma_, 0, bg,
50  1, 0,
51  gamma_ );
52 }
53 
54 // ---------- Decomposition:
55 
56 void HepBoostY::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 HepBoostY::decompose (HepAxisAngle & rotation, Hep3Vector & boost) const {
64  rotation = HepAxisAngle();
65  boost = boostVector();
66 }
67 
68 void HepBoostY::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 HepBoostY::decompose (Hep3Vector & boost, HepAxisAngle & rotation) const {
76  rotation = HepAxisAngle();
77  boost = boostVector();
78 }
79 
80 // ---------- Comparisons:
81 
82 double HepBoostY::distance2( const HepBoost & b ) const {
83  return b.distance2(*this);
84 }
85 
86 double HepBoostY::distance2( const HepRotation & r ) const {
87  double db2 = norm2();
88  double dr2 = r.norm2();
89  return (db2 + dr2);
90 }
91 
92 double HepBoostY::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 HepBoostY::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 HepBoostY::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 HepBoostY::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 BoostY 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 HepBoostY HepBoostY::operator * (const HepBoostY & b) const {
139  return HepBoostY ( (beta()+b.beta()) / (1+beta()*b.beta()) );
140 }
141 HepLorentzRotation HepBoostY::operator * (const HepBoost & b) const {
142  HepLorentzRotation me (*this);
143  return me*b;
144 }
145 HepLorentzRotation HepBoostY::operator * (const HepRotation & r) const {
146  HepLorentzRotation me (*this);
147  return me*r;
148 }
149 HepLorentzRotation HepBoostY::operator * (const HepLorentzRotation & lt) const {
150  HepLorentzRotation me (*this);
151  return me*lt;
152 }
153 
154 // ---------- I/O
155 
156 std::ostream & HepBoostY::print( std::ostream & os ) const {
157  os << "Boost in Y 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:111