CLHEP/Vector/Rotation.icc

0001 // -*- C++ -*-
0002 // $Id: Rotation.icc,v 1.2 2003/10/10 21:42:35 garren Exp $
0003 // ---------------------------------------------------------------------------
0004 //
0005 // This file is a part of the CLHEP - a Class Library for High Energy Physics.
0006 //
0007 // This is the definitions of the inline member functions of the
0008 // HepRotation class
0009 //
0010
0011 namespace CLHEP {
0012
0013 // Put commonly used accessors as early as possible to avoid inlining misses:
0014
0015 inline double HepRotation::xx() const { return rxx; }
0016 inline double HepRotation::xy() const { return rxy; }
0017 inline double HepRotation::xz() const { return rxz; }
0018 inline double HepRotation::yx() const { return ryx; }
0019 inline double HepRotation::yy() const { return ryy; }
0020 inline double HepRotation::yz() const { return ryz; }
0021 inline double HepRotation::zx() const { return rzx; }
0022 inline double HepRotation::zy() const { return rzy; }
0023 inline double HepRotation::zz() const { return rzz; }
0024
0025 inline HepRep3x3 HepRotation::rep3x3() const {
0026   return HepRep3x3 ( rxx, rxy, rxz,
0027              ryx, ryy, ryz,
0028              rzx, rzy, rzz );
0029 }
0030
0031 inline double HepRotation::xt() const { return 0.0; }
0032 inline double HepRotation::yt() const { return 0.0; }
0033 inline double HepRotation::zt() const { return 0.0; }
0034 inline double HepRotation::tx() const { return 0.0; }
0035 inline double HepRotation::ty() const { return 0.0; }
0036 inline double HepRotation::tz() const { return 0.0; }
0037 inline double HepRotation::tt() const { return 1.0; }
0038
0039 inline HepRep4x4 HepRotation::rep4x4() const {
0040   return HepRep4x4 ( rxx, rxy, rxz, 0.0,
0041              ryx, ryy, ryz, 0.0,
0042              rzx, rzy, rzz, 0.0,
0043              0.0, 0.0, 0.0, 1.0 );
0044 }
0045
0046 // Ctors etc:
0047
0048 inline HepRotation::HepRotation() : rxx(1.0), rxy(0.0), rxz(0.0),
0049                     ryx(0.0), ryy(1.0), ryz(0.0),
0050                     rzx(0.0), rzy(0.0), rzz(1.0) {}
0051
0052 inline HepRotation::HepRotation(const HepRotation & m1) :
0053     rxx(m1.rxx), rxy(m1.rxy), rxz(m1.rxz),
0054     ryx(m1.ryx), ryy(m1.ryy), ryz(m1.ryz),
0055     rzx(m1.rzx), rzy(m1.rzy), rzz(m1.rzz) {}
0056
0057 inline HepRotation::HepRotation
0058             (double mxx, double mxy, double mxz,
0059              double myx, double myy, double myz,
0060              double mzx, double mzy, double mzz) :
0061     rxx(mxx), rxy(mxy), rxz(mxz),
0062     ryx(myx), ryy(myy), ryz(myz),
0063     rzx(mzx), rzy(mzy), rzz(mzz) {}
0064
0065 inline HepRotation::HepRotation ( const HepRep3x3 & m1 ) :
0066     rxx(m1.xx_), rxy(m1.xy_), rxz(m1.xz_),
0067     ryx(m1.yx_), ryy(m1.yy_), ryz(m1.yz_),
0068     rzx(m1.zx_), rzy(m1.zy_), rzz(m1.zz_) {}
0069
0070 inline HepRotation::HepRotation(const HepRotationX & rx) :
0071     rxx(1.0), rxy(0.0),     rxz(0.0),
0072     ryx(0.0), ryy(rx.yy()), ryz(rx.yz()),
0073     rzx(0.0), rzy(rx.zy()), rzz(rx.zz()) {}
0074
0075 inline HepRotation::HepRotation(const HepRotationY & ry) :
0076     rxx(ry.xx()), rxy(0.0), rxz(ry.xz()),
0077     ryx(0.0),     ryy(1.0), ryz(0.0),
0078     rzx(ry.zx()), rzy(0.0), rzz(ry.zz()) {}
0079
0080 inline HepRotation::HepRotation(const HepRotationZ & rz) :
0081     rxx(rz.xx()), rxy(rz.xy()), rxz(0.0),
0082     ryx(rz.yx()), ryy(rz.yy()), ryz(0.0),
0083     rzx(0.0),     rzy(0.0),     rzz(1.0) {}
0084
0085 inline HepRotation::~HepRotation() {}
0086
0087 // More accessors:
0088
0089 inline HepRotation::HepRotation_row::HepRotation_row
0090 (const HepRotation & r, int i) : rr(r), ii(i) {}
0091
0092 inline double HepRotation::HepRotation_row::operator [] (int jj) const {
0093   return rr(ii,jj);
0094 }
0095
0096 inline
0097 const HepRotation::HepRotation_row HepRotation::operator [] (int i) const {
0098   return HepRotation_row(*this, i);
0099 }
0100
0101 inline Hep3Vector HepRotation::colX() const
0102                 { return Hep3Vector ( rxx, ryx, rzx ); }
0103 inline Hep3Vector HepRotation::colY() const
0104                 { return Hep3Vector ( rxy, ryy, rzy ); }
0105 inline Hep3Vector HepRotation::colZ() const
0106                 { return Hep3Vector ( rxz, ryz, rzz ); }
0107
0108 inline Hep3Vector HepRotation::rowX() const
0109                 { return Hep3Vector ( rxx, rxy, rxz ); }
0110 inline Hep3Vector HepRotation::rowY() const
0111                 { return Hep3Vector ( ryx, ryy, ryz ); }
0112 inline Hep3Vector HepRotation::rowZ() const
0113                 { return Hep3Vector ( rzx, rzy, rzz ); }
0114
0115 inline HepLorentzVector HepRotation::col1() const
0116                 { return HepLorentzVector (colX(), 0); }
0117 inline HepLorentzVector HepRotation::col2() const
0118                 { return HepLorentzVector (colY(), 0); }
0119 inline HepLorentzVector HepRotation::col3() const
0120                 { return HepLorentzVector (colZ(), 0); }
0121 inline HepLorentzVector HepRotation::col4() const
0122                 { return HepLorentzVector (0,0,0,1); }
0123 inline HepLorentzVector HepRotation::row1() const
0124                 { return HepLorentzVector (rowX(), 0); }
0125 inline HepLorentzVector HepRotation::row2() const
0126                 { return HepLorentzVector (rowY(), 0); }
0127 inline HepLorentzVector HepRotation::row3() const
0128                 { return HepLorentzVector (rowZ(), 0); }
0129 inline HepLorentzVector HepRotation::row4() const
0130                 { return HepLorentzVector (0,0,0,1); }
0131
0132 inline double  HepRotation::getPhi  () const { return phi();   }
0133 inline double  HepRotation::getTheta() const { return theta(); }
0134 inline double  HepRotation::getPsi  () const { return psi();   }
0135 inline double  HepRotation::getDelta() const { return delta(); }
0136 inline Hep3Vector HepRotation::getAxis () const { return axis();  }
0137
0138 inline HepRotation & HepRotation::operator = (const HepRotation & m1) {
0139   rxx = m1.rxx;
0140   rxy = m1.rxy;
0141   rxz = m1.rxz;
0142   ryx = m1.ryx;
0143   ryy = m1.ryy;
0144   ryz = m1.ryz;
0145   rzx = m1.rzx;
0146   rzy = m1.rzy;
0147   rzz = m1.rzz;
0148   return *this;
0149 }
0150
0151 inline HepRotation & HepRotation::set(const HepRep3x3 & m1) {
0152   rxx = m1.xx_;
0153   rxy = m1.xy_;
0154   rxz = m1.xz_;
0155   ryx = m1.yx_;
0156   ryy = m1.yy_;
0157   ryz = m1.yz_;
0158   rzx = m1.zx_;
0159   rzy = m1.zy_;
0160   rzz = m1.zz_;
0161   return *this;
0162 }
0163
0164 inline HepRotation & HepRotation::set(const HepRotationX & r) {
0165   return (set (r.rep3x3()));
0166 }
0167 inline HepRotation & HepRotation::set(const HepRotationY & r) {
0168   return (set (r.rep3x3()));
0169 }
0170 inline HepRotation & HepRotation::set(const HepRotationZ & r) {
0171   return (set (r.rep3x3()));
0172 }
0173
0174 inline HepRotation & HepRotation::operator= (const HepRotationX & r) {
0175   return (set (r.rep3x3()));
0176 }
0177 inline HepRotation & HepRotation::operator= (const HepRotationY & r) {
0178   return (set (r.rep3x3()));
0179 }
0180 inline HepRotation & HepRotation::operator= (const HepRotationZ & r) {
0181   return (set (r.rep3x3()));
0182 }
0183
0184 inline Hep3Vector HepRotation::operator * (const Hep3Vector & p) const {
0185   return Hep3Vector(rxx*p.x() + rxy*p.y() + rxz*p.z(),
0186                     ryx*p.x() + ryy*p.y() + ryz*p.z(),
0187                     rzx*p.x() + rzy*p.y() + rzz*p.z());
0188 //  This is identical to the code in the CLHEP 1.6 version
0189 }
0190
0191 inline Hep3Vector HepRotation::operator () (const Hep3Vector & p) const {
0192   double x = p.x();
0193   double y = p.y();
0194   double z = p.z();
0195   return Hep3Vector(rxx*x + rxy*y + rxz*z,
0196                     ryx*x + ryy*y + ryz*z,
0197                     rzx*x + rzy*y + rzz*z);
0198 }
0199
0200 inline HepLorentzVector
0201 HepRotation::operator () (const HepLorentzVector & w) const {
0202   return HepLorentzVector( operator() (w.vect()), w.t() );
0203 }
0204
0205 inline HepLorentzVector HepRotation::operator *
0206                     (const HepLorentzVector & p) const {
0207   return operator()(p);
0208 }
0209
0210 inline HepRotation HepRotation::operator* (const HepRotation & r) const {
0211   return HepRotation(rxx*r.rxx + rxy*r.ryx + rxz*r.rzx,
0212                      rxx*r.rxy + rxy*r.ryy + rxz*r.rzy,
0213                      rxx*r.rxz + rxy*r.ryz + rxz*r.rzz,
0214                      ryx*r.rxx + ryy*r.ryx + ryz*r.rzx,
0215                      ryx*r.rxy + ryy*r.ryy + ryz*r.rzy,
0216                      ryx*r.rxz + ryy*r.ryz + ryz*r.rzz,
0217                      rzx*r.rxx + rzy*r.ryx + rzz*r.rzx,
0218                      rzx*r.rxy + rzy*r.ryy + rzz*r.rzy,
0219                      rzx*r.rxz + rzy*r.ryz + rzz*r.rzz );
0220 }
0221
0222 inline HepRotation HepRotation::operator * (const HepRotationX & rx) const {
0223   double yy1 = rx.yy();
0224   double yz1 = rx.yz();
0225   double zy1 = -yz1;
0226   double zz1 =  yy1;
0227   return HepRotation(
0228     rxx,   rxy*yy1 + rxz*zy1,   rxy*yz1 + rxz*zz1,
0229     ryx,   ryy*yy1 + ryz*zy1,   ryy*yz1 + ryz*zz1,
0230     rzx,   rzy*yy1 + rzz*zy1,   rzy*yz1 + rzz*zz1 );
0231 }
0232
0233 inline HepRotation HepRotation::operator * (const HepRotationY & ry) const {
0234   double xx1 = ry.xx();
0235   double xz1 = ry.xz();
0236   double zx1 = -xz1;
0237   double zz1 =  xx1;
0238   return HepRotation(
0239     rxx*xx1 + rxz*zx1,   rxy,   rxx*xz1 + rxz*zz1,
0240     ryx*xx1 + ryz*zx1,   ryy,   ryx*xz1 + ryz*zz1,
0241     rzx*xx1 + rzz*zx1,   rzy,   rzx*xz1 + rzz*zz1 );
0242 }
0243
0244 inline HepRotation HepRotation::operator * (const HepRotationZ & rz) const {
0245   double xx1 = rz.xx();
0246   double xy1 = rz.xy();
0247   double yx1 = -xy1;
0248   double yy1 =  xx1;
0249   return HepRotation(
0250     rxx*xx1 + rxy*yx1,   rxx*xy1 + rxy*yy1,   rxz,
0251     ryx*xx1 + ryy*yx1,   ryx*xy1 + ryy*yy1,   ryz,
0252     rzx*xx1 + rzy*yx1,   rzx*xy1 + rzy*yy1,   rzz );
0253 }
0254
0255
0256 inline HepRotation & HepRotation::operator *= (const HepRotation & r) {
0257   return *this = (*this) * (r);
0258 }
0259
0260 inline HepRotation & HepRotation::operator *= (const HepRotationX & r) {
0261   return *this = (*this) * (r); }
0262 inline HepRotation & HepRotation::operator *= (const HepRotationY & r) {
0263   return *this = (*this) * (r); }
0264 inline HepRotation & HepRotation::operator *= (const HepRotationZ & r) {
0265   return *this = (*this) * (r); }
0266
0267 inline HepRotation & HepRotation::transform(const HepRotation & r) {
0268   return *this = r * (*this);
0269 }
0270
0271 inline HepRotation & HepRotation::transform(const HepRotationX & r) {
0272   return *this = r * (*this); }
0273 inline HepRotation & HepRotation::transform(const HepRotationY & r) {
0274   return *this = r * (*this); }
0275 inline HepRotation & HepRotation::transform(const HepRotationZ & r) {
0276   return *this = r * (*this); }
0277
0278 inline HepRotation HepRotation::inverse() const {
0279   return HepRotation( rxx, ryx, rzx,
0280               rxy, ryy, rzy,
0281               rxz, ryz, rzz );
0282 }
0283
0284 inline HepRotation inverseOf (const HepRotation & r) {
0285   return r.inverse();
0286 }
0287
0288 inline HepRotation & HepRotation::invert() {
0289   return *this=inverse();
0290 }
0291
0292 inline HepRotation & HepRotation::rotate
0293                 (double ddelta, const Hep3Vector * p) {
0294   return rotate(ddelta, *p);
0295 }
0296
0297 inline bool HepRotation::operator== ( const HepRotation & r ) const {
0298   return ( rxx==r.rxx && rxy==r.rxy && rxz==r.rxz &&
0299        ryx==r.ryx && ryy==r.ryy && ryz==r.ryz &&
0300        rzx==r.rzx && rzy==r.rzy && rzz==r.rzz );
0301 }
0302 inline bool HepRotation::operator!= ( const HepRotation & r ) const {
0303   return ! operator==(r);
0304 }
0305 inline bool HepRotation::operator< ( const HepRotation & r ) const
0306     { return compare(r)< 0; }
0307 inline bool HepRotation::operator<=( const HepRotation & r ) const
0308     { return compare(r)<=0; }
0309 inline bool HepRotation::operator>=( const HepRotation & r ) const
0310     { return compare(r)>=0; }
0311 inline bool HepRotation::operator> ( const HepRotation & r ) const
0312     { return compare(r)> 0; }
0313
0314 inline double HepRotation::getTolerance() {
0315   return Hep4RotationInterface::tolerance;
0316 }
0317 inline double HepRotation::setTolerance(double tol) {
0318   return Hep4RotationInterface::setTolerance(tol);
0319 }
0320
0321 inline HepRotation operator * (const HepRotationX & rx, const HepRotation & r){
0322   HepRep3x3 mmm = r.rep3x3();
0323   double c = rx.yy();
0324   double ss = rx.zy();
0325   return HepRotation (        mmm.xx_,           mmm.xy_,          mmm.xz_,
0326                         c*mmm.yx_-ss*mmm.zx_, c*mmm.yy_-ss*mmm.zy_, c*mmm.yz_-ss*mmm.zz_,
0327                         ss*mmm.yx_+c*mmm.zx_, ss*mmm.yy_+c*mmm.zy_, ss*mmm.yz_+c*mmm.zz_ );
0328 }
0329
0330 inline HepRotation operator * (const HepRotationY & ry, const HepRotation & r){
0331   HepRep3x3 mmm = r.rep3x3();
0332   double c = ry.xx();
0333   double ss = ry.xz();
0334   return HepRotation (  c*mmm.xx_+ss*mmm.zx_, c*mmm.xy_+ss*mmm.zy_, c*mmm.xz_+ss*mmm.zz_,
0335                               mmm.yx_,           mmm.yy_,          mmm.yz_,
0336                        -ss*mmm.xx_+c*mmm.zx_,-ss*mmm.xy_+c*mmm.zy_,-ss*mmm.xz_+c*mmm.zz_ );
0337 }
0338
0339 inline HepRotation operator * (const HepRotationZ & rz, const HepRotation & r){
0340   HepRep3x3 mmm = r.rep3x3();
0341   double c = rz.xx();
0342   double ss = rz.yx();
0343   return HepRotation (  c*mmm.xx_-ss*mmm.yx_, c*mmm.xy_-ss*mmm.yy_, c*mmm.xz_-ss*mmm.yz_,
0344                         ss*mmm.xx_+c*mmm.yx_, ss*mmm.xy_+c*mmm.yy_, ss*mmm.xz_+c*mmm.yz_,
0345                               mmm.zx_,           mmm.zy_,          mmm.zz_       );
0346 }
0347
0348 }  // namespace CLHEP