CLHEP/Vector/BoostY.h

// -*- C++ -*-
//
// This file is a part of the CLHEP - a Class Library for High Energy Physics.
//
// This is the definition of the HepBoostY class for performing specialized
// Lorentz transformations which are pure boosts in the Y direction, on 
// objects of the HepLorentzVector class.
//
// HepLorentzRotation is a concrete implementation of Hep4RotationInterface.
//
// .SS See Also
// RotationInterfaces.h
// LorentzVector.h LorentzRotation.h 
// Boost.h 
//
// .SS Author
// Mark Fischler

#ifndef HEP_BOOSTY_H
#define HEP_BOOSTY_H

#ifdef GNUPRAGMA
#pragma interface
#endif

#ifdef HEP_NO_INLINE_IN_DECLARATION
#define inline
#endif

#include "CLHEP/Vector/RotationInterfaces.h"
#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Vector/Boost.h"

// Declarations of classes and global methods
class HepBoostY;               
inline HepBoostY inverseOf ( const HepBoostY & b ); 

class HepBoostY : public Hep4RotationInterface {

public:

  // ----------  Constructors and Assignment:

  inline HepBoostY();
  // Default constructor. Gives a boost of 0.  

  inline HepBoostY(const HepBoostY & b);
  // Copy constructor.

  inline HepBoostY & operator = (const HepBoostY & m);
  // Assignment.

  virtual HepBoostY & set (HepDouble beta);
  inline  HepBoostY       (HepDouble beta);
  // Constructor from beta 

  // ----------  Conversion:

  inline operator HepBoost() const;
  // Promote to general boost

  // ----------  Accessors:

  inline HepDouble  beta()  const;
  inline HepDouble  gamma() const;
  inline Hep3Vector boostVector() const;
  inline Hep3Vector getDirection() const;

  inline HepDouble xx() const;
  inline HepDouble xy() const;
  inline HepDouble xz() const;
  inline HepDouble xt() const;
  inline HepDouble yx() const;
  inline HepDouble yy() const;
  inline HepDouble yz() const;
  inline HepDouble yt() const;
  inline HepDouble zx() const;
  inline HepDouble zy() const;
  inline HepDouble zz() const;
  inline HepDouble zt() const;
  inline HepDouble tx() const;
  inline HepDouble ty() const;
  inline HepDouble tz() const;
  inline HepDouble tt() const;
  // Elements of the matrix.

  inline HepLorentzVector col1() const;
  inline HepLorentzVector col2() const;
  inline HepLorentzVector col3() const;
  inline HepLorentzVector col4() const;
  // orthosymplectic column vectors

  inline HepLorentzVector row1() const;
  inline HepLorentzVector row2() const;
  inline HepLorentzVector row3() const;
  inline HepLorentzVector row4() const;
  // orthosymplectic row vectors

  virtual HepRep4x4 rep4x4() const;
  //   4x4 representation:

  // ----------  Decomposition:

  virtual void decompose (HepRotation  & rotation, HepBoost   & boost) const;

  virtual void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
  // Find R and B such that L = R*B -- trivial, since R is identity

  virtual void decompose (HepBoost  & boost, HepRotation   & rotation) const;

  virtual void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;
  // Find R and B such that L = B*R -- trivial, since R is identity

  // ----------  Comparisons:

  inline HepBoolean isIdentity() const;
  // Returns true if a null boost.

  inline int compare( const HepBoostY & b  ) const;
  	 int compare( const Hep4RotationInterface & r  ) const;
  // Dictionary-order comparison.  This is used in
  // operator<, operator>, operator<=, and operator>=, which are inherited.

  virtual HepDouble distance2( const Hep4RotationInterface & lt  ) const;
  // Decompose lt = B*R; add norm2 to distance2 to between boosts.

  inline  HepDouble distance2( const HepBoost & b ) const;
  // Defined as the distance2 between the vectors (gamma*betaVector)

  inline  HepDouble distance2( const HepBoostY & b ) const;
  // Defined as the distance2 between the vectors (gamma*betaVector)

  virtual HepDouble howNear(   const Hep4RotationInterface & lt ) const;
  virtual HepDouble howNear(   const HepBoostY & b ) const;

  virtual HepBoolean isNear(   const Hep4RotationInterface & lt,
                                     HepDouble epsilon=tolerance) const;

  virtual HepBoolean isNear(   const HepBoostY & b,
                                     HepDouble epsilon=tolerance) const;

  // ----------  Properties:

  virtual HepDouble norm2() const;
  // distance2 (IDENTITY), which is beta^2 * gamma^2

  virtual void rectify();
  // sets according to the stored beta

  // ---------- Application:

  virtual HepLorentzVector operator()( const HepLorentzVector & w ) const;
  // Transform a Lorentz Vector.             

  inline HepLorentzVector operator* ( const HepLorentzVector & w ) const;
  // Multiplication with a Lorentz Vector.

  // ---------- Operations in the group of 4-Rotations

  virtual HepLorentzRotation operator * 
				(const Hep4RotationInterface & lt) const;
  // Product of two Lorentz Rotations (this) * lt - matrix multiplication  
  // Notice that the product of two pure boosts is no longer a pure boost

  HepBoostY operator * (const HepBoostY & b) const;

  inline HepBoostY inverse() const;
  // Return the inverse.

  inline friend HepBoostY inverseOf ( const HepBoostY & b );
  // global methods to invert.

  inline HepBoostY & invert();
  // Inverts the Boost matrix.

  // ---------- I/O:

  virtual HepStd::ostream & print( HepStd::ostream & os ) const;
  // Output form is BOOSTY (beta=..., gamma=...);  

protected:

  inline HepBoostY (HepDouble beta, HepDouble gamma);

  HepDouble  beta_;
  HepDouble  gamma_;

};

#ifdef HEP_NO_INLINE_IN_DECLARATION
#undef inline
#endif

#ifdef HEP_SHORT_NAMES
typedef HepBoostY LBoostY;
#endif

#ifndef HEP_DEBUG_INLINE
#include "CLHEP/Vector/BoostY.icc"
#endif

#endif /* HEP_BOOSTY_H */