library: libMathCore
#include "EulerAngles.h"

ROOT::Math::EulerAngles

class description - header file - source file - inheritance tree (.pdf)

class ROOT::Math::EulerAngles

Inheritance Chart:
ROOT::Math::EulerAngles
 
    private:

      static double Pi()

    public:

                                                                                                               EulerAngles()
                                                                                                               EulerAngles(ROOT::Math::EulerAngles::Scalar phi, ROOT::Math::EulerAngles::Scalar theta, ROOT::Math::EulerAngles::Scalar psi)
                                                                                                               EulerAngles(const ROOT::Math::Rotation3D& r)
                                                                                                               EulerAngles(const ROOT::Math::Quaternion& q)
                                                                                                               EulerAngles(const ROOT::Math::AxisAngle& a)
                                                                                                               EulerAngles(ROOT::Math::RotationZ const& r)
                                                                                                               EulerAngles(ROOT::Math::RotationY const& r)
                                                                                                               EulerAngles(ROOT::Math::RotationX const& r)
                                                                                       ROOT::Math::EulerAngles Inverse() const
                                                                                       ROOT::Math::EulerAngles operator*(const ROOT::Math::Rotation3D& r) const
                                                                                       ROOT::Math::EulerAngles operator*(const ROOT::Math::AxisAngle& a) const
                                                                                       ROOT::Math::EulerAngles operator*(const ROOT::Math::EulerAngles& e) const
                                                                                       ROOT::Math::EulerAngles operator*(const ROOT::Math::Quaternion& q) const
                                                                                       ROOT::Math::EulerAngles operator*(const ROOT::Math::RotationX& rx) const
                                                                                       ROOT::Math::EulerAngles operator*(const ROOT::Math::RotationY& ry) const
                                                                                       ROOT::Math::EulerAngles operator*(const ROOT::Math::RotationZ& rz) const
                                                                                                               EulerAngles(double* begin, double* end)
                                                                                                               EulerAngles(const ROOT::Math::EulerAngles&)
                                                                                                               ~EulerAngles()
                                                                                                          void GetComponents(ROOT::Math::EulerAngles::Scalar& phi, ROOT::Math::EulerAngles::Scalar& theta, ROOT::Math::EulerAngles::Scalar& psi) const
                                                                                                          void GetComponents(double* begin, double* end) const
                                                                                                          void Invert()
                                                                                                          bool operator!=(const ROOT::Math::EulerAngles& rhs)
                                                     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > operator()(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
      ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> operator()(const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v) const
          ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> operator()(const ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v) const
          ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> operator*(const ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v) const
      ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> operator*(const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v) const
                                                     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
                                                                                      ROOT::Math::EulerAngles& operator=(ROOT::Math::Rotation3D const& r)
                                                                                      ROOT::Math::EulerAngles& operator=(ROOT::Math::AxisAngle const& a)
                                                                                      ROOT::Math::EulerAngles& operator=(ROOT::Math::Quaternion const& q)
                                                                                      ROOT::Math::EulerAngles& operator=(ROOT::Math::RotationZ const& r)
                                                                                      ROOT::Math::EulerAngles& operator=(ROOT::Math::RotationY const& r)
                                                                                      ROOT::Math::EulerAngles& operator=(ROOT::Math::RotationX const& r)
                                                                                      ROOT::Math::EulerAngles& operator=(const ROOT::Math::EulerAngles&)
                                                                                                          bool operator==(const ROOT::Math::EulerAngles& rhs)
                                                                               ROOT::Math::EulerAngles::Scalar Phi() const
                                                                               ROOT::Math::EulerAngles::Scalar Psi() const
                                                                                                          void Rectify()
                                                                                                          void SetComponents(ROOT::Math::EulerAngles::Scalar phi, ROOT::Math::EulerAngles::Scalar theta, ROOT::Math::EulerAngles::Scalar psi)
                                                                                                          void SetComponents(double* begin, double* end)
                                                                                                          void SetPhi(ROOT::Math::EulerAngles::Scalar phi)
                                                                                                          void SetPsi(ROOT::Math::EulerAngles::Scalar psi)
                                                                                                          void SetTheta(ROOT::Math::EulerAngles::Scalar theta)
                                                                               ROOT::Math::EulerAngles::Scalar Theta() const

Data Members

    private:

      double fPhi    
      double fTheta  
      double fPsi

Class Description

EulerAngles()


 EulerAngles( Scalar phi, Scalar theta, Scalar psi )




 EulerAngles(IT begin, IT end)




void Rectify()




explicit EulerAngles(const Rotation3D & r)




explicit EulerAngles(const Quaternion & q)




explicit EulerAngles(const AxisAngle & a )




explicit EulerAngles( RotationZ const & r )




explicit EulerAngles( RotationY const & r )




explicit EulerAngles( RotationX const & r )




 operator=( Rotation3D const  & r )




 operator=( AxisAngle const & a )




 operator=( Quaternion const  & q )




 operator=( RotationZ const & r )




 operator=( RotationY const & r )




 operator=( RotationX const & r )




void SetComponents(IT begin, IT end)




void GetComponents(IT begin, IT end)




void SetComponents(Scalar phi, Scalar theta, Scalar psi)




void GetComponents(Scalar & phi, Scalar & theta, Scalar & psi)




void SetPhi(Scalar phi)




Scalar Phi()




void SetTheta(Scalar theta)




Scalar Theta()




void SetPsi(Scalar psi)




Scalar Psi()




DisplacementVector3D< Cartesian3D<double>,U > rxyz = operator()(xyz)




xyz = operator()(xyz)




DisplacementVector3D< Cartesian3D<double> > rxyz = operator()(xyz)




void Invert()


 theta stays the same and negative rotation in Theta is done via a rotation
 of + PI in pohi and Psi



fPhi = -fPsi + Pi()




EulerAngles Inverse()




return ! operator==(rhs)







Last update: Tue Jul 11 11:46:34 2006









ROOT page - Class index - Class Hierarchy - Top of the page









This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.