ROOT::Math::Transform3DPJ Class Reference

#include <Transform3DPJ.h>

Public Types
enum	ETransform3DMatrixIndex {   kXX = 0, kXY = 1, kXZ = 2, kDX = 3,   kYX = 4, kYY = 5, kYZ = 6, kDY = 7,   kZX = 8, kZY = 9, kZZ =10, kDZ = 11 }
typedef PositionVector3D < Cartesian3D< double > , DefaultCoordinateSystemTag >	Point
typedef DisplacementVector3D < Cartesian3D< double > , DefaultCoordinateSystemTag >	Vector

Public Member Functions
template<class IT >
void	GetComponents (IT begin, IT end) const
template<class IT >
void	GetComponents (IT begin) const
void	GetComponents (double &xx, double &xy, double &xz, double &dx, double &yx, double &yy, double &yz, double &dy, double &zx, double &zy, double &zz, double &dz) const
void	GetDecomposition (Rotation3D &r, Vector &v) const
template<class ForeignMatrix >
void	GetTransformMatrix (ForeignMatrix &m) const
Transform3DPJ	Inverse () const
void	Invert ()
bool	operator!= (const Transform3DPJ &rhs) const
Point	operator() (const Point &p) const
Vector	operator() (const Vector &v) const
template<class CoordSystem >
PositionVector3D< CoordSystem >	operator() (const PositionVector3D< CoordSystem > &p) const
template<class CoordSystem >
DisplacementVector3D< CoordSystem >	operator() (const DisplacementVector3D< CoordSystem > &v) const
template<class CoordSystem >
LorentzVector< CoordSystem >	operator() (const LorentzVector< CoordSystem > &q) const
Plane3D	operator() (const Plane3D &plane) const
template<class AVector >
AVector	operator* (const AVector &v) const
Transform3DPJ	operator* (const Transform3DPJ &t) const
Transform3DPJ &	operator*= (const Transform3DPJ &t)
template<class ForeignMatrix >
Transform3DPJ &	operator= (const ForeignMatrix &m)
bool	operator== (const Transform3DPJ &rhs) const
template<class IT >
void	SetComponents (IT begin, IT end)
void	SetComponents (double xx, double xy, double xz, double dx, double yx, double yy, double yz, double dy, double zx, double zy, double zz, double dz)
template<class ForeignMatrix >
void	SetTransformMatrix (const ForeignMatrix &m)
template<class CoordSystem , class Tag1 , class Tag2 >
void	Transform (const PositionVector3D< CoordSystem, Tag1 > &p1, PositionVector3D< CoordSystem, Tag2 > &p2) const
template<class CoordSystem , class Tag1 , class Tag2 >
void	Transform (const DisplacementVector3D< CoordSystem, Tag1 > &v1, DisplacementVector3D< CoordSystem, Tag2 > &v2) const
	Transform3DPJ ()
template<class IT >
	Transform3DPJ (IT begin, IT end)
	Transform3DPJ (const Rotation3D &r, const Vector &v)
	Transform3DPJ (const Vector &v, const Rotation3D &r)
	Transform3DPJ (const Rotation3D &r)
	Transform3DPJ (const AxisAngle &r)
	Transform3DPJ (const EulerAngles &r)
	Transform3DPJ (const Quaternion &r)
	Transform3DPJ (const RotationX &r)
	Transform3DPJ (const RotationY &r)
	Transform3DPJ (const RotationZ &r)
template<class CoordSystem , class Tag >
	Transform3DPJ (const DisplacementVector3D< CoordSystem, Tag > &v)
	Transform3DPJ (const Vector &v)
template<class ARotation , class CoordSystem , class Tag >
	Transform3DPJ (const ARotation &r, const DisplacementVector3D< CoordSystem, Tag > &v)
template<class ARotation , class CoordSystem , class Tag >
	Transform3DPJ (const DisplacementVector3D< CoordSystem, Tag > &v, const ARotation &r)
	Transform3DPJ (const Point &fr0, const Point &fr1, const Point &fr2, const Point &to0, const Point &to1, const Point &to2)
template<class ForeignMatrix >
	Transform3DPJ (const ForeignMatrix &m)
	Transform3DPJ (double xx, double xy, double xz, double dx, double yx, double yy, double yz, double dy, double zx, double zy, double zz, double dz)

Protected Member Functions
void	AssignFrom (const Rotation3D &r, const Vector &v)
void	AssignFrom (const Rotation3D &r)
void	AssignFrom (const Vector &v)
void	SetIdentity ()

Private Attributes
double	fM [12]

Detailed Description

Basic 3D Transformation class describing a rotation and then a translation The internal data are a rotation data and a 3D vector data and they can be represented like a 3x4 matrix The class has a template parameter the coordinate system tag of the reference system to which the transformatioon will be applied. For example for transforming from global to local coordinate systems, the transfrom3D has to be instantiated with the coordinate of the traget system

Definition at line 60 of file Transform3DPJ.h.

Member Typedef Documentation

typedef PositionVector3D<Cartesian3D<double>, DefaultCoordinateSystemTag > ROOT::Math::Transform3DPJ::Point

Definition at line 66 of file Transform3DPJ.h.

typedef DisplacementVector3D<Cartesian3D<double>, DefaultCoordinateSystemTag > ROOT::Math::Transform3DPJ::Vector

Definition at line 65 of file Transform3DPJ.h.

Member Enumeration Documentation

enum ROOT::Math::Transform3DPJ::ETransform3DMatrixIndex

Enumerator
kXX
kXY
kXZ
kDX
kYX
kYY
kYZ
kDY
kZX
kZY
kZZ
kDZ

Definition at line 69 of file Transform3DPJ.h.

                                 {
      kXX = 0, kXY = 1, kXZ = 2, kDX = 3, 
      kYX = 4, kYY = 5, kYZ = 6, kDY = 7,
      kZX = 8, kZY = 9, kZZ =10, kDZ = 11
    };

Constructor & Destructor Documentation

ROOT::Math::Transform3DPJ::Transform3DPJ ( )

inline

Default constructor (identy rotation) + zero translation

Definition at line 80 of file Transform3DPJ.h.

References SetIdentity().

    {
      SetIdentity();
    }

template<class IT >

ROOT::Math::Transform3DPJ::Transform3DPJ ( IT  begin, IT  end  )

inline

Construct given a pair of pointers or iterators defining the beginning and end of an array of 12 Scalars

Definition at line 90 of file Transform3DPJ.h.

References SetComponents().

    { 
      SetComponents(begin,end); 
    }

ROOT::Math::Transform3DPJ::Transform3DPJ ( const Rotation3D &  r, const Vector &  v  )

inline

Construct from a rotation and then a translation described by a Vector

Definition at line 98 of file Transform3DPJ.h.

References AssignFrom().

    {
      AssignFrom( r, v ); 
    }

ROOT::Math::Transform3DPJ::Transform3DPJ ( const Vector &  v, const Rotation3D &  r  )

inline

Construct from a translation and then a rotation (inverse assignment)

Definition at line 105 of file Transform3DPJ.h.

References AssignFrom(), and alignCSCRings::r.

    {
      // is equivalent from having first the rotation and then the translation vector rotated
      AssignFrom( r, r(v) ); 
    }

ROOT::Math::Transform3DPJ::Transform3DPJ ( const Rotation3D &  r )

inlineexplicit

Construct from a 3D Rotation only with zero translation

Definition at line 114 of file Transform3DPJ.h.

References AssignFrom().

                                                  { 
      AssignFrom(r);
    } 

ROOT::Math::Transform3DPJ::Transform3DPJ ( const AxisAngle &  r )

inlineexplicit

Definition at line 118 of file Transform3DPJ.h.

References AssignFrom().

                                                 { 
      AssignFrom(Rotation3D(r));
    } 

ROOT::Math::Transform3DPJ::Transform3DPJ ( const EulerAngles &  r )

inlineexplicit

Definition at line 121 of file Transform3DPJ.h.

References AssignFrom().

                                                   { 
      AssignFrom(Rotation3D(r));
    } 

ROOT::Math::Transform3DPJ::Transform3DPJ ( const Quaternion &  r )

inlineexplicit

Definition at line 124 of file Transform3DPJ.h.

References AssignFrom().

                                                  { 
      AssignFrom(Rotation3D(r));
    } 

ROOT::Math::Transform3DPJ::Transform3DPJ ( const RotationX &  r )

inlineexplicit

Definition at line 128 of file Transform3DPJ.h.

References AssignFrom().

                                                 { 
      AssignFrom(Rotation3D(r));
    } 

ROOT::Math::Transform3DPJ::Transform3DPJ ( const RotationY &  r )

inlineexplicit

Definition at line 131 of file Transform3DPJ.h.

References AssignFrom().

                                                 { 
      AssignFrom(Rotation3D(r));
    } 

ROOT::Math::Transform3DPJ::Transform3DPJ ( const RotationZ &  r )

inlineexplicit

Definition at line 134 of file Transform3DPJ.h.

References AssignFrom().

                                                 { 
      AssignFrom(Rotation3D(r));
    } 

template<class CoordSystem , class Tag >

ROOT::Math::Transform3DPJ::Transform3DPJ ( const DisplacementVector3D< CoordSystem, Tag > &  v )

inlineexplicit

Construct from a translation only, represented by any DisplacementVector3D and with an identity rotation

Definition at line 143 of file Transform3DPJ.h.

References AssignFrom().

                                                                             { 
      AssignFrom(Vector(v.X(),v.Y(),v.Z()));
    }

ROOT::Math::Transform3DPJ::Transform3DPJ ( const Vector &  v )

inlineexplicit

Construct from a translation only, represented by a Cartesian 3D Vector, and with an identity rotation

Definition at line 150 of file Transform3DPJ.h.

References AssignFrom().

                                              { 
      AssignFrom(v);
    }

template<class ARotation , class CoordSystem , class Tag >

ROOT::Math::Transform3DPJ::Transform3DPJ ( const ARotation &  r, const DisplacementVector3D< CoordSystem, Tag > &  v  )

inline

Construct from a rotation (any rotation object) and then a translation (represented by any DisplacementVector) The requirements on the rotation and vector objects are that they can be transformed in a Rotation3D class and in a Vector

Definition at line 165 of file Transform3DPJ.h.

References AssignFrom().

    {
      AssignFrom( Rotation3D(r), Vector (v.X(),v.Y(),v.Z()) ); 
    }

template<class ARotation , class CoordSystem , class Tag >

ROOT::Math::Transform3DPJ::Transform3DPJ ( const DisplacementVector3D< CoordSystem, Tag > &  v, const ARotation &  r  )

inline

Construct from a translation (using any type of DisplacementVector ) and then a rotation (any rotation object). Requirement on the rotation and vector objects are that they can be transformed in a Rotation3D class and in a Vector

Definition at line 176 of file Transform3DPJ.h.

References AssignFrom().

    {
      // is equivalent from having first the rotation and then the translation vector rotated
      Rotation3D r3d(r);
      AssignFrom( r3d, r3d( Vector(v.X(),v.Y(),v.Z()) ) ); 
    }

ROOT::Math::Transform3DPJ::Transform3DPJ	(	const Point &	fr0,
		const Point &	fr1,
		const Point &	fr2,
		const Point &	to0,
		const Point &	to1,
		const Point &	to2
	)

Construct transformation from one coordinate system defined by three points (origin + two axis) to a new coordinate system defined by other three points (origin + axis)

Parameters

fr0	point defining origin of original reference system
fr1	point defining first axis of original reference system
fr2	point defining second axis of original reference system
to0	point defining origin of transformed reference system
to1	point defining first axis transformed reference system
to2	point defining second axis transformed reference system

Definition at line 40 of file Transform3DPJ.cc.

References dtNoiseDBValidation_cfg::cerr, SetComponents(), and SetIdentity().

{
   // takes impl. from CLHEP ( E.Chernyaev). To be checked
   
   XYZVector x1,y1,z1, x2,y2,z2;
   x1 = (fr1 - fr0).Unit();
   y1 = (fr2 - fr0).Unit();
   x2 = (to1 - to0).Unit();
   y2 = (to2 - to0).Unit();
   
   //   C H E C K   A N G L E S
   
   double cos1, cos2;
   cos1 = x1.Dot(y1);
   cos2 = x2.Dot(y2);
   
   if (std::fabs(1.0-cos1) <= 0.000001 || std::fabs(1.0-cos2) <= 0.000001) {
      std::cerr << "Transform3DPJ: Error : zero angle between axes" << std::endl;
      SetIdentity();
   } else {
      if (std::fabs(cos1-cos2) > 0.000001) {
         std::cerr << "Transform3DPJ: Warning: angles between axes are not equal"
         << std::endl;
      }
      
      //   F I N D   R O T A T I O N   M A T R I X
      
      z1 = (x1.Cross(y1)).Unit();
      y1  = z1.Cross(x1);
      
      z2 = (x2.Cross(y2)).Unit();
      y2  = z2.Cross(x2);

      double x1x = x1.X(), x1y = x1.Y(), x1z = x1.Z();
      double y1x = y1.X(), y1y = y1.Y(), y1z = y1.Z();
      double z1x = z1.X(), z1y = z1.Y(), z1z = z1.Z();
      
      double detxx =  (y1y*z1z - z1y*y1z);
      double detxy = -(y1x*z1z - z1x*y1z);
      double detxz =  (y1x*z1y - z1x*y1y);
      double detyx = -(x1y*z1z - z1y*x1z);
      double detyy =  (x1x*z1z - z1x*x1z);
      double detyz = -(x1x*z1y - z1x*x1y);
      double detzx =  (x1y*y1z - y1y*x1z);
      double detzy = -(x1x*y1z - y1x*x1z);
      double detzz =  (x1x*y1y - y1x*x1y);

      double x2x = x2.X(), x2y = x2.Y(), x2z = x2.Z();
      double y2x = y2.X(), y2y = y2.Y(), y2z = y2.Z();
      double z2x = z2.X(), z2y = z2.Y(), z2z = z2.Z();

      double txx = x2x*detxx + y2x*detyx + z2x*detzx;
      double txy = x2x*detxy + y2x*detyy + z2x*detzy;
      double txz = x2x*detxz + y2x*detyz + z2x*detzz;
      double tyx = x2y*detxx + y2y*detyx + z2y*detzx;
      double tyy = x2y*detxy + y2y*detyy + z2y*detzy;
      double tyz = x2y*detxz + y2y*detyz + z2y*detzz;
      double tzx = x2z*detxx + y2z*detyx + z2z*detzx;
      double tzy = x2z*detxy + y2z*detyy + z2z*detzy;
      double tzz = x2z*detxz + y2z*detyz + z2z*detzz;
      
      //   S E T    T R A N S F O R M A T I O N
      
      double dx1 = fr0.X(), dy1 = fr0.Y(), dz1 = fr0.Z();
      double dx2 = to0.X(), dy2 = to0.Y(), dz2 = to0.Z();
      
      SetComponents(txx, txy, txz, dx2-txx*dx1-txy*dy1-txz*dz1,
                    tyx, tyy, tyz, dy2-tyx*dx1-tyy*dy1-tyz*dz1,
                    tzx, tzy, tzz, dz2-tzx*dx1-tzy*dy1-tzz*dz1);
   }
}

template<class ForeignMatrix >

ROOT::Math::Transform3DPJ::Transform3DPJ ( const ForeignMatrix &  m )

inlineexplicit

Construct from a linear algebra matrix of size at least 3x4, which must support operator()(i,j) to obtain elements (0,0) thru (2,3). The 3x3 sub-block is assumed to be the rotation part and the translations vector are described by the 4-th column

Definition at line 211 of file Transform3DPJ.h.

References SetComponents().

                                                    { 
      SetComponents(m); 
    }

ROOT::Math::Transform3DPJ::Transform3DPJ ( double  xx, double  xy, double  xz, double  dx, double  yx, double  yy, double  yz, double  dy, double  zx, double  zy, double  zz, double  dz  )

inline

Raw constructor from 12 Scalar components

Definition at line 218 of file Transform3DPJ.h.

References SetComponents().

    {
      SetComponents (xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
    }

Member Function Documentation

void ROOT::Math::Transform3DPJ::AssignFrom ( const Rotation3D &  r, const Vector &  v  )

protected

make transformation from first a rotation then a translation

Definition at line 212 of file Transform3DPJ.cc.

References fM, i, kDX, kDY, kDZ, kYX, and kZX.

Referenced by Transform3DPJ().

{
   // assignment  from rotation + translation
   
   double rotData[9];
   r.GetComponents(rotData, rotData +9);
   // first raw
   for (int i = 0; i < 3; ++i)
      fM[i] = rotData[i];
   // second raw
   for (int i = 0; i < 3; ++i)
      fM[kYX+i] = rotData[3+i];
   // third raw
   for (int i = 0; i < 3; ++i)
      fM[kZX+i] = rotData[6+i];
   
   // translation data
   double vecData[3];
   v.GetCoordinates(vecData, vecData+3);
   fM[kDX] = vecData[0];
   fM[kDY] = vecData[1];
   fM[kDZ] = vecData[2];
}

void ROOT::Math::Transform3DPJ::AssignFrom ( const Rotation3D &  r )

protected

make transformation from only rotations (zero translation)

Definition at line 237 of file Transform3DPJ.cc.

References fM, i, and j.

{
   // assign from only a rotation  (null translation)
   double rotData[9];
   r.GetComponents(rotData, rotData +9);
   for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 3; ++j)
         fM[4*i + j] = rotData[3*i+j];
      // empty vector data
      fM[4*i + 3] = 0;
   }
}

void ROOT::Math::Transform3DPJ::AssignFrom ( const Vector &  v )

protected

make transformation from only translation (identity rotations)

Definition at line 250 of file Transform3DPJ.cc.

References fM, kDX, kDY, kDZ, kXX, kXY, kXZ, kYX, kYY, kYZ, kZX, kZY, and kZZ.

{
   // assign from a translation only (identity rotations)
   fM[kXX] = 1.0;  fM[kXY] = 0.0; fM[kXZ] = 0.0; fM[kDX] = v.X();
   fM[kYX] = 0.0;  fM[kYY] = 1.0; fM[kYZ] = 0.0; fM[kDY] = v.Y();
   fM[kZX] = 0.0;  fM[kZY] = 0.0; fM[kZZ] = 1.0; fM[kDZ] = v.Z();
}

template<class IT >

void ROOT::Math::Transform3DPJ::GetComponents ( IT  begin, IT  end  ) const

inline

Get the 12 matrix components into data specified by an iterator begin and another to the end of the desired data (12 past start).

Definition at line 260 of file Transform3DPJ.h.

References begin, fM, and i.

Referenced by ROOT::Math::operator<<().

                                               {
       for (int i = 0; i <12; ++i) { 
          *begin = fM[i];
          ++begin;  
       }
       assert (end==begin);
    }

template<class IT >

void ROOT::Math::Transform3DPJ::GetComponents ( IT  begin ) const

inline

Get the 12 matrix components into data specified by an iterator begin

Definition at line 272 of file Transform3DPJ.h.

References filterCSVwithJSON::copy, and fM.

                                       {
      std::copy ( fM, fM+12, begin );
    }

void ROOT::Math::Transform3DPJ::GetComponents ( double &  xx, double &  xy, double &  xz, double &  dx, double &  yx, double &  yy, double &  yz, double &  dy, double &  zx, double &  zy, double &  zz, double &  dz  ) const

inline

Get the nine components into 12 scalars

Definition at line 320 of file Transform3DPJ.h.

References fM, kDX, kDY, kDZ, kXX, kXY, kXZ, kYX, kYY, kYZ, kZX, kZY, and kZZ.

                                                                 {
      xx=fM[kXX];  xy=fM[kXY];  xz=fM[kXZ];  dx=fM[kDX];
      yx=fM[kYX];  yy=fM[kYY];  yz=fM[kYZ];  dy=fM[kDY];
      zx=fM[kZX];  zy=fM[kZY];  zz=fM[kZZ];  dz=fM[kDZ];
    }

void ROOT::Math::Transform3DPJ::GetDecomposition	(	Rotation3D &	r,
		Vector &	v
	)		const

Get the rotation and translation vector representing the 3D transformation

Definition at line 146 of file Transform3DPJ.cc.

References fM, kDX, kDY, kDZ, kXX, kXY, kXZ, kYX, kYY, kYZ, kZX, kZY, and kZZ.

Referenced by CrystalPad::CrystalPad(), and operator()().

{
   // decompose a trasfomation in a 3D rotation and in a 3D vector (cartesian coordinates) 
   r.SetComponents( fM[kXX], fM[kXY], fM[kXZ],
                    fM[kYX], fM[kYY], fM[kYZ],
                    fM[kZX], fM[kZY], fM[kZZ] );
   
   v.SetCoordinates( fM[kDX], fM[kDY], fM[kDZ] );
}

template<class ForeignMatrix >

void ROOT::Math::Transform3DPJ::GetTransformMatrix ( ForeignMatrix &  m ) const

inline

Get components into a linear algebra matrix of size at least 3x4, which must support operator()(i,j) for write access to elements (0,0) thru (2,3).

Definition at line 297 of file Transform3DPJ.h.

References fM, kDX, kDY, kDZ, kXX, kXY, kXZ, kYX, kYY, kYZ, kZX, kZY, kZZ, and m.

                                                 {
      m(0,0)=fM[kXX];  m(0,1)=fM[kXY];  m(0,2)=fM[kXZ];  m(0,3)=fM[kDX];
      m(1,0)=fM[kYX];  m(1,1)=fM[kYY];  m(1,2)=fM[kYZ];  m(1,3)=fM[kDY];
      m(2,0)=fM[kZX];  m(2,1)=fM[kZY];  m(2,2)=fM[kZZ];  m(2,3)=fM[kDZ];
    }

Transform3DPJ ROOT::Math::Transform3DPJ::Inverse ( ) const

inline

Return the inverse of the transformation.

Definition at line 441 of file Transform3DPJ.h.

References Invert(), and lumiQTWidget::t.

                                  { 
      Transform3DPJ t(*this);
      t.Invert();
      return t;
    }

void ROOT::Math::Transform3DPJ::Invert

(

)

Invert the transformation in place

Definition at line 115 of file Transform3DPJ.cc.

References dtNoiseDBValidation_cfg::cerr, fM, kDX, kDY, kDZ, kXX, kXY, kXZ, kYX, kYY, kYZ, kZX, kZY, kZZ, and SetComponents().

Referenced by Inverse().

{
   //
   // Name: Transform3DPJ::inverse                     Date:    24.09.96
   // Author: E.Chernyaev (IHEP/Protvino)            Revised:
   //
   // Function: Find inverse affine transformation.
   
   double detxx = fM[kYY]*fM[kZZ] - fM[kYZ]*fM[kZY];
   double detxy = fM[kYX]*fM[kZZ] - fM[kYZ]*fM[kZX];
   double detxz = fM[kYX]*fM[kZY] - fM[kYY]*fM[kZX];
   double det   = fM[kXX]*detxx - fM[kXY]*detxy + fM[kXZ]*detxz;
   if (det == 0) {
      std::cerr << "Transform3DPJ::inverse error: zero determinant" << std::endl;
      return;
   }
   det = 1./det; detxx *= det; detxy *= det; detxz *= det;
   double detyx = (fM[kXY]*fM[kZZ] - fM[kXZ]*fM[kZY] )*det;
   double detyy = (fM[kXX]*fM[kZZ] - fM[kXZ]*fM[kZX] )*det;
   double detyz = (fM[kXX]*fM[kZY] - fM[kXY]*fM[kZX] )*det;
   double detzx = (fM[kXY]*fM[kYZ] - fM[kXZ]*fM[kYY] )*det;
   double detzy = (fM[kXX]*fM[kYZ] - fM[kXZ]*fM[kYX] )*det;
   double detzz = (fM[kXX]*fM[kYY] - fM[kXY]*fM[kYX] )*det;
   SetComponents
      (detxx, -detyx,  detzx, -detxx*fM[kDX]+detyx*fM[kDY]-detzx*fM[kDZ],
       -detxy,  detyy, -detzy,  detxy*fM[kDX]-detyy*fM[kDY]+detzy*fM[kDZ],
       detxz, -detyz,  detzz, -detxz*fM[kDX]+detyz*fM[kDY]-detzz*fM[kDZ]);
}

bool ROOT::Math::Transform3DPJ::operator!= ( const Transform3DPJ &  rhs ) const

inline

Definition at line 467 of file Transform3DPJ.h.

References operator==().

                                                       {
      return ! operator==(rhs);
    }

XYZPoint ROOT::Math::Transform3DPJ::operator()

(

const Point &

p

)

const

Transformation operation for Position Vector in Cartesian coordinate

Definition at line 157 of file Transform3DPJ.cc.

References GetDecomposition(), alignCSCRings::r, and lumiQTWidget::t.

Referenced by operator()(), operator*(), and Transform().

{
   // pass through rotation class (could be implemented directly to be faster)
   
   Rotation3D r;
   XYZVector  t;
   GetDecomposition(r, t);
   XYZPoint pnew = r(p);
   pnew += t;
   return pnew;
}

XYZVector ROOT::Math::Transform3DPJ::operator()

(

const Vector &

v

)

const

Transformation operation for Displacement Vectors in Cartesian coordinate For the Displacement Vectors only the rotation applies - no translations

Definition at line 170 of file Transform3DPJ.cc.

References GetDecomposition(), alignCSCRings::r, and lumiQTWidget::t.

{
   // pass through rotation class ( could be implemented directly to be faster)
   
   Rotation3D r;
   XYZVector  t;
   GetDecomposition(r, t);
   // only rotation
   return r(v);
}

template<class CoordSystem >

PositionVector3D<CoordSystem> ROOT::Math::Transform3DPJ::operator() ( const PositionVector3D< CoordSystem > &  p ) const

inline

Transformation operation for Position Vector in any coordinate system

Definition at line 356 of file Transform3DPJ.h.

References operator()().

                                                                                              { 
      Point xyzNew = operator() ( Point(p) );
      return  PositionVector3D<CoordSystem> (xyzNew);
    }

template<class CoordSystem >

DisplacementVector3D<CoordSystem> ROOT::Math::Transform3DPJ::operator() ( const DisplacementVector3D< CoordSystem > &  v ) const

inline

Transformation operation for Displacement Vector in any coordinate system

Definition at line 365 of file Transform3DPJ.h.

References operator()().

                                                                                                      { 
      Vector xyzNew = operator() ( Vector(v) );
      return  DisplacementVector3D<CoordSystem> (xyzNew);
    }

template<class CoordSystem >

LorentzVector<CoordSystem> ROOT::Math::Transform3DPJ::operator() ( const LorentzVector< CoordSystem > &  q ) const

inline

Transformation operation for a Lorentz Vector in any coordinate system

Definition at line 393 of file Transform3DPJ.h.

References operator()().

                                                                                       { 
      Vector xyzNew = operator() ( Vector(q.Vect() ) );
      return  LorentzVector<CoordSystem> (xyzNew.X(), xyzNew.Y(), xyzNew.Z(), q.E() );
    }

Plane3D ROOT::Math::Transform3DPJ::operator()

(

const Plane3D &

plane

)

const

Transformation on a 3D plane

Definition at line 258 of file Transform3DPJ.cc.

References n, and AlCaHLTBitMon_ParallelJobs::p.

{
   // transformations on a 3D plane
   XYZVector n = plane.Normal();
   // take a point on the plane. Use origin projection on the plane
   // ( -ad, -bd, -cd) if (a**2 + b**2 + c**2 ) = 1
   double d = plane.HesseDistance();
   XYZPoint p( - d * n.X() , - d *n.Y(), -d *n.Z() );
   return Plane3D ( operator() (n), operator() (p) );
}

template<class AVector >

AVector ROOT::Math::Transform3DPJ::operator* ( const AVector &  v ) const

inline

Transformation operation for Vectors. Apply same rules as operator() depending on type of vector. Will work only for DisplacementVector3D, PositionVector3D and LorentzVector

Definition at line 413 of file Transform3DPJ.h.

References operator()().

                                                 { 
      return operator() (v);
    }

Transform3DPJ ROOT::Math::Transform3DPJ::operator* ( const Transform3DPJ &  t ) const

inline

multiply (combine) two transformations

Definition at line 427 of file Transform3DPJ.h.

References lumiQTWidget::t, and tmp.

                                                              { 
      Transform3DPJ tmp(*this);
      tmp*= t;
      return tmp;
    }

Transform3DPJ & ROOT::Math::Transform3DPJ::operator*=

(

const Transform3DPJ &

t

)

multiply (combine) with another transformation in place

Definition at line 181 of file Transform3DPJ.cc.

References fM, kDX, kDY, kDZ, kXX, kXY, kXZ, kYX, kYY, kYZ, kZX, kZY, kZZ, and SetComponents().

{
   // combination of transformations
   
   SetComponents(fM[kXX]*t.fM[kXX]+fM[kXY]*t.fM[kYX]+fM[kXZ]*t.fM[kZX],
                 fM[kXX]*t.fM[kXY]+fM[kXY]*t.fM[kYY]+fM[kXZ]*t.fM[kZY],
                 fM[kXX]*t.fM[kXZ]+fM[kXY]*t.fM[kYZ]+fM[kXZ]*t.fM[kZZ],
                 fM[kXX]*t.fM[kDX]+fM[kXY]*t.fM[kDY]+fM[kXZ]*t.fM[kDZ]+fM[kDX],
                 
                 fM[kYX]*t.fM[kXX]+fM[kYY]*t.fM[kYX]+fM[kYZ]*t.fM[kZX],
                 fM[kYX]*t.fM[kXY]+fM[kYY]*t.fM[kYY]+fM[kYZ]*t.fM[kZY],
                 fM[kYX]*t.fM[kXZ]+fM[kYY]*t.fM[kYZ]+fM[kYZ]*t.fM[kZZ],
                 fM[kYX]*t.fM[kDX]+fM[kYY]*t.fM[kDY]+fM[kYZ]*t.fM[kDZ]+fM[kDY],
                 
                 fM[kZX]*t.fM[kXX]+fM[kZY]*t.fM[kYX]+fM[kZZ]*t.fM[kZX],
                 fM[kZX]*t.fM[kXY]+fM[kZY]*t.fM[kYY]+fM[kZZ]*t.fM[kZY],
                 fM[kZX]*t.fM[kXZ]+fM[kZY]*t.fM[kYZ]+fM[kZZ]*t.fM[kZZ],
                 fM[kZX]*t.fM[kDX]+fM[kZY]*t.fM[kDY]+fM[kZZ]*t.fM[kDZ]+fM[kDZ]);
   
   return *this;
}

template<class ForeignMatrix >

Transform3DPJ& ROOT::Math::Transform3DPJ::operator= ( const ForeignMatrix &  m )

inline

Construct from a linear algebra matrix of size at least 3x4, which must support operator()(i,j) to obtain elements (0,0) thru (2,3). The 3x3 sub-block is assumed to be the rotation part and the translations vector are described by the 4-th column

Definition at line 233 of file Transform3DPJ.h.

References SetComponents().

                                                        { 
      SetComponents(m); 
      return *this; 
    }

bool ROOT::Math::Transform3DPJ::operator== ( const Transform3DPJ &  rhs ) const

inline

Equality/inequality operators

Definition at line 451 of file Transform3DPJ.h.

References fM.

Referenced by operator!=().

                                                       {
      if( fM[0] != rhs.fM[0] )  return false;
      if( fM[1] != rhs.fM[1] )  return false;
      if( fM[2] != rhs.fM[2] )  return false;
      if( fM[3] != rhs.fM[3] )  return false;
      if( fM[4] != rhs.fM[4] )  return false;
      if( fM[5] != rhs.fM[5] )  return false;
      if( fM[6] != rhs.fM[6] )  return false;
      if( fM[7] != rhs.fM[7] )  return false;
      if( fM[8] != rhs.fM[8] )  return false;
      if( fM[9] != rhs.fM[9] )  return false;
      if( fM[10]!= rhs.fM[10] ) return false;
      if( fM[11]!= rhs.fM[11] ) return false;
      return true;
    }

template<class IT >

void ROOT::Math::Transform3DPJ::SetComponents ( IT  begin, IT  end  )

inline

Set the 12 matrix components given an iterator to the start of the desired data, and another to the end (12 past start).

Definition at line 247 of file Transform3DPJ.h.

References begin, fM, and i.

Referenced by Invert(), operator*=(), operator=(), and Transform3DPJ().

                                         {
     for (int i = 0; i <12; ++i) { 
        fM[i] = *begin;
        ++begin; 
     }
     assert (end==begin);
    }

void ROOT::Math::Transform3DPJ::SetComponents ( double  xx, double  xy, double  xz, double  dx, double  yx, double  yy, double  yz, double  dy, double  zx, double  zy, double  zz, double  dz  )

inline

Set the components from 12 scalars

Definition at line 308 of file Transform3DPJ.h.

References fM, kDX, kDY, kDZ, kXX, kXY, kXZ, kYX, kYY, kYZ, kZX, kZY, kZZ, and create_public_lumi_plots::xy.

                                                          {
      fM[kXX]=xx;  fM[kXY]=xy;  fM[kXZ]=xz;  fM[kDX]=dx;
      fM[kYX]=yx;  fM[kYY]=yy;  fM[kYZ]=yz;  fM[kDY]=dy;
      fM[kZX]=zx;  fM[kZY]=zy;  fM[kZZ]=zz;  fM[kDZ]=dz;
    }

void ROOT::Math::Transform3DPJ::SetIdentity ( )

protected

Set identity transformation (identity rotation , zero translation)

Definition at line 203 of file Transform3DPJ.cc.

References fM, kDX, kDY, kDZ, kXX, kXY, kXZ, kYX, kYY, kYZ, kZX, kZY, and kZZ.

Referenced by Transform3DPJ().

{
   //set identity ( identity rotation and zero translation)
   fM[kXX] = 1.0;  fM[kXY] = 0.0; fM[kXZ] = 0.0; fM[kDX] = 0.0;
   fM[kYX] = 0.0;  fM[kYY] = 1.0; fM[kYZ] = 0.0; fM[kDY] = 0.0;
   fM[kZX] = 0.0;  fM[kZY] = 0.0; fM[kZZ] = 1.0; fM[kDZ] = 0.0;
}

template<class ForeignMatrix >

void ROOT::Math::Transform3DPJ::SetTransformMatrix ( const ForeignMatrix &  m )

inline

Set components from a linear algebra matrix of size at least 3x4, which must support operator()(i,j) to obtain elements (0,0) thru (2,3). The 3x3 sub-block is assumed to be the rotation part and the translations vector are described by the 4-th column

Definition at line 284 of file Transform3DPJ.h.

References fM, kDX, kDY, kDZ, kXX, kXY, kXZ, kYX, kYY, kYZ, kZX, kZY, kZZ, and m.

                                                 {
      fM[kXX]=m(0,0);  fM[kXY]=m(0,1);  fM[kXZ]=m(0,2); fM[kDX]=m(0,3);
      fM[kYX]=m(1,0);  fM[kYY]=m(1,1);  fM[kYZ]=m(1,2); fM[kDY]=m(1,3);
      fM[kZX]=m(2,0);  fM[kZY]=m(2,1);  fM[kZZ]=m(2,2); fM[kDZ]=m(2,3);
    }

template<class CoordSystem , class Tag1 , class Tag2 >

void ROOT::Math::Transform3DPJ::Transform ( const PositionVector3D< CoordSystem, Tag1 > &  p1, PositionVector3D< CoordSystem, Tag2 > &  p2  ) const

inline

Transformation operation for points between different coordinate system tags

Definition at line 374 of file Transform3DPJ.h.

References operator()().

                                                                                                                      { 
      Point xyzNew = operator() ( Point(p1.X(), p1.Y(), p1.Z()) );
      p2.SetXYZ( xyzNew.X(), xyzNew.Y(), xyzNew.Z() ); 
    }

template<class CoordSystem , class Tag1 , class Tag2 >

void ROOT::Math::Transform3DPJ::Transform ( const DisplacementVector3D< CoordSystem, Tag1 > &  v1, DisplacementVector3D< CoordSystem, Tag2 > &  v2  ) const

inline

Transformation operation for Displacement Vector of different coordinate systems

Definition at line 384 of file Transform3DPJ.h.

References operator()().

                                                                                                                              { 
      Vector xyzNew = operator() ( Vector(v1.X(), v1.Y(), v1.Z() ) );
      v2.SetXYZ( xyzNew.X(), xyzNew.Y(), xyzNew.Z() ); 
    }

Member Data Documentation

double ROOT::Math::Transform3DPJ::fM[12]

private

Definition at line 497 of file Transform3DPJ.h.

Referenced by AssignFrom(), GetComponents(), GetDecomposition(), GetTransformMatrix(), Invert(), operator*=(), operator==(), SetComponents(), SetIdentity(), and SetTransformMatrix().