Rotation3DxAxial.cxx

Go to the documentation of this file.

// @(#)root/mathcore:$Id$
// Authors: W. Brown, M. Fischler, L. Moneta    2005
 
#include "MathX/GenVectorX/Rotation3D.h"
 
#include "MathX/GenVectorX/RotationX.h"
#include "MathX/GenVectorX/RotationY.h"
#include "MathX/GenVectorX/RotationZ.h"
 
#include "MathX/GenVectorX/AccHeaders.h"
 
#include "MathX/GenVectorX/MathHeaders.h"
 
namespace ROOT {
 
namespace ROOT_MATH_ARCH {
 
Rotation3D Rotation3D::operator*(const RotationX &rx) const
{
   // combination of a Rotation3D with a RotationX
   Scalar s = rx.SinAngle();
   Scalar c = rx.CosAngle();
   return Rotation3D(fM[kXX], fM[kXY] * c + fM[kXZ] * s, fM[kXZ] * c - fM[kXY] * s, fM[kYX], fM[kYY] * c + fM[kYZ] * s,
                     fM[kYZ] * c - fM[kYY] * s, fM[kZX], fM[kZY] * c + fM[kZZ] * s, fM[kZZ] * c - fM[kZY] * s);
}
 
Rotation3D Rotation3D::operator*(const RotationY &ry) const
{
   // combination of a Rotation3D with a RotationY
   Scalar s = ry.SinAngle();
   Scalar c = ry.CosAngle();
   return Rotation3D(fM[kXX] * c - fM[kXZ] * s, fM[kXY], fM[kXX] * s + fM[kXZ] * c, fM[kYX] * c - fM[kYZ] * s, fM[kYY],
                     fM[kYX] * s + fM[kYZ] * c, fM[kZX] * c - fM[kZZ] * s, fM[kZY], fM[kZX] * s + fM[kZZ] * c);
}
 
Rotation3D Rotation3D::operator*(const RotationZ &rz) const
{
   // combination of a Rotation3D with a RotationZ
   Scalar s = rz.SinAngle();
   Scalar c = rz.CosAngle();
   return Rotation3D(fM[kXX] * c + fM[kXY] * s, fM[kXY] * c - fM[kXX] * s, fM[kXZ], fM[kYX] * c + fM[kYY] * s,
                     fM[kYY] * c - fM[kYX] * s, fM[kYZ], fM[kZX] * c + fM[kZY] * s, fM[kZY] * c - fM[kZX] * s, fM[kZZ]);
}
 
Rotation3D operator*(RotationX const &r1, Rotation3D const &r2)
{
   // combination of a RotationX with a Rotation3D
   // TODO -- recode for much better efficiency!
   return Rotation3D(r1) * r2;
}
 
Rotation3D operator*(RotationY const &r1, Rotation3D const &r2)
{
   // combination of a RotationY with a Rotation3D
   // TODO -- recode for much better efficiency!
   return Rotation3D(r1) * r2;
}
 
Rotation3D operator*(RotationZ const &r1, Rotation3D const &r2)
{
   // combination of a RotationZ with a Rotation3D
   // TODO -- recode for much better efficiency!
   return Rotation3D(r1) * r2;
}
 
typedef Rotation3D::Scalar Scalar;
 
// Rx * Ry
Rotation3D operator*(RotationX const &rx, RotationY const &ry)
{
   Scalar sx = rx.SinAngle();
   Scalar cx = rx.CosAngle();
   Scalar sy = ry.SinAngle();
   Scalar cy = ry.CosAngle();
   return Rotation3D(cy, 0, sy, sx * sy, cx, -sx * cy, -sy * cx, sx, cx * cy);
}
 
// Rx * Rz
Rotation3D operator*(RotationX const &rx, RotationZ const &rz)
{
   Scalar sx = rx.SinAngle();
   Scalar cx = rx.CosAngle();
   Scalar sz = rz.SinAngle();
   Scalar cz = rz.CosAngle();
   return Rotation3D(cz, -sz, 0, cx * sz, cx * cz, -sx, sx * sz, cz * sx, cx);
}
 
// Ry * Rx
Rotation3D operator*(RotationY const &ry, RotationX const &rx)
{
   Scalar sx = rx.SinAngle();
   Scalar cx = rx.CosAngle();
   Scalar sy = ry.SinAngle();
   Scalar cy = ry.CosAngle();
   return Rotation3D(cy, sx * sy, sy * cx, 0, cx, -sx, -sy, cy * sx, cx * cy);
}
 
// Ry * Rz
Rotation3D operator*(RotationY const &ry, RotationZ const &rz)
{
   Scalar sy = ry.SinAngle();
   Scalar cy = ry.CosAngle();
   Scalar sz = rz.SinAngle();
   Scalar cz = rz.CosAngle();
   return Rotation3D(cy * cz, -cy * sz, sy, sz, cz, 0, -cz * sy, sy * sz, cy);
}
 
// Rz * Rx
Rotation3D operator*(RotationZ const &rz, RotationX const &rx)
{
   Scalar sx = rx.SinAngle();
   Scalar cx = rx.CosAngle();
   Scalar sz = rz.SinAngle();
   Scalar cz = rz.CosAngle();
   return Rotation3D(cz, -cx * sz, sx * sz, sz, cx * cz, -cz * sx, 0, sx, cx);
}
 
// Rz * Ry
Rotation3D operator*(RotationZ const &rz, RotationY const &ry)
{
   Scalar sy = ry.SinAngle();
   Scalar cy = ry.CosAngle();
   Scalar sz = rz.SinAngle();
   Scalar cz = rz.CosAngle();
   return Rotation3D(cy * cz, -sz, cz * sy, cy * sz, cz, sy * sz, -sy, 0, cy);
}
 
} // namespace ROOT_MATH_ARCH
} // namespace ROOT