PWG2/FEMTOSCOPY/AliFemto/AliFemtoLorentzVector.h

   1 /***************************************************************************
   2  *
   3  * $Id$
   4  *
   5  * Author: Brian Lasiuk, Thomas Ullrich, April 1998
   6  ***************************************************************************
   7  *
   8  * Description:
   9  *
  10  * Remarks:   Since not all compilers support member templates
  11  *            we have to specialize the templated member on these
  12  *            platforms. If member templates are not supported the
  13  *            ST_NO_MEMBER_TEMPLATES flag has to be set. tu.
  14  *
  15  *            In the near future when all compilers can handle member
  16  *            templates this class should be cleaned up. A lot of
  17  *            redundant code can be removed as soon as the compilers
  18  *            are up-to-date. tu
  19  *
  20  ***************************************************************************
  21  *
  22  * $Log$
  23  * Revision 1.1.1.1  2007/04/25 15:38:41  panos
  24  * Importing the HBT code dir
  25  *
  26  * Revision 1.1.1.1  2007/03/07 10:14:49  mchojnacki
  27  * First version on CVS
  28  *
  29  * Revision 1.11  2005/09/22 20:09:20  fisyak
  30  * Make AliFemtoLorentzVector persistent
  31  *
  32  * Revision 1.10  2005/07/06 18:49:56  fisyak
  33  * Replace AliFemtoHelixD, AliFemtoLorentzVectorD,AliFemtoLorentzVectorF,AliFemtoMatrixD,AliFemtoMatrixF,AliFemtoPhysicalHelixD,AliFemtoThreeVectorD,AliFemtoThreeVectorF by templated version
  34  *
  35  * Revision 1.9  2005/03/28 06:02:45  perev
  36  * Defence FPE added
  37  *
  38  * Revision 1.8  2003/09/02 17:59:35  perev
  39  * gcc 3.2 updates + WarnOff
  40  *
  41  * Revision 1.7  2003/05/01 19:24:31  ullrich
  42  * Corrected problem in boost().
  43  *
  44  * Revision 1.6  1999/10/15 15:56:36  ullrich
  45  * Changed output format in operator<<, added operator>>
  46  *
  47  * Revision 1.5  1999/06/04 18:01:36  ullrich
  48  * New operators operator() and operator[] which can be used
  49  * as lvalues.
  50  *
  51  * Revision 1.4  1999/04/14 23:12:07  fisyak
  52  * Add __CINT__ to handle references
  53  *
  54  * Revision 1.3  1999/02/17 11:38:36  ullrich
  55  * Removed specialization for 'long double'.
  56  *
  57  * Revision 1.2  1999/02/14 23:11:42  fisyak
  58  * Fixes for Rootcint
  59  *
  60  * Revision 1.1  1999/01/30 03:59:02  fisyak
  61  * Root Version of AliFemtoarClassLibrary
  62  *
  63  * Revision 1.1  1999/01/23 00:27:52  ullrich
  64  * Initial Revision
  65  *
  66  **************************************************************************/
  67 /*//
  68 //// General class for a Lorentz four-vector
  69 ///*/
  70 #ifndef ST_LORENTZ_VECTOR_HH
  71 #define ST_LORENTZ_VECTOR_HH
  72
  73 #include "AliFemtoThreeVector.h"
  74 template<class T> class AliFemtoLorentzVector {
  75 public:
  76     AliFemtoLorentzVector(T = 0, T = 0, T = 0, T = 0);
  77     virtual ~AliFemtoLorentzVector();
  78
  79 #ifndef ST_NO_MEMBER_TEMPLATES
  80     template<class X> AliFemtoLorentzVector(const AliFemtoThreeVector<X>&, T);
  81     template<class X> AliFemtoLorentzVector(T, const AliFemtoThreeVector<X>&);
  82
  83     template<class X> AliFemtoLorentzVector(const AliFemtoLorentzVector<X>&);
  84     template<class X> AliFemtoLorentzVector<T>& operator=(const AliFemtoLorentzVector<X>&);
  85     // AliFemtoLorentzVector(const AliFemtoLorentzVector<T>&);                use default
  86     // AliFemtoLorentzVector<T>& operator=(const AliFemtoLorentzVector<T>&);  use default
  87 #else
  88     AliFemtoLorentzVector(const AliFemtoThreeVector<float>&, T);
  89     AliFemtoLorentzVector(T, const AliFemtoThreeVector<float>&);
  90     AliFemtoLorentzVector(const AliFemtoLorentzVector<float>&);
  91
  92     AliFemtoLorentzVector(const AliFemtoThreeVector<double>&, T);
  93     AliFemtoLorentzVector(T, const AliFemtoThreeVector<double>&);
  94     AliFemtoLorentzVector(const AliFemtoLorentzVector<double>&);
  95
  96     AliFemtoLorentzVector<T>& operator=(const AliFemtoLorentzVector<float>&);
  97     AliFemtoLorentzVector<T>& operator=(const AliFemtoLorentzVector<double>&);
  98 #endif
  99
 100     T x()                     const;
 101     T y()                     const;
 102     T z()                     const;
 103     T t()                     const;
 104     T px()                    const;
 105     T py()                    const;
 106     T pz()                    const;
 107     T e()                     const;
 108     T operator()  (size_t)    const;
 109     T operator[]  (size_t)    const;
 110
 111     T& operator()  (size_t);
 112     T& operator[]  (size_t);
 113
 114     const AliFemtoThreeVector<T>& vect() const;
 115
 116     void SetX(T);
 117     void SetY(T);
 118     void SetZ(T);
 119     void SetPx(T);
 120     void SetPy(T);
 121     void SetPz(T);
 122     void SetE(T);
 123     void SetT(T);
 124
 125 #ifndef ST_NO_MEMBER_TEMPLATES
 126     template <class X> void SetVect(const AliFemtoThreeVector<X>&);
 127 #else
 128     void SetVect(const AliFemtoThreeVector<float>&);
 129     void SetVect(const AliFemtoThreeVector<double>&);
 130 #endif
 131
 132     T Perp()               const;
 133     T Perp2()              const;
 134     T PseudoRapidity()     const;
 135     T Phi()                const;
 136     T Theta()              const;
 137     T CosTheta()           const;
 138
 139     T Plus()               const;
 140     T Minus()              const;
 141
 142     T m()                  const;
 143     T m2()                 const;
 144     T mt()                 const;
 145     T mt2()                const;
 146     T Rapidity()           const;
 147
 148 #ifndef ST_NO_MEMBER_TEMPLATES
 149     template<class X> AliFemtoLorentzVector<T> boost(const AliFemtoLorentzVector<X>&) const;
 150 #else
 151     AliFemtoLorentzVector<T> boost(const AliFemtoLorentzVector<float>&) const;
 152     AliFemtoLorentzVector<T> boost(const AliFemtoLorentzVector<double>&) const;
 153 #endif
 154
 155     AliFemtoLorentzVector<T>  operator- ();
 156     AliFemtoLorentzVector<T>  operator+ ();
 157     AliFemtoLorentzVector<T>& operator*= (double);
 158     AliFemtoLorentzVector<T>& operator/= (double);
 159
 160 #ifndef ST_NO_MEMBER_TEMPLATES
 161     template<class X> bool operator == (const AliFemtoLorentzVector<X>&) const;
 162     template<class X> bool operator != (const AliFemtoLorentzVector<X>&) const;
 163     template<class X> AliFemtoLorentzVector<T>& operator+= (const AliFemtoLorentzVector<X>&);
 164     template<class X> AliFemtoLorentzVector<T>& operator-= (const AliFemtoLorentzVector<X>&);
 165 #else
 166     bool operator == (const AliFemtoLorentzVector<float>&) const;
 167     bool operator != (const AliFemtoLorentzVector<float>&) const;
 168     bool operator == (const AliFemtoLorentzVector<double>&) const;
 169     bool operator != (const AliFemtoLorentzVector<double>&) const;
 170
 171     AliFemtoLorentzVector<T>& operator+= (const AliFemtoLorentzVector<float>&);
 172     AliFemtoLorentzVector<T>& operator-= (const AliFemtoLorentzVector<float>&);
 173     AliFemtoLorentzVector<T>& operator+= (const AliFemtoLorentzVector<double>&);
 174     AliFemtoLorentzVector<T>& operator-= (const AliFemtoLorentzVector<double>&);
 175 #endif
 176
 177 protected:
 178     AliFemtoThreeVector<T> mThreeVector;
 179     T                mX4;
 180 #ifdef __ROOT__
 181   ClassDef(AliFemtoLorentzVector,3)
 182 #endif
 183 };
 184 #ifndef __CINT__
 185 //
 186 //        Implementation of member functions
 187 //
 188 template<class T>
 189 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(T x, T y, T z, T t)
 190     : mThreeVector(x, y, z), mX4(t) { /* nop */ }
 191
 192 template<class T>
 193 AliFemtoLorentzVector<T>::~AliFemtoLorentzVector() { /* nopt */ }
 194
 195 template<class T>
 196 const AliFemtoThreeVector<T>& AliFemtoLorentzVector<T>::vect() const
 197 {
 198     return mThreeVector;
 199 }
 200
 201 template<class T>
 202 T AliFemtoLorentzVector<T>::m2() const
 203 {
 204     return (mX4*mX4 - mThreeVector*mThreeVector);
 205 }
 206
 207 template<class T>
 208 T AliFemtoLorentzVector<T>::Plus() const { return (e() + pz()); }
 209
 210 template<class T>
 211 T AliFemtoLorentzVector<T>::Minus() const { return (e() - pz()); }
 212
 213 template<class T>
 214 T AliFemtoLorentzVector<T>::m() const
 215 {
 216     T mass2 = m2();
 217     if (mass2 < 0)
 218         return -::sqrt(-mass2);
 219     else
 220         return ::sqrt(mass2);
 221 }
 222
 223 template<class T>
 224 T AliFemtoLorentzVector<T>::mt2() const
 225 {
 226     return this->Perp2() + m2();
 227 }
 228
 229 template<class T>
 230 T AliFemtoLorentzVector<T>::mt() const
 231 {
 232     //
 233     // change to more optimal code ?
 234     // return e()*e() - pz()*pz();
 235     T massPerp2 = mt2();
 236     if (massPerp2 < 0)
 237         return -::sqrt(-massPerp2);
 238     else
 239         return ::sqrt(massPerp2);
 240 }
 241
 242 template<class T>
 243 void AliFemtoLorentzVector<T>::SetPx(T x) {mThreeVector.SetX(x);}
 244
 245 template<class T>
 246 void AliFemtoLorentzVector<T>::SetPy(T y) {mThreeVector.SetY(y);}
 247
 248 template<class T>
 249 void AliFemtoLorentzVector<T>::SetPz(T z) {mThreeVector.SetZ(z);}
 250
 251 template<class T>
 252 void AliFemtoLorentzVector<T>::SetX(T x) {mThreeVector.SetX(x);}
 253
 254 template<class T>
 255 void AliFemtoLorentzVector<T>::SetY(T y) {mThreeVector.SetY(y);}
 256
 257 template<class T>
 258 void AliFemtoLorentzVector<T>::SetZ(T z) {mThreeVector.SetZ(z);}
 259
 260 template<class T>
 261 void AliFemtoLorentzVector<T>::SetT(T t) {mX4 = t;}
 262
 263 template<class T>
 264 void AliFemtoLorentzVector<T>::SetE(T e) {mX4 = e;}
 265
 266 template<class T>
 267 T AliFemtoLorentzVector<T>::x() const {return mThreeVector.x();}
 268
 269 template<class T>
 270 T AliFemtoLorentzVector<T>::y() const {return mThreeVector.y();}
 271
 272 template<class T>
 273 T AliFemtoLorentzVector<T>::z() const {return mThreeVector.z();}
 274
 275 template<class T>
 276 T AliFemtoLorentzVector<T>::px() const {return mThreeVector.x();}
 277
 278 template<class T>
 279 T AliFemtoLorentzVector<T>::py() const {return mThreeVector.y();}
 280
 281 template<class T>
 282 T AliFemtoLorentzVector<T>::pz() const {return mThreeVector.z();}
 283
 284 template<class T>
 285 T AliFemtoLorentzVector<T>::e() const {return mX4;}
 286
 287 template<class T>
 288 T AliFemtoLorentzVector<T>::t() const {return mX4;}
 289
 290 template<class T>
 291 T AliFemtoLorentzVector<T>::Perp() const {return mThreeVector.Perp();}
 292
 293 template<class T>
 294 T AliFemtoLorentzVector<T>::Perp2() const {return mThreeVector.Perp2();}
 295
 296 template<class T>
 297 T AliFemtoLorentzVector<T>::PseudoRapidity() const {return mThreeVector.PseudoRapidity();}
 298
 299 template<class T>
 300 T AliFemtoLorentzVector<T>::Phi() const {return mThreeVector.Phi();}
 301
 302 template<class T>
 303 T AliFemtoLorentzVector<T>::Theta() const {return mThreeVector.Theta();}
 304
 305 template<class T>
 306 T AliFemtoLorentzVector<T>::CosTheta() const {return mThreeVector.CosTheta();}
 307
 308 template<class T>
 309 T AliFemtoLorentzVector<T>::operator() (size_t i) const
 310 {
 311     if (i < 3)
 312         return mThreeVector(i);
 313     else if (i == 3)
 314         return mX4;
 315     else {
 316 #ifndef ST_NO_EXCEPTIONS
 317       throw out_of_range("AliFemtoLorentzVector<T>::operator(): bad index");
 318 #else
 319       cerr << "AliFemtoLorentzVector<T>::operator(): bad index." << endl;
 320 #endif
 321       return 0;
 322     }
 323 }
 324
 325 template<class T>
 326 T& AliFemtoLorentzVector<T>::operator() (size_t i)
 327 {
 328     if (i < 3)
 329         return mThreeVector(i);
 330     else if (i == 3)
 331         return mX4;
 332     else {
 333 #ifndef ST_NO_EXCEPTIONS
 334       throw out_of_range("AliFemtoLorentzVector<T>::operator(): bad index");
 335 #else
 336       cerr << "AliFemtoLorentzVector<T>::operator(): bad index." << endl;
 337 #endif
 338       return mX4;
 339     }
 340 }
 341
 342 template<class T>
 343 T AliFemtoLorentzVector<T>::operator[] (size_t i) const
 344 {
 345     if (i < 3)
 346         return mThreeVector[i];
 347     else if (i == 3)
 348         return mX4;
 349     else {
 350 #ifndef ST_NO_EXCEPTIONS
 351       throw out_of_range("AliFemtoLorentzVector<T>::operator[]: bad index");
 352 #else
 353       cerr << "AliFemtoLorentzVector<T>::operator[]: bad index." << endl;
 354 #endif
 355       return 0;
 356     }
 357 }
 358
 359 template<class T>
 360 T& AliFemtoLorentzVector<T>::operator[] (size_t i)
 361 {
 362     if (i < 3)
 363         return mThreeVector[i];
 364     else if (i == 3)
 365         return mX4;
 366     else {
 367 #ifndef ST_NO_EXCEPTIONS
 368       throw out_of_range("AliFemtoLorentzVector<T>::operator[]: bad index");
 369 #else
 370       cerr << "AliFemtoLorentzVector<T>::operator[]: bad index." << endl;
 371 #endif
 372       return mX4;
 373     }
 374 }
 375
 376 template<class T>
 377 T AliFemtoLorentzVector<T>::Rapidity() const
 378 {
 379     return 0.5*::log((mX4+mThreeVector.z())/(mX4-mThreeVector.z())+1e-20);
 380 }
 381
 382 template<class T>
 383 AliFemtoLorentzVector<T> AliFemtoLorentzVector<T>::operator- ()
 384 {
 385     return AliFemtoLorentzVector<T>(-mX4,-mThreeVector);
 386 }
 387
 388 template<class T>
 389 AliFemtoLorentzVector<T> AliFemtoLorentzVector<T>::operator+ ()
 390 {
 391     return *this;
 392 }
 393
 394 template<class T>
 395 AliFemtoLorentzVector<T>& AliFemtoLorentzVector<T>::operator*= (double c)
 396 {
 397     mThreeVector *= c;
 398     mX4 *= c;
 399     return *this;
 400 }
 401
 402 template<class T>
 403 AliFemtoLorentzVector<T>& AliFemtoLorentzVector<T>::operator/= (double c)
 404 {
 405     mThreeVector /= c;
 406     mX4 /= c;
 407     return *this;
 408 }
 409
 410 #ifndef ST_NO_MEMBER_TEMPLATES
 411 #ifndef WIN32
 412
 413 template<class T>
 414 template<class X>
 415 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoThreeVector<X> &vec, T t)
 416         : mThreeVector(vec), mX4(t) { /* nop */ }
 417
 418 template<class T>
 419 template<class X>
 420 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(T t, const AliFemtoThreeVector<X> &vec)
 421         : mThreeVector(vec), mX4(t) { /* nop */ }
 422
 423 template<class T>
 424 template<class X>
 425 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoLorentzVector<X> &vec)
 426         : mThreeVector(vec.vect()), mX4(vec.t()) { /* nop */ }
 427
 428 template<class T>
 429 template<class X>
 430 AliFemtoLorentzVector<T>
 431 AliFemtoLorentzVector<T>::boost(const AliFemtoLorentzVector<X>& pframe) const
 432 {
 433     T mass               = abs(pframe);
 434     AliFemtoThreeVector<T> eta = (-1./mass)*pframe.vect();            // gamma*beta
 435     T gamma              = fabs(pframe.e())/mass;
 436     AliFemtoThreeVector<T> pl  = ((this->vect()*eta)/(eta*eta))*eta;  // longitudinal momentum
 437     return AliFemtoLorentzVector<T>(gamma*this->e() - this->vect()*eta,
 438                               this->vect() + (gamma-1.)*pl - this->e()*eta);
 439 }
 440
 441 template<class T>
 442 template<class X>
 443 void AliFemtoLorentzVector<T>::SetVect(const AliFemtoThreeVector<X>& v)
 444 {
 445     mThreeVector = v;
 446 }
 447
 448 template<class T>
 449 template<class X>
 450 AliFemtoLorentzVector<T>&
 451 AliFemtoLorentzVector<T>::operator=(const AliFemtoLorentzVector<X>& vec)
 452 {
 453     mThreeVector = vec.vect();
 454     mX4 = vec.t();
 455     return *this;
 456 }
 457
 458 template<class T>
 459 template<class X>
 460 bool
 461 AliFemtoLorentzVector<T>::operator== (const AliFemtoLorentzVector<X>& v) const
 462 {
 463     return (mThreeVector == v.vect()) && (mX4 == v.t());
 464 }
 465
 466 template<class T>
 467 template<class X>
 468 bool
 469 AliFemtoLorentzVector<T>::operator!= (const AliFemtoLorentzVector<X>& v) const
 470 {
 471     return !(*this == v);
 472 }
 473
 474 template<class T>
 475 template<class X>
 476 AliFemtoLorentzVector<T>&
 477 AliFemtoLorentzVector<T>::operator+= (const AliFemtoLorentzVector<X>& v)
 478 {
 479     mThreeVector += v.vect();
 480     mX4 += v.t();
 481     return *this;
 482 }
 483
 484 template<class T>
 485 template<class X>
 486 AliFemtoLorentzVector<T>&
 487 AliFemtoLorentzVector<T>::operator-= (const AliFemtoLorentzVector<X>& v)
 488 {
 489     mThreeVector -= v.vect();
 490     mX4 -= v.t();
 491     return *this;
 492 }
 493
 494 #endif
 495 #else
 496
 497 template<class T>
 498 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoThreeVector<float> &vec, T t)
 499         : mThreeVector(vec), mX4(t) { /* nop */ }
 500
 501 template<class T>
 502 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoThreeVector<double> &vec, T t)
 503         : mThreeVector(vec), mX4(t) { /* nop */ }
 504
 505 template<class T>
 506 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(T t, const AliFemtoThreeVector<float> &vec)
 507         : mThreeVector(vec), mX4(t) { /* nop */ }
 508
 509 template<class T>
 510 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(T t, const AliFemtoThreeVector<double> &vec)
 511         : mThreeVector(vec), mX4(t) { /* nop */ }
 512
 513 template<class T>
 514 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoLorentzVector<float> &vec)
 515         : mThreeVector(vec.vect()), mX4(vec.t()) { /* nop */ }
 516
 517 template<class T>
 518 AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoLorentzVector<double> &vec)
 519         : mThreeVector(vec.vect()), mX4(vec.t()) { /* nop */ }
 520
 521 template<class T>
 522 AliFemtoLorentzVector<T>
 523 AliFemtoLorentzVector<T>::boost(const AliFemtoLorentzVector<float>& pframe) const
 524 {
 525     T mass               = abs(pframe);
 526     AliFemtoThreeVector<T> eta = (-1./mass)*pframe.vect();            // gamma*beta
 527     T gamma              = fabs(pframe.e())/mass;
 528     AliFemtoThreeVector<T> pl  = ((this->vect()*eta)/(eta*eta))*eta;  // longitudinal momentum
 529     return AliFemtoLorentzVector<T>(gamma*this->e() - this->vect()*eta,
 530                               this->vect() + (gamma-1.)*pl - this->e()*eta);
 531 }
 532
 533 template<class T>
 534 AliFemtoLorentzVector<T>
 535 AliFemtoLorentzVector<T>::boost(const AliFemtoLorentzVector<double>& pframe) const
 536 {
 537     T mass               = abs(pframe);
 538     AliFemtoThreeVector<T> eta = (-1./mass)*pframe.vect();            // gamma*beta
 539     T gamma              = fabs(pframe.e())/mass;
 540     AliFemtoThreeVector<T> pl  = ((this->vect()*eta)/(eta*eta))*eta;  // longitudinal momentum
 541     return AliFemtoLorentzVector<T>(gamma*this->e() - this->vect()*eta,
 542                               this->vect() + (gamma-1.)*pl - this->e()*eta);
 543 }
 544
 545 template<class T>
 546 void AliFemtoLorentzVector<T>::SetVect(const AliFemtoThreeVector<float>& v)
 547 {
 548     mThreeVector = v;
 549 }
 550
 551 template<class T>
 552 void AliFemtoLorentzVector<T>::SetVect(const AliFemtoThreeVector<double>& v)
 553 {
 554     mThreeVector = v;
 555 }
 556
 557 template<class T>
 558 AliFemtoLorentzVector<T>&
 559 AliFemtoLorentzVector<T>::operator=(const AliFemtoLorentzVector<float>& vec)
 560 {
 561     mThreeVector = vec.vect();
 562     mX4 = vec.t();
 563     return *this;
 564 }
 565
 566 template<class T>
 567 AliFemtoLorentzVector<T>&
 568 AliFemtoLorentzVector<T>::operator=(const AliFemtoLorentzVector<double>& vec)
 569 {
 570     mThreeVector = vec.vect();
 571     mX4 = vec.t();
 572     return *this;
 573 }
 574
 575 template<class T>
 576 bool
 577 AliFemtoLorentzVector<T>::operator== (const AliFemtoLorentzVector<float>& v) const
 578 {
 579     return (this->vect() == v.vect()) && (mX4 == v.t());
 580 }
 581
 582 template<class T>
 583 bool
 584 AliFemtoLorentzVector<T>::operator== (const AliFemtoLorentzVector<double>& v) const
 585 {
 586     return (mThreeVector == v.vect()) && (mX4 == v.t());
 587 }
 588
 589 template<class T>
 590 bool
 591 AliFemtoLorentzVector<T>::operator!= (const AliFemtoLorentzVector<float>& v) const
 592 {
 593     return !(*this == v);
 594 }
 595
 596 template<class T>
 597 bool
 598 AliFemtoLorentzVector<T>::operator!= (const AliFemtoLorentzVector<double>& v) const
 599 {
 600     return !(*this == v);
 601 }
 602
 603 template<class T>
 604 AliFemtoLorentzVector<T>&
 605 AliFemtoLorentzVector<T>::operator+= (const AliFemtoLorentzVector<float>& v)
 606 {
 607     mThreeVector += v.vect();
 608     mX4 += v.t();
 609     return *this;
 610 }
 611
 612 template<class T>
 613 AliFemtoLorentzVector<T>&
 614 AliFemtoLorentzVector<T>::operator+= (const AliFemtoLorentzVector<double>& v)
 615 {
 616     mThreeVector += v.vect();
 617     mX4 += v.t();
 618     return *this;
 619 }
 620
 621 template<class T>
 622 AliFemtoLorentzVector<T>&
 623 AliFemtoLorentzVector<T>::operator-= (const AliFemtoLorentzVector<float>& v)
 624 {
 625     mThreeVector -= v.vect();
 626     mX4 -= v.t();
 627     return *this;
 628 }
 629
 630 template<class T>
 631 AliFemtoLorentzVector<T>&
 632 AliFemtoLorentzVector<T>::operator-= (const AliFemtoLorentzVector<double>& v)
 633 {
 634     mThreeVector -= v.vect();
 635     mX4 -= v.t();
 636     return *this;
 637 }
 638
 639 #endif // ST_NO_MEMBER_TEMPLATES
 640 #endif /* ! __CINT__ */
 641 #ifdef __CINT__
 642 template<> AliFemtoLorentzVector<double> operator+ (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<double>& v2);
 643 template<> AliFemtoLorentzVector<double> operator+ (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<float>& v2);
 644 template<> AliFemtoLorentzVector<double> operator+ (const AliFemtoLorentzVector<float>&  v1, const AliFemtoLorentzVector<double>& v2);
 645 template<> AliFemtoLorentzVector<float>  operator+ (const AliFemtoLorentzVector<float>&  v1, const AliFemtoLorentzVector<float>& v2);
 646 template<> AliFemtoLorentzVector<double> operator- (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<double>& v2);
 647 template<> AliFemtoLorentzVector<double> operator- (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<float>& v2);
 648 template<> AliFemtoLorentzVector<double> operator- (const AliFemtoLorentzVector<float>&  v1, const AliFemtoLorentzVector<double>& v2);
 649 template<> AliFemtoLorentzVector<float>  operator- (const AliFemtoLorentzVector<float>&  v1, const AliFemtoLorentzVector<float>& v2);
 650 template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<double>& v2);
 651 template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<float>& v2);
 652 template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<float>&  v1, const AliFemtoLorentzVector<double>& v2);
 653 template<> AliFemtoLorentzVector<float>  operator* (const AliFemtoLorentzVector<float>&  v1, const AliFemtoLorentzVector<float>& v2);
 654 template<> AliFemtoLorentzVector<double> operator* (const              double v1, const AliFemtoLorentzVector<double>& v2);
 655 template<> AliFemtoLorentzVector<double> operator* (const              double v1, const AliFemtoLorentzVector<float>&  v2);
 656 template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<double>& v1, const double              v2);
 657 template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<float>&  v1, const double              v2);
 658 template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<double>& v2);
 659 template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<float>& v2);
 660 template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<float>&  v1, const AliFemtoLorentzVector<double>& v2);
 661 template<> AliFemtoLorentzVector<float>  operator/ (const AliFemtoLorentzVector<float>&  v1, const AliFemtoLorentzVector<float>& v2);
 662 template<> AliFemtoLorentzVector<double> operator/ (const              double v1, const AliFemtoLorentzVector<double>& v2);
 663 template<> AliFemtoLorentzVector<double> operator/ (const              double v1, const AliFemtoLorentzVector<float>&  v2);
 664 template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<double>& v1, const double              v2);
 665 template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<float>&  v1, const double              v2);
 666 template<> istream& operator>> (istream& is, const AliFemtoLorentzVector<double>& v);
 667 template<> ostream& operator<< (ostream& os, const AliFemtoLorentzVector<double>& v);
 668 template<> istream& operator>> (istream& is, const AliFemtoLorentzVector<float>& v);
 669 template<> ostream& operator<< (ostream& os, const AliFemtoLorentzVector<float>& v);
 670 template<> double abs(const AliFemtoLorentzVector<double>& v);
 671 template<> float  abs(const AliFemtoLorentzVector<float>& v);
 672 #else
 673 //
 674 //   Non-member operators
 675 //
 676 template<class T, class X>
 677 AliFemtoLorentzVector<T>
 678 operator+ (const AliFemtoLorentzVector<T>& v1, const AliFemtoLorentzVector<X>& v2)
 679 {
 680     return AliFemtoLorentzVector<T>(v1) += v2;
 681 }
 682
 683 template<class T, class X>
 684 AliFemtoLorentzVector<T>
 685 operator- (const AliFemtoLorentzVector<T>& v1, const AliFemtoLorentzVector<X>& v2)
 686 {
 687     return AliFemtoLorentzVector<T>(v1) -= v2;
 688 }
 689
 690 template<class T, class X>
 691 T
 692 operator* (const AliFemtoLorentzVector<T>& v1, const AliFemtoLorentzVector<X>& v2)
 693 {
 694     return v1.t()*v2.t() - v1.vect()*v2.vect();
 695 }
 696
 697 template<class T>
 698 AliFemtoLorentzVector<T>
 699 operator* (const AliFemtoLorentzVector<T>& v, double c)
 700 {
 701     return AliFemtoLorentzVector<T>(v) *= c;
 702 }
 703
 704 template<class T>
 705 AliFemtoLorentzVector<T> operator* (double c, const AliFemtoLorentzVector<T>& v)
 706 {
 707     return AliFemtoLorentzVector<T>(v) *= c;
 708 }
 709
 710 template<class T, class X>
 711 AliFemtoLorentzVector<T> operator/ (const AliFemtoLorentzVector<T>& v, X c)
 712 {
 713     return AliFemtoLorentzVector<T>(v) /= c;
 714 }
 715
 716 template<class T>
 717 ostream& operator<< (ostream& os, const AliFemtoLorentzVector<T>& v)
 718 {
 719     return os << v.vect() << "\t\t" << v.t();
 720 }
 721
 722 template<class T>
 723 istream&  operator>>(istream& is, AliFemtoLorentzVector<T>& v)
 724 {
 725     T  x, y, z, t;
 726     is >> x >> y >> z >> t;
 727     v.SetX(x);
 728     v.SetY(y);
 729     v.SetZ(z);
 730     v.SetT(t);
 731     return is;
 732 }
 733
 734 //
 735 //        Non-member functions
 736 //
 737 template<class T>
 738 T abs(const AliFemtoLorentzVector<T>& v) {return v.m();}
 739
 740 #endif /*  __CINT__ */
 741 #endif