]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGCF/FEMTOSCOPY/AliFemto/AliFemtoLorentzVector.h
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master_patch'
[u/mrichter/AliRoot.git] / PWGCF / FEMTOSCOPY / AliFemto / AliFemtoLorentzVector.h
CommitLineData
76ce4b5b 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"
74template<class T> class AliFemtoLorentzVector {
75public:
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
177protected:
178 AliFemtoThreeVector<T> fThreeVector; // The three-vector component
179 T fX4; // The fourth component
180#ifdef __ROOT__
181 ClassDef(AliFemtoLorentzVector,3)
182#endif
183};
184#ifndef __CINT__
185//
186// Implementation of member functions
187//
188template<class T>
189AliFemtoLorentzVector<T>::AliFemtoLorentzVector(T x, T y, T z, T t)
190 : fThreeVector(x, y, z), fX4(t) { /* nop */ }
191
192template<class T>
193AliFemtoLorentzVector<T>::~AliFemtoLorentzVector() { /* nopt */ }
194
195template<class T>
196const AliFemtoThreeVector<T>& AliFemtoLorentzVector<T>::vect() const
197{
198 return fThreeVector;
199}
200
201template<class T>
202T AliFemtoLorentzVector<T>::m2() const
203{
204 return (fX4*fX4 - fThreeVector*fThreeVector);
205}
206
207template<class T>
208T AliFemtoLorentzVector<T>::Plus() const { return (e() + pz()); }
209
210template<class T>
211T AliFemtoLorentzVector<T>::Minus() const { return (e() - pz()); }
212
213template<class T>
214T 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
223template<class T>
224T AliFemtoLorentzVector<T>::mt2() const
225{
226 return this->Perp2() + m2();
227}
228
229template<class T>
230T 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
242template<class T>
243void AliFemtoLorentzVector<T>::SetPx(T x) {fThreeVector.SetX(x);}
244
245template<class T>
246void AliFemtoLorentzVector<T>::SetPy(T y) {fThreeVector.SetY(y);}
247
248template<class T>
249void AliFemtoLorentzVector<T>::SetPz(T z) {fThreeVector.SetZ(z);}
250
251template<class T>
252void AliFemtoLorentzVector<T>::SetX(T x) {fThreeVector.SetX(x);}
253
254template<class T>
255void AliFemtoLorentzVector<T>::SetY(T y) {fThreeVector.SetY(y);}
256
257template<class T>
258void AliFemtoLorentzVector<T>::SetZ(T z) {fThreeVector.SetZ(z);}
259
260template<class T>
261void AliFemtoLorentzVector<T>::SetT(T t) {fX4 = t;}
262
263template<class T>
264void AliFemtoLorentzVector<T>::SetE(T e) {fX4 = e;}
265
266template<class T>
267T AliFemtoLorentzVector<T>::x() const {return fThreeVector.x();}
268
269template<class T>
270T AliFemtoLorentzVector<T>::y() const {return fThreeVector.y();}
271
272template<class T>
273T AliFemtoLorentzVector<T>::z() const {return fThreeVector.z();}
274
275template<class T>
276T AliFemtoLorentzVector<T>::px() const {return fThreeVector.x();}
277
278template<class T>
279T AliFemtoLorentzVector<T>::py() const {return fThreeVector.y();}
280
281template<class T>
282T AliFemtoLorentzVector<T>::pz() const {return fThreeVector.z();}
283
284template<class T>
285T AliFemtoLorentzVector<T>::e() const {return fX4;}
286
287template<class T>
288T AliFemtoLorentzVector<T>::t() const {return fX4;}
289
290template<class T>
291T AliFemtoLorentzVector<T>::Perp() const {return fThreeVector.Perp();}
292
293template<class T>
294T AliFemtoLorentzVector<T>::Perp2() const {return fThreeVector.Perp2();}
295
296template<class T>
297T AliFemtoLorentzVector<T>::PseudoRapidity() const {return fThreeVector.PseudoRapidity();}
298
299template<class T>
300T AliFemtoLorentzVector<T>::Phi() const {return fThreeVector.Phi();}
301
302template<class T>
303T AliFemtoLorentzVector<T>::Theta() const {return fThreeVector.Theta();}
304
305template<class T>
306T AliFemtoLorentzVector<T>::CosTheta() const {return fThreeVector.CosTheta();}
307
308template<class T>
309T AliFemtoLorentzVector<T>::operator() (size_t i) const
310{
311 if (i < 3)
312 return fThreeVector(i);
313 else if (i == 3)
314 return fX4;
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
325template<class T>
326T& AliFemtoLorentzVector<T>::operator() (size_t i)
327{
328 if (i < 3)
329 return fThreeVector(i);
330 else if (i == 3)
331 return fX4;
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 fX4;
339 }
340}
341
342template<class T>
343T AliFemtoLorentzVector<T>::operator[] (size_t i) const
344{
345 if (i < 3)
346 return fThreeVector[i];
347 else if (i == 3)
348 return fX4;
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
359template<class T>
360T& AliFemtoLorentzVector<T>::operator[] (size_t i)
361{
362 if (i < 3)
363 return fThreeVector[i];
364 else if (i == 3)
365 return fX4;
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 fX4;
373 }
374}
375
376template<class T>
377T AliFemtoLorentzVector<T>::Rapidity() const
378{
379 return 0.5*::log((fX4+fThreeVector.z())/(fX4-fThreeVector.z())+1e-20);
380}
381
382template<class T>
383AliFemtoLorentzVector<T> AliFemtoLorentzVector<T>::operator- ()
384{
385 return AliFemtoLorentzVector<T>(-fX4,-fThreeVector);
386}
387
388template<class T>
389AliFemtoLorentzVector<T> AliFemtoLorentzVector<T>::operator+ ()
390{
391 return *this;
392}
393
394template<class T>
395AliFemtoLorentzVector<T>& AliFemtoLorentzVector<T>::operator*= (double c)
396{
397 fThreeVector *= c;
398 fX4 *= c;
399 return *this;
400}
401
402template<class T>
403AliFemtoLorentzVector<T>& AliFemtoLorentzVector<T>::operator/= (double c)
404{
405 fThreeVector /= c;
406 fX4 /= c;
407 return *this;
408}
409
410#ifndef ST_NO_MEMBER_TEMPLATES
411#ifndef WIN32
412
413template<class T>
414template<class X>
415AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoThreeVector<X> &vec, T t)
416 : fThreeVector(vec), fX4(t) { /* nop */ }
417
418template<class T>
419template<class X>
420AliFemtoLorentzVector<T>::AliFemtoLorentzVector(T t, const AliFemtoThreeVector<X> &vec)
421 : fThreeVector(vec), fX4(t) { /* nop */ }
422
423template<class T>
424template<class X>
425AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoLorentzVector<X> &vec)
426 : fThreeVector(vec.vect()), fX4(vec.t()) { /* nop */ }
427
428template<class T>
429template<class X>
430AliFemtoLorentzVector<T>
431AliFemtoLorentzVector<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
441template<class T>
442template<class X>
443void AliFemtoLorentzVector<T>::SetVect(const AliFemtoThreeVector<X>& v)
444{
445 fThreeVector = v;
446}
447
448template<class T>
449template<class X>
450AliFemtoLorentzVector<T>&
451AliFemtoLorentzVector<T>::operator=(const AliFemtoLorentzVector<X>& vec)
452{
453 if(this != &vec) {
454 fThreeVector = vec.vect();
455 fX4 = vec.t();
456 }
457 return *this;
458}
459
460template<class T>
461template<class X>
462bool
463AliFemtoLorentzVector<T>::operator== (const AliFemtoLorentzVector<X>& v) const
464{
465 return (fThreeVector == v.vect()) && (fX4 == v.t());
466}
467
468template<class T>
469template<class X>
470bool
471AliFemtoLorentzVector<T>::operator!= (const AliFemtoLorentzVector<X>& v) const
472{
473 return !(*this == v);
474}
475
476template<class T>
477template<class X>
478AliFemtoLorentzVector<T>&
479AliFemtoLorentzVector<T>::operator+= (const AliFemtoLorentzVector<X>& v)
480{
481 fThreeVector += v.vect();
482 fX4 += v.t();
483 return *this;
484}
485
486template<class T>
487template<class X>
488AliFemtoLorentzVector<T>&
489AliFemtoLorentzVector<T>::operator-= (const AliFemtoLorentzVector<X>& v)
490{
491 fThreeVector -= v.vect();
492 fX4 -= v.t();
493 return *this;
494}
495
496#endif
497#else
498
499template<class T>
500AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoThreeVector<float> &vec, T t)
501 : fThreeVector(vec), fX4(t) { /* nop */ }
502
503template<class T>
504AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoThreeVector<double> &vec, T t)
505 : fThreeVector(vec), fX4(t) { /* nop */ }
506
507template<class T>
508AliFemtoLorentzVector<T>::AliFemtoLorentzVector(T t, const AliFemtoThreeVector<float> &vec)
509 : fThreeVector(vec), fX4(t) { /* nop */ }
510
511template<class T>
512AliFemtoLorentzVector<T>::AliFemtoLorentzVector(T t, const AliFemtoThreeVector<double> &vec)
513 : fThreeVector(vec), fX4(t) { /* nop */ }
514
515template<class T>
516AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoLorentzVector<float> &vec)
517 : fThreeVector(vec.vect()), fX4(vec.t()) { /* nop */ }
518
519template<class T>
520AliFemtoLorentzVector<T>::AliFemtoLorentzVector(const AliFemtoLorentzVector<double> &vec)
521 : fThreeVector(vec.vect()), fX4(vec.t()) { /* nop */ }
522
523template<class T>
524AliFemtoLorentzVector<T>
525AliFemtoLorentzVector<T>::boost(const AliFemtoLorentzVector<float>& pframe) const
526{
527 T mass = abs(pframe);
528 AliFemtoThreeVector<T> eta = (-1./mass)*pframe.vect(); // gamma*beta
529 T gamma = fabs(pframe.e())/mass;
530 AliFemtoThreeVector<T> pl = ((this->vect()*eta)/(eta*eta))*eta; // longitudinal momentum
531 return AliFemtoLorentzVector<T>(gamma*this->e() - this->vect()*eta,
532 this->vect() + (gamma-1.)*pl - this->e()*eta);
533}
534
535template<class T>
536AliFemtoLorentzVector<T>
537AliFemtoLorentzVector<T>::boost(const AliFemtoLorentzVector<double>& pframe) const
538{
539 T mass = abs(pframe);
540 AliFemtoThreeVector<T> eta = (-1./mass)*pframe.vect(); // gamma*beta
541 T gamma = fabs(pframe.e())/mass;
542 AliFemtoThreeVector<T> pl = ((this->vect()*eta)/(eta*eta))*eta; // longitudinal momentum
543 return AliFemtoLorentzVector<T>(gamma*this->e() - this->vect()*eta,
544 this->vect() + (gamma-1.)*pl - this->e()*eta);
545}
546
547template<class T>
548void AliFemtoLorentzVector<T>::SetVect(const AliFemtoThreeVector<float>& v)
549{
550 fThreeVector = v;
551}
552
553template<class T>
554void AliFemtoLorentzVector<T>::SetVect(const AliFemtoThreeVector<double>& v)
555{
556 fThreeVector = v;
557}
558
559template<class T>
560AliFemtoLorentzVector<T>&
561AliFemtoLorentzVector<T>::operator=(const AliFemtoLorentzVector<float>& vec)
562{
563 fThreeVector = vec.vect();
564 fX4 = vec.t();
565 return *this;
566}
567
568template<class T>
569AliFemtoLorentzVector<T>&
570AliFemtoLorentzVector<T>::operator=(const AliFemtoLorentzVector<double>& vec)
571{
572 fThreeVector = vec.vect();
573 fX4 = vec.t();
574 return *this;
575}
576
577template<class T>
578bool
579AliFemtoLorentzVector<T>::operator== (const AliFemtoLorentzVector<float>& v) const
580{
581 return (this->vect() == v.vect()) && (fX4 == v.t());
582}
583
584template<class T>
585bool
586AliFemtoLorentzVector<T>::operator== (const AliFemtoLorentzVector<double>& v) const
587{
588 return (fThreeVector == v.vect()) && (fX4 == v.t());
589}
590
591template<class T>
592bool
593AliFemtoLorentzVector<T>::operator!= (const AliFemtoLorentzVector<float>& v) const
594{
595 return !(*this == v);
596}
597
598template<class T>
599bool
600AliFemtoLorentzVector<T>::operator!= (const AliFemtoLorentzVector<double>& v) const
601{
602 return !(*this == v);
603}
604
605template<class T>
606AliFemtoLorentzVector<T>&
607AliFemtoLorentzVector<T>::operator+= (const AliFemtoLorentzVector<float>& v)
608{
609 fThreeVector += v.vect();
610 fX4 += v.t();
611 return *this;
612}
613
614template<class T>
615AliFemtoLorentzVector<T>&
616AliFemtoLorentzVector<T>::operator+= (const AliFemtoLorentzVector<double>& v)
617{
618 fThreeVector += v.vect();
619 fX4 += v.t();
620 return *this;
621}
622
623template<class T>
624AliFemtoLorentzVector<T>&
625AliFemtoLorentzVector<T>::operator-= (const AliFemtoLorentzVector<float>& v)
626{
627 fThreeVector -= v.vect();
628 fX4 -= v.t();
629 return *this;
630}
631
632template<class T>
633AliFemtoLorentzVector<T>&
634AliFemtoLorentzVector<T>::operator-= (const AliFemtoLorentzVector<double>& v)
635{
636 fThreeVector -= v.vect();
637 fX4 -= v.t();
638 return *this;
639}
640
641#endif // ST_NO_MEMBER_TEMPLATES
642#endif /* ! __CINT__ */
643#ifdef __CINT__
644template<> AliFemtoLorentzVector<double> operator+ (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<double>& v2);
645template<> AliFemtoLorentzVector<double> operator+ (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<float>& v2);
646template<> AliFemtoLorentzVector<double> operator+ (const AliFemtoLorentzVector<float>& v1, const AliFemtoLorentzVector<double>& v2);
647template<> AliFemtoLorentzVector<float> operator+ (const AliFemtoLorentzVector<float>& v1, const AliFemtoLorentzVector<float>& v2);
648template<> AliFemtoLorentzVector<double> operator- (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<double>& v2);
649template<> AliFemtoLorentzVector<double> operator- (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<float>& v2);
650template<> AliFemtoLorentzVector<double> operator- (const AliFemtoLorentzVector<float>& v1, const AliFemtoLorentzVector<double>& v2);
651template<> AliFemtoLorentzVector<float> operator- (const AliFemtoLorentzVector<float>& v1, const AliFemtoLorentzVector<float>& v2);
652template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<double>& v2);
653template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<float>& v2);
654template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<float>& v1, const AliFemtoLorentzVector<double>& v2);
655template<> AliFemtoLorentzVector<float> operator* (const AliFemtoLorentzVector<float>& v1, const AliFemtoLorentzVector<float>& v2);
656template<> AliFemtoLorentzVector<double> operator* (const double v1, const AliFemtoLorentzVector<double>& v2);
657template<> AliFemtoLorentzVector<double> operator* (const double v1, const AliFemtoLorentzVector<float>& v2);
658template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<double>& v1, const double v2);
659template<> AliFemtoLorentzVector<double> operator* (const AliFemtoLorentzVector<float>& v1, const double v2);
660template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<double>& v2);
661template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<double>& v1, const AliFemtoLorentzVector<float>& v2);
662template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<float>& v1, const AliFemtoLorentzVector<double>& v2);
663template<> AliFemtoLorentzVector<float> operator/ (const AliFemtoLorentzVector<float>& v1, const AliFemtoLorentzVector<float>& v2);
664template<> AliFemtoLorentzVector<double> operator/ (const double v1, const AliFemtoLorentzVector<double>& v2);
665template<> AliFemtoLorentzVector<double> operator/ (const double v1, const AliFemtoLorentzVector<float>& v2);
666template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<double>& v1, const double v2);
667template<> AliFemtoLorentzVector<double> operator/ (const AliFemtoLorentzVector<float>& v1, const double v2);
668template<> istream& operator>> (istream& is, const AliFemtoLorentzVector<double>& v);
669template<> ostream& operator<< (ostream& os, const AliFemtoLorentzVector<double>& v);
670template<> istream& operator>> (istream& is, const AliFemtoLorentzVector<float>& v);
671template<> ostream& operator<< (ostream& os, const AliFemtoLorentzVector<float>& v);
672template<> double abs(const AliFemtoLorentzVector<double>& v);
673template<> float abs(const AliFemtoLorentzVector<float>& v);
674#else
675//
676// Non-member operators
677//
678template<class T, class X>
679AliFemtoLorentzVector<T>
680operator+ (const AliFemtoLorentzVector<T>& v1, const AliFemtoLorentzVector<X>& v2)
681{
682 return AliFemtoLorentzVector<T>(v1) += v2;
683}
684
685template<class T, class X>
686AliFemtoLorentzVector<T>
687operator- (const AliFemtoLorentzVector<T>& v1, const AliFemtoLorentzVector<X>& v2)
688{
689 return AliFemtoLorentzVector<T>(v1) -= v2;
690}
691
692template<class T, class X>
693T
694operator* (const AliFemtoLorentzVector<T>& v1, const AliFemtoLorentzVector<X>& v2)
695{
696 return v1.t()*v2.t() - v1.vect()*v2.vect();
697}
698
699template<class T>
700AliFemtoLorentzVector<T>
701operator* (const AliFemtoLorentzVector<T>& v, double c)
702{
703 return AliFemtoLorentzVector<T>(v) *= c;
704}
705
706template<class T>
707AliFemtoLorentzVector<T> operator* (double c, const AliFemtoLorentzVector<T>& v)
708{
709 return AliFemtoLorentzVector<T>(v) *= c;
710}
711
712template<class T, class X>
713AliFemtoLorentzVector<T> operator/ (const AliFemtoLorentzVector<T>& v, X c)
714{
715 return AliFemtoLorentzVector<T>(v) /= c;
716}
717
718template<class T>
719ostream& operator<< (ostream& os, const AliFemtoLorentzVector<T>& v)
720{
721 return os << v.vect() << "\t\t" << v.t();
722}
723
724template<class T>
725istream& operator>>(istream& is, AliFemtoLorentzVector<T>& v)
726{
727 T x, y, z, t;
728 is >> x >> y >> z >> t;
729 v.SetX(x);
730 v.SetY(y);
731 v.SetZ(z);
732 v.SetT(t);
733 return is;
734}
735
736//
737// Non-member functions
738//
739template<class T>
740T abs(const AliFemtoLorentzVector<T>& v) {return v.m();}
741
742#endif /* __CINT__ */
743#endif