RotationInterfaces.h

Go to the documentation of this file.

// -*- C++ -*-
// CLASSDOC OFF
// ---------------------------------------------------------------------------
// CLASSDOC ON
 
#ifndef HEP_ROTATION_INTERFACES_H
#define HEP_ROTATION_INTERFACES_H
 
// This file is a part of the CLHEP - a Class Library for High Energy Physics.
//
// This contains the definition of two abstract interface classes:
// Hep4RotationInterface 
// Hep3RotationInterface.  
// However, these are mostly for defining methods which should be present in
// any 4- or 3-rotation class, however specialized.  The actual classes do
// not inherit from these.  The virtual function overhead turns out 
// to be too steep for that to be practical.
//
// It may be desirable in the future to turn these classes into constraints
// in the Stroustrup sense, so as to enforce this interface, still without 
// inheritance.  However, they do contain an important static:
// static double tolerance to set criteria for relative nearness.
//
// This file also defines structs 
// HepRep3x3;
// HepRep4x4;
// HepRep4x4Symmetric;
// which are used by various Rotation classes.
// 
// Hep4RotationInterface 
//  contains all the methods to get attributes of either a
//  HepLorentzRotation or a HepRotation -- any information 
//  that pertains to a LorentzRotation can also be defined
//  for a HepRotation.(For example, the 4x4 representation
//  would just have 0's in the space-time entries and 1 in
//  the time-time entry.) 
//
// Hep3RotationInterface 
//  inherits from Hep4RotationInterface,  and adds methods
//  which are well-defined only in the case of a Rotation.
//  For example, a 3x3 representation is an attribute only
//  if the generic LorentzRotation involves no boost.
//
// In terms of classes in the ZOOM PhysicsVectors package, 
//  Hep4RotationInterface <--> LorentzTransformationInterface
//  Hep3RotationInterface <--> RotationInterface
//
// Hep4RotationInterface defines the required methods for:
//  HepLorentzRotation
//  HepBoost
//  HepBoostX
//  HepBoostY
//  HepBoostZ
//
// Hep3RotationInterface defines the required methods for:
//  HepRotation
//  HepRotationX
//  HepRotationY
//  HepRotationZ
//
// .SS See Also
// Rotation.h, LorentzRotation.h
//
// .SS Author
// Mark Fischler
//
 
#include "CLHEP/Vector/defs.h" 
#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Vector/AxisAngle.h"
 
namespace CLHEP {
 
struct HepRep3x3;
struct HepRep4x4;
struct HepRep4x4Symmetric;
 
class HepRotation;
class HepRotationX;
class HepRotationY;
class HepRotationZ;
class HepLorentzRotation;
class HepBoost;
class HepBoostX;
class HepBoostY;
class HepBoostZ;
 
//-******************************
//
// Hep4RotationInterface 
//
//-******************************
 
/**
 * @author
 * @ingroup vector
 */
class Hep4RotationInterface  {
 
  // All attributes of shared by HepLorentzRotation, HepBoost, 
  // HepBoostX, HepBoostY, HepBoostZ.  HepRotation, HepRotationX, 
  // HepRotationY, HepRotationZ also share this attribute interface.
 
  friend class  HepRotation;
  friend class  HepRotationX;
  friend class  HepRotationY;
  friend class  HepRotationZ;
  friend class  HepLorentzRotation;
  friend class  HepBoost;
  friend class  HepBoostX;
  friend class  HepBoostY;
  friend class  HepBoostZ;
 
public:
 
  static double tolerance;        // to determine relative nearness
 
  // ----------  Accessors:
 
#ifdef ONLY_IN_CONCRETE_CLASSES
  //  orthosymplectic 4-vectors:
  HepLorentzVector col1() const;
  HepLorentzVector col2() const;
  HepLorentzVector col3() const;
  HepLorentzVector col4() const;
  HepLorentzVector row1() const;
  HepLorentzVector row2() const;
  HepLorentzVector row3() const;
  HepLorentzVector row4() const;
 
  //  individual elements:
  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  ;
 
  //   4x4 representation:
//HepRep4x4 rep4x4() const; JMM  Declared here but not defined anywhere!
 
  // ----------  Operations:
  //   comparisons:
 
  inline int compare( const Hep4RotationInterface & lt ) const;
  // Dictionary-order comparisons, utilizing the decompose(b,r) method
 
  //   decomposition:
 
  void decompose (HepAxisAngle & rotation, Hep3Vector & boost)const;
  // Decompose as T= R * B, where R is pure rotation, B is pure boost.
 
  void decompose (Hep3Vector & boost, HepAxisAngle & rotation)const;
  // Decompose as T= B * R, where R is pure rotation, B is pure boost.
 
  bool operator == (const Hep4RotationInterface & r) const;
  bool operator != (const Hep4RotationInterface & r) const;
 
  //   relative comparison:
 
  double norm2() const  ;
  double  distance2( const Hep4RotationInterface & lt ) const  ;
  double  howNear( const Hep4RotationInterface & lt ) const  ;
  bool isNear (const Hep4RotationInterface & lt, 
                   double epsilon=tolerance) const  ;
 
  void rectify()  ;
  // non-const but logically const correction for accumulated roundoff errors
 
  // ----------  Apply LorentzTransformations:
 
  HepLorentzVector operator* ( const HepLorentzVector & w ) const  ;
  HepLorentzVector operator()( const HepLorentzVector & w ) const  ;
  // Apply to a 4-vector
 
  // ----------  I/O:
 
  std::ostream & print( std::ostream & os ) const;
 
#endif /* ONLY_IN_CONCRETE_CLASSES */
 
  static double getTolerance();
  static double setTolerance( double tol );
 
  static const int ToleranceTicks = 100;
 
protected:
 
  ~Hep4RotationInterface() {}   // protect destructor to forbid instatiation
 
};  // Hep4RotationInterface
 
 
//-******************************
//
// Hep3RotationInterface 
//
//-******************************
 
/**
 * @author
 * @ingroup vector
 */
class Hep3RotationInterface : public Hep4RotationInterface {
 
  // All attributes of HepRotation, HepRotationX, HepRotationY, HepRotationZ
  // beyond those available by virtue of being a Hep3RotationInterface.
 
  friend class  HepRotation;
  friend class  HepRotationX;
  friend class  HepRotationY;
  friend class  HepRotationZ;
 
public:
 
#ifdef ONLY_IN_CONCRETE_CLASSES
 
  //   Euler angles:
  double getPhi  () const  ;
  double getTheta() const  ;
  double getPsi  () const  ;
  double    phi  () const  ;
  double    theta() const  ;
  double    psi  () const  ;
  HepEulerAngles eulerAngles() const  ;
 
  //   axis & angle of rotation:
  double  getDelta() const  ;
  Hep3Vector getAxis () const  ;
  double     delta() const  ;
  Hep3Vector    axis () const  ;
  HepAxisAngle axisAngle() const  ;
 
  //   orthogonal unit-length vectors:
  Hep3Vector rowX() const;
  Hep3Vector rowY() const;
  Hep3Vector rowZ() const;
 
  Hep3Vector colX() const;
  Hep3Vector colY() const;
  Hep3Vector colZ() const;
 
//HepRep3x3 rep3x3() const; JMM  Declared here but not defined anywhere!
  //   3x3 representation
 
  //  orthosymplectic 4-vectors treating this as a 4-rotation:
  HepLorentzVector col1() const;
  HepLorentzVector col2() const;
  HepLorentzVector col3() const;
  HepLorentzVector col4() const;
  HepLorentzVector row1() const;
  HepLorentzVector row2() const;
  HepLorentzVector row3() const;
  HepLorentzVector row4() const;
 
  //  individual elements treating this as a 4-rotation:
  double xt() const; 
  double yt() const; 
  double zt() const; 
  double tx() const; 
  double ty() const;
  double tz() const;
  double tt() const;
 
  // ---------- Operations in the Rotation group
 
  HepRotation operator * ( const Hep3RotationInterface & r ) const  ;
 
  // ---------- Application
 
  HepLorentzVector operator* ( const HepLorentzVector & w ) const  ;
  HepLorentzVector operator()( const HepLorentzVector & w ) const  ;
  //   apply to HepLorentzVector
 
  Hep3Vector operator* ( const Hep3Vector & v ) const  ;
  Hep3Vector operator()( const Hep3Vector & v ) const  ;
  //   apply to Hep3Vector
 
  // ---------- I/O and a helper method
 
  std::ostream & print( std::ostream & os ) const;
 
#endif /* ONLY_IN_CONCRETE_CLASSES */
 
private:
 
  ~Hep3RotationInterface() {}   // private destructor to forbid instatiation
 
};  // Hep3RotationInterface
 
//-***************************
// 3x3 and 4x4 representations
//-***************************
 
struct HepRep3x3 {
 
  // -----  Constructors:
 
  inline HepRep3x3();
 
  inline HepRep3x3(  double xx, double xy, double xz
                   , double yx, double yy, double yz
                   , double zx, double zy, double zz
                   );
 
  inline HepRep3x3( const double * array );
  // construct from an array of doubles, holding the rotation matrix
  // in ROW order (xx, xy, ...)
 
  inline void setToIdentity();
 
  // -----  The data members are public:
  double xx_, xy_, xz_,
            yx_, yy_, yz_,
            zx_, zy_, zz_;
 
  inline void getArray ( double * array ) const;
  // fill array with the NINE doubles xx, xy, xz ... zz
 
};  // HepRep3x3
 
struct HepRep4x4 {
 
  // -----  Constructors:
  inline HepRep4x4();
 
  inline HepRep4x4(  double xx, double xy, double xz, double xt
                   , double yx, double yy, double yz, double yt
                   , double zx, double zy, double zz, double zt
                   , double tx, double ty, double tz, double tt
                   );
 
  inline HepRep4x4( const HepRep4x4Symmetric & rep );
 
  inline HepRep4x4( const double * array );
  // construct from an array of doubles, holding the transformation matrix
  // in ROW order xx, xy, ...
 
  inline void setToIdentity();
 
  // -----  The data members are public:
  double xx_, xy_, xz_, xt_,
            yx_, yy_, yz_, yt_,
            zx_, zy_, zz_, zt_,
            tx_, ty_, tz_, tt_;
                         
  inline void getArray ( double * array ) const;
  // fill array with the SIXTEEN doubles xx, xy, xz ... tz, tt
 
  inline bool operator==(HepRep4x4 const & r) const;
  inline bool operator!=(HepRep4x4 const & r) const;
 
 
};  // HepRep4x4
 
struct HepRep4x4Symmetric {
 
  // -----  Constructors:
 
  inline HepRep4x4Symmetric();
 
  inline HepRep4x4Symmetric
    ( double xx, double xy, double xz, double xt
                      , double yy, double yz, double yt
                                    , double zz, double zt
                                                  , double tt );
 
  inline HepRep4x4Symmetric( const double * array );
  // construct from an array of doubles, holding the transformation matrix
  // elements in this order:  xx, xy, xz, xt, yy, yz, yt, zz, zt, tt
 
  inline void setToIdentity();
 
  // -----  The data members are public:
  double xx_, xy_, xz_, xt_,
                 yy_, yz_, yt_,
                      zz_, zt_,
                           tt_;
 
  inline void getArray ( double * array ) const;
  // fill array with the TEN doubles xx, xy, xz, xt, yy, yz, yt, zz, zt, tt
 
};
 
}  // namespace CLHEP
 
#include "CLHEP/Vector/RotationInterfaces.icc"
 
#ifdef ENABLE_BACKWARDS_COMPATIBILITY
//  backwards compatibility will be enabled ONLY in CLHEP 1.9
using namespace CLHEP;
#endif
 
#endif // ROTATION_INTERFACES_H