Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/externals/clhep/src/RotationZ.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

  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 methods of the HepRotationZ class which
  7 // were introduced when ZOOM PhysicsVectors was merged in.
  8 //
  9 
 10 #include "CLHEP/Vector/RotationZ.h"
 11 #include "CLHEP/Vector/AxisAngle.h"
 12 #include "CLHEP/Vector/EulerAngles.h"
 13 #include "CLHEP/Vector/LorentzRotation.h"
 14 #include "CLHEP/Units/PhysicalConstants.h"
 15 
 16 #include <cmath>
 17 #include <stdlib.h>
 18 #include <iostream>
 19 
 20 namespace CLHEP  {
 21 
 22 static inline double safe_acos (double x) {
 23   if (std::abs(x) <= 1.0) return std::acos(x);
 24   return ( (x>0) ? 0 : CLHEP::pi );
 25 }
 26 
 27 HepRotationZ::HepRotationZ(double ddelta) : 
 28     its_d(proper(ddelta)), its_s(std::sin(ddelta)), its_c(std::cos(ddelta))
 29 {}
 30 
 31 HepRotationZ & HepRotationZ::set ( double ddelta ) {
 32   its_d = proper(ddelta);
 33   its_s = std::sin(its_d);
 34   its_c = std::cos(its_d);
 35   return *this;
 36 }
 37 
 38 double  HepRotationZ::phi() const {
 39   return  - its_d/2.0;
 40 }  // HepRotationZ::phi()
 41 
 42 double  HepRotationZ::theta() const {
 43   return  0.0 ;
 44 }  // HepRotationZ::theta()
 45 
 46 double  HepRotationZ::psi() const {
 47   return  - its_d/2.0;
 48 }  // HepRotationZ::psi()
 49 
 50 HepEulerAngles HepRotationZ::eulerAngles() const {
 51   return HepEulerAngles(  phi(),  theta(),  psi() );
 52 }  // HepRotationZ::eulerAngles()
 53 
 54 
 55 // From the defining code in the implementation of CLHEP (in Rotation.cc)
 56 // it is clear that thetaX, phiX form the polar angles in the original
 57 // coordinate system of the new X axis (and similarly for phiY and phiZ).
 58 //
 59 // This code is take directly from CLHEP original.  However, there are as
 60 // shown opportunities for significant speed improvement.
 61 
 62 double HepRotationZ::phiX() const {
 63   return (yx() == 0.0 && xx() == 0.0) ? 0.0 : std::atan2(yx(),xx());
 64       // or ---- return d;
 65 }
 66 
 67 double HepRotationZ::phiY() const {
 68   return (yy() == 0.0 && xy() == 0.0) ? 0.0 : std::atan2(yy(),xy());
 69 }
 70 
 71 double HepRotationZ::phiZ() const {
 72   return (yz() == 0.0 && xz() == 0.0) ? 0.0 : std::atan2(yz(),xz());
 73     // or ---- return 0.0;
 74 }
 75 
 76 double HepRotationZ::thetaX() const {
 77   return safe_acos(zx());
 78     // or ----  return CLHEP::halfpi;
 79 }
 80 
 81 double HepRotationZ::thetaY() const {
 82   return safe_acos(zy());
 83     // or ----  return CLHEP::halfpi;
 84 }
 85 
 86 double HepRotationZ::thetaZ() const {
 87   return safe_acos(zz());  
 88     // or ---- return 0.0;
 89 }
 90 
 91 void HepRotationZ::setDelta ( double ddelta ) {
 92   set(ddelta);
 93 }
 94 
 95 void HepRotationZ::decompose
 96   (HepAxisAngle & rotation, Hep3Vector & boost) const {
 97   boost.set(0,0,0);
 98   rotation = axisAngle();
 99 }
100 
101 void HepRotationZ::decompose
102   (Hep3Vector & boost, HepAxisAngle & rotation) const {
103   boost.set(0,0,0);
104   rotation = axisAngle();
105 }
106  
107 void HepRotationZ::decompose
108         (HepRotation & rotation, HepBoost & boost) const {
109   boost.set(0,0,0);
110   rotation = HepRotation(*this);
111 }
112                                                                                 
113 void HepRotationZ::decompose
114         (HepBoost & boost, HepRotation & rotation) const {
115   boost.set(0,0,0);
116   rotation = HepRotation(*this);
117 }
118 
119 double HepRotationZ::distance2( const HepRotationZ & r  ) const {
120   double answer = 2.0 * ( 1.0 - ( its_s * r.its_s + its_c * r.its_c ) ) ;
121   return (answer >= 0) ? answer : 0;
122 }
123 
124 double HepRotationZ::distance2( const HepRotation & r  ) const {
125   double sum =    xx() * r.xx() + xy() * r.xy()
126                    + yx() * r.yx() + yy() * r.yy()
127                + r.zz();
128   double answer = 3.0 - sum;
129   return (answer >= 0 ) ? answer : 0;
130 }
131 
132 double HepRotationZ::distance2( const HepLorentzRotation & lt  ) const {
133   HepAxisAngle a; 
134   Hep3Vector   b;
135   lt.decompose(b, a);
136   double bet = b.beta();
137   double bet2 = bet*bet;
138   HepRotation r(a);
139   return bet2/(1-bet2) + distance2(r);
140 }
141 
142 double HepRotationZ::distance2( const HepBoost & lt ) const {
143   return distance2( HepLorentzRotation(lt));
144 }
145 
146 double HepRotationZ::howNear( const HepRotationZ & r ) const {
147   return std::sqrt(distance2(r));
148 }
149 double HepRotationZ::howNear( const HepRotation & r ) const {
150   return std::sqrt(distance2(r));
151 }
152 double HepRotationZ::howNear( const HepBoost & lt ) const {
153   return std::sqrt(distance2(lt));
154 }
155 double HepRotationZ::howNear( const HepLorentzRotation & lt ) const {
156   return std::sqrt(distance2(lt));
157 }
158 bool HepRotationZ::isNear(const HepRotationZ & r,double epsilon)const {
159   return (distance2(r) <= epsilon*epsilon);
160 }
161 bool HepRotationZ::isNear(const HepRotation & r,double epsilon)const {
162   return (distance2(r) <= epsilon*epsilon);
163 }
164 bool HepRotationZ::isNear( const HepBoost & lt,double epsilon) const {
165   return (distance2(lt) <= epsilon*epsilon);
166 }
167 bool HepRotationZ::isNear( const HepLorentzRotation & lt,
168                                      double epsilon) const {
169   return (distance2(lt) <= epsilon*epsilon);
170 }
171 
172 double HepRotationZ::norm2() const {
173   return 2.0 - 2.0 * its_c;
174 }
175 
176 std::ostream & HepRotationZ::print( std::ostream & os ) const {
177   os << "\nRotation about Z (" << its_d <<
178                 ") [cos d = " << its_c << " sin d = " << its_s << "]\n";
179   return os;
180 }
181 
182 }  // namespace CLHEP
183 
184