Transform3DPJ.h

Go to the documentation of this file.

// @(#)root/mathcore:$Name: CMSSW_5_3_11_patch3 $:$Id: Transform3DPJ.h,v 1.1 2007/05/27 20:12:30 pjanot Exp $
// Authors: W. Brown, M. Fischler, L. Moneta    2005  

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2005 , LCG ROOT MathLib Team                         *
 *                                                                    *
 *                                                                    *
 **********************************************************************/

// Header file for class Transform3DPJ
// 
// Created by: Lorenzo Moneta  October 21 2005
// 
// 
#ifndef ROOT_Math_GenVector_Transform3DPJ 
#define ROOT_Math_GenVector_Transform3DPJ  1



#include "Math/GenVector/Cartesian3D.h"
#include "Math/GenVector/DisplacementVector3D.h"
#include "Math/GenVector/PositionVector3D.h"
#include "Math/GenVector/LorentzVector.h"
#include "Math/GenVector/Rotation3D.h"
#include "Math/GenVector/AxisAnglefwd.h"
#include "Math/GenVector/EulerAnglesfwd.h"
#include "Math/GenVector/Quaternionfwd.h"
#include "Math/GenVector/RotationXfwd.h"
#include "Math/GenVector/RotationYfwd.h"
#include "Math/GenVector/RotationZfwd.h"

#include <iostream>

//#include "Math/Vector3Dfwd.h"



namespace ROOT { 

  namespace Math { 

    class Plane3D; 



  class Transform3DPJ { 
    

  public: 

    typedef  DisplacementVector3D<Cartesian3D<double>, DefaultCoordinateSystemTag >  Vector; 
    typedef  PositionVector3D<Cartesian3D<double>, DefaultCoordinateSystemTag >      Point; 


    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
    };



    Transform3DPJ()
    {
      SetIdentity();
    }
    
    template<class IT>
    Transform3DPJ(IT begin, IT end) 
    { 
      SetComponents(begin,end); 
    }

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

    explicit Transform3DPJ( const Rotation3D & r) { 
      AssignFrom(r);
    } 
    // convenience methods for the other rotations (cannot use templates for conflict with LA)
    explicit Transform3DPJ( const AxisAngle & r) { 
      AssignFrom(Rotation3D(r));
    } 
    explicit Transform3DPJ( const EulerAngles & r) { 
      AssignFrom(Rotation3D(r));
    } 
    explicit Transform3DPJ( const Quaternion & r) { 
      AssignFrom(Rotation3D(r));
    } 
    // TO DO: implement direct methods for axial rotations without going through Rotation3D
    explicit Transform3DPJ( const RotationX & r) { 
      AssignFrom(Rotation3D(r));
    } 
    explicit Transform3DPJ( const RotationY & r) { 
      AssignFrom(Rotation3D(r));
    } 
    explicit Transform3DPJ( const RotationZ & r) { 
      AssignFrom(Rotation3D(r));
    } 

    template<class CoordSystem, class Tag>
    explicit Transform3DPJ( const DisplacementVector3D<CoordSystem,Tag> & v) { 
      AssignFrom(Vector(v.X(),v.Y(),v.Z()));
    }
    explicit Transform3DPJ( const Vector & v) { 
      AssignFrom(v);
    }



    //#if !defined(__MAKECINT__) && !defined(G__DICTIONARY)  // this is ambigous with double * , double *   
    // to do : change to displacement vector3D
    template <class ARotation, class CoordSystem, class Tag>
    Transform3DPJ( const ARotation & r, const DisplacementVector3D<CoordSystem,Tag> & v) 
    {
      AssignFrom( Rotation3D(r), Vector (v.X(),v.Y(),v.Z()) ); 
    }
    template <class ARotation, class CoordSystem, class Tag>
    Transform3DPJ(const DisplacementVector3D<CoordSystem,Tag> & v , const ARotation & r) 
    {
      // 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()) ) ); 
    }

    //#endif

    Transform3DPJ
    (const Point & fr0, const Point & fr1, const Point & fr2,  
     const Point & to0, const Point & to1, const Point & to2 );  


    // use compiler generated copy ctor, copy assignmet and dtor

    template<class ForeignMatrix>
    explicit Transform3DPJ(const ForeignMatrix & m) { 
      SetComponents(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)
    {
      SetComponents (xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
    }


    template<class ForeignMatrix>
    Transform3DPJ & operator= (const ForeignMatrix & m) { 
      SetComponents(m); 
      return *this; 
    }


    // ======== Components ==============


    template<class IT>
    void SetComponents(IT begin, IT end) {
     for (int i = 0; i <12; ++i) { 
        fM[i] = *begin;
        ++begin; 
     }
     assert (end==begin);
    }

    template<class IT>
    void GetComponents(IT begin, IT end) const {
       for (int i = 0; i <12; ++i) { 
          *begin = fM[i];
          ++begin;  
       }
       assert (end==begin);
    }

    template<class IT>
    void GetComponents(IT begin) const {
      std::copy ( fM, fM+12, begin );
    }

    template<class ForeignMatrix>
    void
    SetTransformMatrix (const ForeignMatrix & 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 ForeignMatrix>
    void
    GetTransformMatrix (ForeignMatrix & m) const {
      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];
    }


    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) {
      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
    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 {
      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 GetDecomposition(Rotation3D &r, Vector &v) const;



    // operations on points and vectors 

    Point operator() (const Point & p) const;  


    Vector operator() (const Vector & v) const;


    template<class CoordSystem > 
    PositionVector3D<CoordSystem> operator() (const PositionVector3D <CoordSystem> & p) const { 
      Point xyzNew = operator() ( Point(p) );
      return  PositionVector3D<CoordSystem> (xyzNew);
    }

    template<class CoordSystem > 
    DisplacementVector3D<CoordSystem> operator() (const DisplacementVector3D <CoordSystem> & v) const { 
      Vector xyzNew = operator() ( Vector(v) );
      return  DisplacementVector3D<CoordSystem> (xyzNew);
    }

    template<class CoordSystem, class Tag1, class Tag2 > 
    void Transform (const PositionVector3D <CoordSystem,Tag1> & p1, PositionVector3D <CoordSystem,Tag2> & p2  ) const { 
      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 Transform (const DisplacementVector3D <CoordSystem,Tag1> & v1, DisplacementVector3D <CoordSystem,Tag2> & v2  ) const { 
      Vector xyzNew = operator() ( Vector(v1.X(), v1.Y(), v1.Z() ) );
      v2.SetXYZ( xyzNew.X(), xyzNew.Y(), xyzNew.Z() ); 
    }

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

    Plane3D operator() (const Plane3D & plane) const; 
          

    // skip transformation for arbitrary vectors - not really defined if point or displacement vectors

    // same but with operator * 
    template<class AVector > 
    AVector operator * (const AVector & v) const { 
      return operator() (v);
    }



    Transform3DPJ & operator *= (const Transform3DPJ  & t);

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

    void Invert();

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


    bool operator == (const Transform3DPJ & rhs) const {
      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;
    }

    bool operator != (const Transform3DPJ & rhs) const {
      return ! operator==(rhs);
    }


  protected: 

    void  AssignFrom( const Rotation3D & r, const Vector & v);  

    void  AssignFrom( const Rotation3D & r);  

    void  AssignFrom( const Vector & v);  

    void SetIdentity() ; 

  private: 


    double fM[12];

  };


    // global functions 

  // TODO - I/O should be put in the manipulator form 

    std::ostream & operator<< (std::ostream & os, const Transform3DPJ & t);
  
    // need a function Transform = Translation * Rotation ???

   




  } // end namespace Math

} // end namespace ROOT


#endif /* MATHCORE_BASIC3DTRANSFORMATION */