Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/externals/clhep/include/CLHEP/Vector/BoostX.h

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 ]

Diff markup

Differences between /externals/clhep/include/CLHEP/Vector/BoostX.h (Version 11.3.0) and /externals/clhep/include/CLHEP/Vector/BoostX.h (Version 9.1)


  1 // -*- C++ -*-                                      1 
  2 //                                                
  3 // This file is a part of the CLHEP - a Class     
  4 //                                                
  5 // This is the definition of the HepBoostX cla    
  6 // Lorentz transformations which are pure boos    
  7 // objects of the HepLorentzVector class.         
  8 //                                                
  9 // HepLorentzRotation is a concrete implementa    
 10 //                                                
 11 // .SS See Also                                   
 12 // RotationInterfaces.h                           
 13 // LorentzVector.h LorentzRotation.h              
 14 // Boost.h                                        
 15 //                                                
 16 // .SS Author                                     
 17 // Mark Fischler                                  
 18                                                   
 19 #ifndef HEP_BOOSTX_H                              
 20 #define HEP_BOOSTX_H                              
 21                                                   
 22 #include "CLHEP/Vector/RotationInterfaces.h"      
 23 #include "CLHEP/Vector/LorentzVector.h"           
 24                                                   
 25 namespace CLHEP  {                                
 26                                                   
 27 // Declarations of classes and global methods     
 28 class HepBoostX;                                  
 29 inline HepBoostX inverseOf ( const HepBoostX &    
 30 class HepBoost;                                   
 31 class HepRotation;                                
 32                                                   
 33 /**                                               
 34  * @author                                        
 35  * @ingroup vector                                
 36  */                                               
 37 class HepBoostX {                                 
 38                                                   
 39 public:                                           
 40                                                   
 41   // ----------  Constructors and Assignment:     
 42                                                   
 43   inline HepBoostX();                             
 44   // Default constructor. Gives a boost of 0.     
 45                                                   
 46   inline HepBoostX(const HepBoostX & b);          
 47   inline HepBoostX(HepBoostX && b) = default;     
 48   // Copy and move constructors.                  
 49                                                   
 50   inline HepBoostX & operator = (const HepBoos    
 51   inline HepBoostX & operator = (HepBoostX &&     
 52   // Copy and move assignment operators.          
 53                                                   
 54          HepBoostX & set (double beta);           
 55   inline HepBoostX       (double beta);           
 56   // Constructor from beta                        
 57                                                   
 58   // ----------  Accessors:                       
 59                                                   
 60   inline double  beta()  const;                   
 61   inline double  gamma() const;                   
 62   inline Hep3Vector boostVector() const;          
 63   inline Hep3Vector getDirection() const;         
 64                                                   
 65   inline double xx() const;                       
 66   inline double xy() const;                       
 67   inline double xz() const;                       
 68   inline double xt() const;                       
 69   inline double yx() const;                       
 70   inline double yy() const;                       
 71   inline double yz() const;                       
 72   inline double yt() const;                       
 73   inline double zx() const;                       
 74   inline double zy() const;                       
 75   inline double zz() const;                       
 76   inline double zt() const;                       
 77   inline double tx() const;                       
 78   inline double ty() const;                       
 79   inline double tz() const;                       
 80   inline double tt() const;                       
 81   // Elements of the matrix.                      
 82                                                   
 83   inline HepLorentzVector col1() const;           
 84   inline HepLorentzVector col2() const;           
 85   inline HepLorentzVector col3() const;           
 86   inline HepLorentzVector col4() const;           
 87   // orthosymplectic column vectors               
 88                                                   
 89   inline HepLorentzVector row1() const;           
 90   inline HepLorentzVector row2() const;           
 91   inline HepLorentzVector row3() const;           
 92   inline HepLorentzVector row4() const;           
 93   // orthosymplectic row vectors                  
 94                                                   
 95   HepRep4x4 rep4x4() const;                       
 96   //   4x4 representation:                        
 97                                                   
 98   HepRep4x4Symmetric rep4x4Symmetric() const;     
 99   //   Symmetric 4x4 representation.              
100                                                   
101   // ----------  Decomposition:                   
102                                                   
103   void decompose (HepRotation  & rotation, Hep    
104   void decompose (HepAxisAngle & rotation, Hep    
105   // Find R and B such that L = R*B -- trivial    
106                                                   
107   void decompose ( HepBoost  & boost, HepRotat    
108   void decompose (Hep3Vector & boost, HepAxisA    
109   // Find R and B such that L = B*R -- trivial    
110                                                   
111   // ----------  Comparisons:                     
112                                                   
113   inline int compare( const HepBoostX & b  ) c    
114   // Dictionary-order comparison, in order of     
115   // Used in operator<, >, <=, >=                 
116                                                   
117   inline bool operator == (const HepBoostX & b    
118   inline bool operator != (const HepBoostX & b    
119   inline bool operator <= (const HepBoostX & b    
120   inline bool operator >= (const HepBoostX & b    
121   inline bool operator <  (const HepBoostX & b    
122   inline bool operator >  (const HepBoostX & b    
123   // Comparisons.                                 
124                                                   
125   inline bool isIdentity() const;                 
126   // Returns true if a null boost.                
127                                                   
128   inline double distance2( const HepBoostX & b    
129          double distance2( const HepBoost & b     
130   // Defined as the distance2 between the vect    
131                                                   
132   double distance2( const HepRotation & r  ) c    
133   double distance2( const HepLorentzRotation &    
134   // Decompose lt = B*R; add norm2 to distance    
135                                                   
136   inline double howNear(   const HepBoostX & b    
137   inline double howNear(   const HepBoost  & b    
138   inline double howNear(   const HepRotation &    
139   inline double howNear(   const HepLorentzRot    
140                                                   
141   inline bool isNear(   const HepBoostX & b,      
142              double epsilon=Hep4RotationInterf    
143   inline bool isNear(   const HepBoost & b,       
144              double epsilon=Hep4RotationInterf    
145   bool isNear(   const HepRotation & r,           
146              double epsilon=Hep4RotationInterf    
147   bool isNear(   const HepLorentzRotation & lt    
148              double epsilon=Hep4RotationInterf    
149                                                   
150   // ----------  Properties:                      
151                                                   
152   inline double norm2() const;                    
153   // distance2 (IDENTITY), which is beta^2 * g    
154                                                   
155   void rectify();                                 
156   // sets according to the stored beta            
157                                                   
158   // ---------- Application:                      
159                                                   
160   inline HepLorentzVector operator()( const He    
161   // Transform a Lorentz Vector.                  
162                                                   
163   inline HepLorentzVector operator* ( const He    
164   // Multiplication with a Lorentz Vector.        
165                                                   
166   // ---------- Operations in the group of 4-R    
167                                                   
168   HepBoostX   operator * (const HepBoostX & b)    
169   HepLorentzRotation operator * (const HepBoos    
170   HepLorentzRotation operator * (const HepRota    
171   HepLorentzRotation operator * (const HepLore    
172   // Product of two Lorentz Rotations (this) *    
173   // Notice that the product of two pure boost    
174   // is no longer a pure boost.                   
175                                                   
176   inline HepBoostX inverse() const;               
177   // Return the inverse.                          
178                                                   
179   inline friend HepBoostX inverseOf ( const He    
180   // global methods to invert.                    
181                                                   
182   inline HepBoostX & invert();                    
183   // Inverts the Boost matrix.                    
184                                                   
185   // ---------- I/O:                              
186                                                   
187   std::ostream & print( std::ostream & os ) co    
188   // Output form is BOOSTX (beta=..., gamma=..    
189                                                   
190   // ---------- Tolerance                         
191                                                   
192   static inline double getTolerance();            
193   static inline double setTolerance(double tol    
194                                                   
195 protected:                                        
196                                                   
197   inline HepLorentzVector vectorMultiplication    
198                                         ( cons    
199   // Multiplication with a Lorentz Vector.        
200                                                   
201   HepLorentzRotation matrixMultiplication (con    
202   HepLorentzRotation matrixMultiplication (con    
203                                                   
204   inline HepBoostX (double beta, double gamma)    
205                                                   
206   double  beta_;                                  
207   double  gamma_;                                 
208                                                   
209 };  // HepBoostX                                  
210                                                   
211 inline                                            
212 std::ostream & operator <<                        
213   ( std::ostream & os, const HepBoostX& b ) {r    
214                                                   
215 }  // namespace CLHEP                             
216                                                   
217 #include "CLHEP/Vector/BoostX.icc"                
218                                                   
219 #endif /* HEP_BOOSTX_H */                         
220