Transform3DPJ.h

Go to the documentation of this file.

// @(#)root/mathcore:$Name: V02-02-29 $:$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 "Math/GenVector/Plane3D.h"
 
#include <iostream>
 
//#include "Math/Vector3Dfwd.h"
 
namespace ROOT {
 
  namespace Math {
 
    using ROOT::Math::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 */