#ifndef ROOT_TThreeRotation
#define ROOT_TThreeRotation
 
#ifndef ROOT_TObject
#include "TObject.h"
#endif
#ifndef ROOT_TLorentzTransform
#include "TLorentzTransform.h"
#endif
#ifndef ROOT_TError
#include "TError.h"
#endif
 
#include <math.h>

class TThreeVectorComplex;

 
class TThreeRotation : public TLorentzTransform {
 
public:
   TThreeRotation() { }
   TThreeRotation(const TThreeVectorReal &axis);
   TThreeRotation(const TUnitVector &ahat, const Double_t angle);
   TThreeRotation(const Double_t phi, const Double_t theta, const Double_t psi);
   TThreeRotation(const TThreeRotation &another);
 
   virtual ~TThreeRotation() { }
 
   TThreeVectorReal Axis() const;
   void GetAxis(TUnitVector &ahat, Double_t &angle) const;
   void GetEuler(Double_t &phi, Double_t &theta, Double_t &psi) const;

   TThreeRotation &operator=(const TThreeRotation &source);
   TThreeRotation &operator*=(const TThreeRotation &source);
 
   TThreeRotation &Null();
   TThreeRotation &Transpose();
   TThreeRotation &Invert();

   TThreeRotation &SetAxis(const TThreeVectorReal &axis);
   TThreeRotation &SetAxis(const TUnitVector &ahat, const Double_t angle);
   TThreeRotation &SetEuler(const Double_t &phi,
                       const Double_t &theta,
                       const Double_t &psi);

   TThreeVectorReal operator*(const TThreeVectorReal &vec) const;
   TThreeVectorComplex operator*(const TThreeVectorComplex &vec) const;
   TThreeRotation operator*(const TThreeRotation &rotOp) const;

   void Print(Option_t *option="");
 
   ClassDef(TThreeRotation,1)  // Space-rotation operator class
};
 
//----- inlines ----------------------------------------------------------------

inline TThreeRotation::TThreeRotation(const TThreeVectorReal &axis)
{
   SetAxis(axis);
}

inline TThreeRotation::TThreeRotation(const TUnitVector &ahat, const Double_t angle)
{
   SetAxis(ahat,angle);
}

inline TThreeRotation::TThreeRotation(const Double_t phi,
                            const Double_t theta,
                            const Double_t psi)
{
   SetEuler(phi,theta,psi);
}

inline TThreeRotation::TThreeRotation(const TThreeRotation &another)
{
   *(TLorentzTransform *)this = (TLorentzTransform)another;
}
 
#endif