ROOT logo
/***************************************************************************
 *
 * $Id$
 *
 * Author: Brian Lasiuk, Thomas Ullrich, April 1998
 ***************************************************************************
 *
 * Description:
 *
 * Remarks:   Since not all compilers support member templates
 *            we have to specialize the templated member on these
 *            platforms. If member templates are not supported the
 *            ST_NO_MEMBER_TEMPLATES flag has to be set. tu.
 *
 *            In the near future when all compilers can handle member
 *            templates this class should be cleaned up. A lot of
 *            redundant code can be removed as soon as the compilers
 *            are up-to-date. tu
 *
 ***************************************************************************
 *
 * $Log$
 * Revision 1.1.1.1  2007/04/25 15:38:41  panos
 * Importing the HBT code dir
 *
 * Revision 1.1.1.1  2007/03/07 10:14:49  mchojnacki
 * First version on CVS
 *
 * Revision 1.11  2005/09/22 20:09:20  fisyak
 * Make AliFmLorentzVector persistent
 *
 * Revision 1.10  2005/07/06 18:49:56  fisyak
 * Replace AliFmHelixD, AliFmLorentzVectorD,AliFmLorentzVectorF,AliFmMatrixD,AliFmMatrixF,AliFmPhysicalHelixD,AliFmThreeVectorD,AliFmThreeVectorF by templated version
 *
 * Revision 1.9  2005/03/28 06:02:45  perev
 * Defence FPE added
 *
 * Revision 1.8  2003/09/02 17:59:35  perev
 * gcc 3.2 updates + WarnOff
 *
 * Revision 1.7  2003/05/01 19:24:31  ullrich
 * Corrected problem in boost().
 *
 * Revision 1.6  1999/10/15 15:56:36  ullrich
 * Changed output format in operator<<, added operator>>
 *
 * Revision 1.5  1999/06/04 18:01:36  ullrich
 * New operators operator() and operator[] which can be used
 * as lvalues.
 *
 * Revision 1.4  1999/04/14 23:12:07  fisyak
 * Add __CINT__ to handle references
 *
 * Revision 1.3  1999/02/17 11:38:36  ullrich
 * Removed specialization for 'long double'.
 *
 * Revision 1.2  1999/02/14 23:11:42  fisyak
 * Fixes for Rootcint
 *
 * Revision 1.1  1999/01/30 03:59:02  fisyak
 * Root Version of AliFmarClassLibrary
 *
 * Revision 1.1  1999/01/23 00:27:52  ullrich
 * Initial Revision
 *
 **************************************************************************/
/*//
//// General class for a Lorentz four-vector
///*/
#ifndef ST_LORENTZ_VECTOR_HH
#define ST_LORENTZ_VECTOR_HH

#include "AliFmThreeVector.h"
template<class T> class AliFmLorentzVector {
public:
    AliFmLorentzVector(T = 0, T = 0, T = 0, T = 0);
    virtual ~AliFmLorentzVector();
    
#ifndef ST_NO_MEMBER_TEMPLATES
    template<class X> AliFmLorentzVector(const AliFmThreeVector<X>&, T);
    template<class X> AliFmLorentzVector(T, const AliFmThreeVector<X>&);   

    template<class X> AliFmLorentzVector(const AliFmLorentzVector<X>&);
    template<class X> AliFmLorentzVector<T>& operator=(const AliFmLorentzVector<X>&);
    // AliFmLorentzVector(const AliFmLorentzVector<T>&);                use default
    // AliFmLorentzVector<T>& operator=(const AliFmLorentzVector<T>&);  use default
#else
    AliFmLorentzVector(const AliFmThreeVector<float>&, T);
    AliFmLorentzVector(T, const AliFmThreeVector<float>&);   
    AliFmLorentzVector(const AliFmLorentzVector<float>&);
    
    AliFmLorentzVector(const AliFmThreeVector<double>&, T);
    AliFmLorentzVector(T, const AliFmThreeVector<double>&);   
    AliFmLorentzVector(const AliFmLorentzVector<double>&);
        
    AliFmLorentzVector<T>& operator=(const AliFmLorentzVector<float>&);
    AliFmLorentzVector<T>& operator=(const AliFmLorentzVector<double>&);
#endif
    
    T x()                     const;
    T y()                     const;
    T z()                     const;
    T t()                     const;
    T px()                    const;
    T py()                    const;
    T pz()                    const;
    T e()                     const;
    T operator()  (size_t)    const;
    T operator[]  (size_t)    const;
    
    T& operator()  (size_t);
    T& operator[]  (size_t);

    const AliFmThreeVector<T>& vect() const;    
    
    void SetX(T);
    void SetY(T);
    void SetZ(T);
    void SetPx(T);
    void SetPy(T);
    void SetPz(T);
    void SetE(T);
    void SetT(T);
    
#ifndef ST_NO_MEMBER_TEMPLATES
    template <class X> void SetVect(const AliFmThreeVector<X>&);
#else
    void SetVect(const AliFmThreeVector<float>&);
    void SetVect(const AliFmThreeVector<double>&);
#endif   

    T Perp()               const;
    T Perp2()              const;
    T PseudoRapidity()     const;
    T Phi()                const;
    T Theta()              const;
    T CosTheta()           const;
    
    T Plus()               const;
    T Minus()              const;
    
    T m()                  const; 
    T m2()                 const; 
    T mt()                 const;
    T mt2()                const;
    T Rapidity()           const;
    
#ifndef ST_NO_MEMBER_TEMPLATES
    template<class X> AliFmLorentzVector<T> boost(const AliFmLorentzVector<X>&) const;
#else
    AliFmLorentzVector<T> boost(const AliFmLorentzVector<float>&) const;
    AliFmLorentzVector<T> boost(const AliFmLorentzVector<double>&) const;
#endif   
    
    AliFmLorentzVector<T>  operator- ();
    AliFmLorentzVector<T>  operator+ ();
    AliFmLorentzVector<T>& operator*= (double);
    AliFmLorentzVector<T>& operator/= (double);

#ifndef ST_NO_MEMBER_TEMPLATES
    template<class X> bool operator == (const AliFmLorentzVector<X>&) const;
    template<class X> bool operator != (const AliFmLorentzVector<X>&) const;
    template<class X> AliFmLorentzVector<T>& operator+= (const AliFmLorentzVector<X>&);
    template<class X> AliFmLorentzVector<T>& operator-= (const AliFmLorentzVector<X>&);
#else    
    bool operator == (const AliFmLorentzVector<float>&) const;
    bool operator != (const AliFmLorentzVector<float>&) const;
    bool operator == (const AliFmLorentzVector<double>&) const;
    bool operator != (const AliFmLorentzVector<double>&) const;

    AliFmLorentzVector<T>& operator+= (const AliFmLorentzVector<float>&);
    AliFmLorentzVector<T>& operator-= (const AliFmLorentzVector<float>&);
    AliFmLorentzVector<T>& operator+= (const AliFmLorentzVector<double>&);
    AliFmLorentzVector<T>& operator-= (const AliFmLorentzVector<double>&);
#endif

protected:
    AliFmThreeVector<T> fThreeVector; // The spatial three-vector
    T	             fX4;             // The fourth components
#ifdef __ROOT__
  ClassDef(AliFmLorentzVector,3)
#endif
};
#ifndef __CINT__
//
//        Implementation of member functions
//
template<class T>
AliFmLorentzVector<T>::AliFmLorentzVector(T ax, T ay, T az, T at)
    : fThreeVector(ax, ay, az), fX4(at) { /* nop */ }

template<class T>
AliFmLorentzVector<T>::~AliFmLorentzVector() { /* nopt */ }    

template<class T>
const AliFmThreeVector<T>& AliFmLorentzVector<T>::vect() const 
{
    return fThreeVector;
}

template<class T>
T AliFmLorentzVector<T>::m2() const
{
    return (fX4*fX4 - fThreeVector*fThreeVector);    
}

template<class T>
T AliFmLorentzVector<T>::Plus() const { return (e() + pz()); }

template<class T>
T AliFmLorentzVector<T>::Minus() const { return (e() - pz()); }

template<class T>
T AliFmLorentzVector<T>::m() const
{
    T mass2 = m2();
    if (mass2 < 0)
	return -::sqrt(-mass2);
    else
	return ::sqrt(mass2);
}

template<class T>
T AliFmLorentzVector<T>::mt2() const
{
    return this->Perp2() + m2();
}

template<class T>
T AliFmLorentzVector<T>::mt() const
{
    //
    // change to more optimal code ?
    // return e()*e() - pz()*pz();
    T massPerp2 = mt2();
    if (massPerp2 < 0)
	return -::sqrt(-massPerp2);
    else
	return ::sqrt(massPerp2);
}

template<class T>
void AliFmLorentzVector<T>::SetPx(T ax) {fThreeVector.SetX(ax);}

template<class T>
void AliFmLorentzVector<T>::SetPy(T ay) {fThreeVector.SetY(ay);}

template<class T>
void AliFmLorentzVector<T>::SetPz(T az) {fThreeVector.SetZ(az);}

template<class T>
void AliFmLorentzVector<T>::SetX(T ax) {fThreeVector.SetX(ax);}

template<class T>
void AliFmLorentzVector<T>::SetY(T ay) {fThreeVector.SetY(ay);}

template<class T>
void AliFmLorentzVector<T>::SetZ(T az) {fThreeVector.SetZ(az);}

template<class T>
void AliFmLorentzVector<T>::SetT(T at) {fX4 = at;}

template<class T>
void AliFmLorentzVector<T>::SetE(T ae) {fX4 = ae;}

template<class T>
T AliFmLorentzVector<T>::x() const {return fThreeVector.x();}

template<class T>
T AliFmLorentzVector<T>::y() const {return fThreeVector.y();}

template<class T>
T AliFmLorentzVector<T>::z() const {return fThreeVector.z();}

template<class T>
T AliFmLorentzVector<T>::px() const {return fThreeVector.x();}

template<class T>
T AliFmLorentzVector<T>::py() const {return fThreeVector.y();}

template<class T>
T AliFmLorentzVector<T>::pz() const {return fThreeVector.z();}

template<class T>
T AliFmLorentzVector<T>::e() const {return fX4;}

template<class T>
T AliFmLorentzVector<T>::t() const {return fX4;}

template<class T>
T AliFmLorentzVector<T>::Perp() const {return fThreeVector.Perp();}

template<class T>
T AliFmLorentzVector<T>::Perp2() const {return fThreeVector.Perp2();}

template<class T>
T AliFmLorentzVector<T>::PseudoRapidity() const {return fThreeVector.PseudoRapidity();}

template<class T>
T AliFmLorentzVector<T>::Phi() const {return fThreeVector.Phi();}

template<class T>
T AliFmLorentzVector<T>::Theta() const {return fThreeVector.Theta();}

template<class T>
T AliFmLorentzVector<T>::CosTheta() const {return fThreeVector.CosTheta();}

template<class T>
T AliFmLorentzVector<T>::operator() (size_t i) const
{
    if (i < 3)
        return fThreeVector(i);
    else if (i == 3)
        return fX4;
    else {
#ifndef ST_NO_EXCEPTIONS
      throw out_of_range("AliFmLorentzVector<T>::operator(): bad index");  
#else
      cerr << "AliFmLorentzVector<T>::operator(): bad index." << endl;
#endif
      return 0;
    }
}

template<class T>
T& AliFmLorentzVector<T>::operator() (size_t i)
{
    if (i < 3)
        return fThreeVector(i);
    else if (i == 3)
        return fX4;
    else {
#ifndef ST_NO_EXCEPTIONS
      throw out_of_range("AliFmLorentzVector<T>::operator(): bad index");  
#else
      cerr << "AliFmLorentzVector<T>::operator(): bad index." << endl;
      return fX4;
#endif
    }
}

template<class T>
T AliFmLorentzVector<T>::operator[] (size_t i) const
{
    if (i < 3)
        return fThreeVector[i];
    else if (i == 3)
        return fX4;
    else {
#ifndef ST_NO_EXCEPTIONS
      throw out_of_range("AliFmLorentzVector<T>::operator[]: bad index"); 
#else
      cerr << "AliFmLorentzVector<T>::operator[]: bad index." << endl;
      return 0;
#endif
    }
}

template<class T>
T& AliFmLorentzVector<T>::operator[] (size_t i)
{
    if (i < 3)
        return fThreeVector[i];
    else if (i == 3)
        return fX4;
    else {
#ifndef ST_NO_EXCEPTIONS
      throw out_of_range("AliFmLorentzVector<T>::operator[]: bad index"); 
#else
      cerr << "AliFmLorentzVector<T>::operator[]: bad index." << endl;
      return fX4;
#endif
    }
}

template<class T>
T AliFmLorentzVector<T>::Rapidity() const
{
    return 0.5*::log((fX4+fThreeVector.z())/(fX4-fThreeVector.z())+1e-20);
}

template<class T>
AliFmLorentzVector<T> AliFmLorentzVector<T>::operator- ()
{
    return AliFmLorentzVector<T>(-fX4,-fThreeVector);
}

template<class T>
AliFmLorentzVector<T> AliFmLorentzVector<T>::operator+ ()
{
    return *this;
}

template<class T>
AliFmLorentzVector<T>& AliFmLorentzVector<T>::operator*= (double c)
{
    fThreeVector *= c;
    fX4 *= c;
    return *this;
}

template<class T>
AliFmLorentzVector<T>& AliFmLorentzVector<T>::operator/= (double c)
{
    fThreeVector /= c;
    fX4 /= c;
    return *this;
}

#ifndef ST_NO_MEMBER_TEMPLATES
#ifndef WIN32

template<class T>
template<class X>
AliFmLorentzVector<T>::AliFmLorentzVector(const AliFmThreeVector<X> &vec, T at)
	: fThreeVector(vec), fX4(at) { /* nop */ }

template<class T>
template<class X>
AliFmLorentzVector<T>::AliFmLorentzVector(T at, const AliFmThreeVector<X> &vec)
	: fThreeVector(vec), fX4(at) { /* nop */ }

template<class T>
template<class X>
AliFmLorentzVector<T>::AliFmLorentzVector(const AliFmLorentzVector<X> &vec)
	: fThreeVector(vec.vect()), fX4(vec.t()) { /* nop */ }

template<class T>
template<class X>
AliFmLorentzVector<T>
AliFmLorentzVector<T>::boost(const AliFmLorentzVector<X>& pframe) const
{
    T mass               = abs(pframe);
    AliFmThreeVector<T> eta = (-1./mass)*pframe.vect();            // gamma*beta
    T gamma              = fabs(pframe.e())/mass;
    AliFmThreeVector<T> pl  = ((this->vect()*eta)/(eta*eta))*eta;  // longitudinal momentum
    return AliFmLorentzVector<T>(gamma*this->e() - this->vect()*eta,
                              this->vect() + (gamma-1.)*pl - this->e()*eta);
}

template<class T>
template<class X>
void AliFmLorentzVector<T>::SetVect(const AliFmThreeVector<X>& v)
{
    fThreeVector = v;
}

template<class T>
template<class X>
AliFmLorentzVector<T>&
AliFmLorentzVector<T>::operator=(const AliFmLorentzVector<X>& vec)
{
    fThreeVector = vec.vect();
    fX4 = vec.t();
    return *this;
}

template<class T>
template<class X>
bool
AliFmLorentzVector<T>::operator== (const AliFmLorentzVector<X>& v) const
{
    return (fThreeVector == v.vect()) && (fX4 == v.t());
}

template<class T>
template<class X>
bool
AliFmLorentzVector<T>::operator!= (const AliFmLorentzVector<X>& v) const
{
    return !(*this == v);
}

template<class T>
template<class X>
AliFmLorentzVector<T>&
AliFmLorentzVector<T>::operator+= (const AliFmLorentzVector<X>& v)
{
    fThreeVector += v.vect();
    fX4 += v.t();
    return *this;
}

template<class T>
template<class X>
AliFmLorentzVector<T>&
AliFmLorentzVector<T>::operator-= (const AliFmLorentzVector<X>& v)
{
    fThreeVector -= v.vect();
    fX4 -= v.t();
    return *this;
}

#endif 
#else

template<class T>
AliFmLorentzVector<T>::AliFmLorentzVector(const AliFmThreeVector<float> &vec, T t)
	: fThreeVector(vec), fX4(t) { /* nop */ }

template<class T>
AliFmLorentzVector<T>::AliFmLorentzVector(const AliFmThreeVector<double> &vec, T t)
	: fThreeVector(vec), fX4(t) { /* nop */ }

template<class T>
AliFmLorentzVector<T>::AliFmLorentzVector(T t, const AliFmThreeVector<float> &vec)
	: fThreeVector(vec), fX4(t) { /* nop */ }

template<class T>
AliFmLorentzVector<T>::AliFmLorentzVector(T t, const AliFmThreeVector<double> &vec)
	: fThreeVector(vec), fX4(t) { /* nop */ }

template<class T>
AliFmLorentzVector<T>::AliFmLorentzVector(const AliFmLorentzVector<float> &vec)
	: fThreeVector(vec.vect()), fX4(vec.t()) { /* nop */ }
    
template<class T>
AliFmLorentzVector<T>::AliFmLorentzVector(const AliFmLorentzVector<double> &vec)
	: fThreeVector(vec.vect()), fX4(vec.t()) { /* nop */ }
    
template<class T>
AliFmLorentzVector<T>
AliFmLorentzVector<T>::boost(const AliFmLorentzVector<float>& pframe) const
{
    T mass               = abs(pframe);
    AliFmThreeVector<T> eta = (-1./mass)*pframe.vect();            // gamma*beta
    T gamma              = fabs(pframe.e())/mass;
    AliFmThreeVector<T> pl  = ((this->vect()*eta)/(eta*eta))*eta;  // longitudinal momentum
    return AliFmLorentzVector<T>(gamma*this->e() - this->vect()*eta,
                              this->vect() + (gamma-1.)*pl - this->e()*eta);
}

template<class T>
AliFmLorentzVector<T>
AliFmLorentzVector<T>::boost(const AliFmLorentzVector<double>& pframe) const
{
    T mass               = abs(pframe);
    AliFmThreeVector<T> eta = (-1./mass)*pframe.vect();            // gamma*beta
    T gamma              = fabs(pframe.e())/mass;
    AliFmThreeVector<T> pl  = ((this->vect()*eta)/(eta*eta))*eta;  // longitudinal momentum
    return AliFmLorentzVector<T>(gamma*this->e() - this->vect()*eta,
                              this->vect() + (gamma-1.)*pl - this->e()*eta);
}

template<class T>
void AliFmLorentzVector<T>::SetVect(const AliFmThreeVector<float>& v)
{
    fThreeVector = v;
}

template<class T>
void AliFmLorentzVector<T>::SetVect(const AliFmThreeVector<double>& v)
{
    fThreeVector = v;
}

template<class T>
AliFmLorentzVector<T>&
AliFmLorentzVector<T>::operator=(const AliFmLorentzVector<float>& vec)
{
    fThreeVector = vec.vect();
    fX4 = vec.t();
    return *this;
}

template<class T>
AliFmLorentzVector<T>&
AliFmLorentzVector<T>::operator=(const AliFmLorentzVector<double>& vec)
{
    fThreeVector = vec.vect();
    fX4 = vec.t();
    return *this;
}

template<class T>
bool
AliFmLorentzVector<T>::operator== (const AliFmLorentzVector<float>& v) const
{
    return (this->vect() == v.vect()) && (fX4 == v.t());
}

template<class T>
bool
AliFmLorentzVector<T>::operator== (const AliFmLorentzVector<double>& v) const
{
    return (fThreeVector == v.vect()) && (fX4 == v.t());
}

template<class T>
bool
AliFmLorentzVector<T>::operator!= (const AliFmLorentzVector<float>& v) const
{
    return !(*this == v);
}

template<class T>
bool
AliFmLorentzVector<T>::operator!= (const AliFmLorentzVector<double>& v) const
{
    return !(*this == v);
}

template<class T>
AliFmLorentzVector<T>&
AliFmLorentzVector<T>::operator+= (const AliFmLorentzVector<float>& v)
{
    fThreeVector += v.vect();
    fX4 += v.t();
    return *this;
}

template<class T>
AliFmLorentzVector<T>&
AliFmLorentzVector<T>::operator+= (const AliFmLorentzVector<double>& v)
{
    fThreeVector += v.vect();
    fX4 += v.t();
    return *this;
}

template<class T>
AliFmLorentzVector<T>&
AliFmLorentzVector<T>::operator-= (const AliFmLorentzVector<float>& v)
{
    fThreeVector -= v.vect();
    fX4 -= v.t();
    return *this;
}

template<class T>
AliFmLorentzVector<T>&
AliFmLorentzVector<T>::operator-= (const AliFmLorentzVector<double>& v)
{
    fThreeVector -= v.vect();
    fX4 -= v.t();
    return *this;
}

#endif // ST_NO_MEMBER_TEMPLATES
#endif /* ! __CINT__ */
#ifdef __CINT__
template<> AliFmLorentzVector<double> operator+ (const AliFmLorentzVector<double>& v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<double> operator+ (const AliFmLorentzVector<double>& v1, const AliFmLorentzVector<float>& v2);
template<> AliFmLorentzVector<double> operator+ (const AliFmLorentzVector<float>&  v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<float>  operator+ (const AliFmLorentzVector<float>&  v1, const AliFmLorentzVector<float>& v2);
template<> AliFmLorentzVector<double> operator- (const AliFmLorentzVector<double>& v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<double> operator- (const AliFmLorentzVector<double>& v1, const AliFmLorentzVector<float>& v2);
template<> AliFmLorentzVector<double> operator- (const AliFmLorentzVector<float>&  v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<float>  operator- (const AliFmLorentzVector<float>&  v1, const AliFmLorentzVector<float>& v2);
template<> AliFmLorentzVector<double> operator* (const AliFmLorentzVector<double>& v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<double> operator* (const AliFmLorentzVector<double>& v1, const AliFmLorentzVector<float>& v2);
template<> AliFmLorentzVector<double> operator* (const AliFmLorentzVector<float>&  v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<float>  operator* (const AliFmLorentzVector<float>&  v1, const AliFmLorentzVector<float>& v2);
template<> AliFmLorentzVector<double> operator* (const              double v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<double> operator* (const              double v1, const AliFmLorentzVector<float>&  v2);
template<> AliFmLorentzVector<double> operator* (const AliFmLorentzVector<double>& v1, const double              v2);
template<> AliFmLorentzVector<double> operator* (const AliFmLorentzVector<float>&  v1, const double              v2);
template<> AliFmLorentzVector<double> operator/ (const AliFmLorentzVector<double>& v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<double> operator/ (const AliFmLorentzVector<double>& v1, const AliFmLorentzVector<float>& v2);
template<> AliFmLorentzVector<double> operator/ (const AliFmLorentzVector<float>&  v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<float>  operator/ (const AliFmLorentzVector<float>&  v1, const AliFmLorentzVector<float>& v2);
template<> AliFmLorentzVector<double> operator/ (const              double v1, const AliFmLorentzVector<double>& v2);
template<> AliFmLorentzVector<double> operator/ (const              double v1, const AliFmLorentzVector<float>&  v2);
template<> AliFmLorentzVector<double> operator/ (const AliFmLorentzVector<double>& v1, const double              v2);
template<> AliFmLorentzVector<double> operator/ (const AliFmLorentzVector<float>&  v1, const double              v2);
template<> istream& operator>> (istream& is, const AliFmLorentzVector<double>& v);
template<> ostream& operator<< (ostream& os, const AliFmLorentzVector<double>& v);
template<> istream& operator>> (istream& is, const AliFmLorentzVector<float>& v);
template<> ostream& operator<< (ostream& os, const AliFmLorentzVector<float>& v);
template<> double abs(const AliFmLorentzVector<double>& v);
template<> float  abs(const AliFmLorentzVector<float>& v);
#else
//
//   Non-member operators
//
template<class T, class X>
AliFmLorentzVector<T>
operator+ (const AliFmLorentzVector<T>& v1, const AliFmLorentzVector<X>& v2)
{
    return AliFmLorentzVector<T>(v1) += v2;
}

template<class T, class X>
AliFmLorentzVector<T>
operator- (const AliFmLorentzVector<T>& v1, const AliFmLorentzVector<X>& v2)
{
    return AliFmLorentzVector<T>(v1) -= v2;
}

template<class T, class X>
T
operator* (const AliFmLorentzVector<T>& v1, const AliFmLorentzVector<X>& v2)
{
    return v1.t()*v2.t() - v1.vect()*v2.vect();
}

template<class T>
AliFmLorentzVector<T>
operator* (const AliFmLorentzVector<T>& v, double c)
{
    return AliFmLorentzVector<T>(v) *= c;
}

template<class T>
AliFmLorentzVector<T> operator* (double c, const AliFmLorentzVector<T>& v)
{
    return AliFmLorentzVector<T>(v) *= c;
}

template<class T, class X>
AliFmLorentzVector<T> operator/ (const AliFmLorentzVector<T>& v, X c)
{
    return AliFmLorentzVector<T>(v) /= c;
}

template<class T>
ostream& operator<< (ostream& os, const AliFmLorentzVector<T>& v)
{
    return os << v.vect() << "\t\t" << v.t();
}

template<class T>
istream&  operator>>(istream& is, AliFmLorentzVector<T>& v)
{
    T  x, y, z, t;
    is >> x >> y >> z >> t;
    v.SetX(x);
    v.SetY(y);
    v.SetZ(z);
    v.SetT(t);
    return is;
}

//
//        Non-member functions
//
template<class T>
T abs(const AliFmLorentzVector<T>& v) {return v.m();}

#endif /*  __CINT__ */
#endif
 AliFmLorentzVector.h:1
 AliFmLorentzVector.h:2
 AliFmLorentzVector.h:3
 AliFmLorentzVector.h:4
 AliFmLorentzVector.h:5
 AliFmLorentzVector.h:6
 AliFmLorentzVector.h:7
 AliFmLorentzVector.h:8
 AliFmLorentzVector.h:9
 AliFmLorentzVector.h:10
 AliFmLorentzVector.h:11
 AliFmLorentzVector.h:12
 AliFmLorentzVector.h:13
 AliFmLorentzVector.h:14
 AliFmLorentzVector.h:15
 AliFmLorentzVector.h:16
 AliFmLorentzVector.h:17
 AliFmLorentzVector.h:18
 AliFmLorentzVector.h:19
 AliFmLorentzVector.h:20
 AliFmLorentzVector.h:21
 AliFmLorentzVector.h:22
 AliFmLorentzVector.h:23
 AliFmLorentzVector.h:24
 AliFmLorentzVector.h:25
 AliFmLorentzVector.h:26
 AliFmLorentzVector.h:27
 AliFmLorentzVector.h:28
 AliFmLorentzVector.h:29
 AliFmLorentzVector.h:30
 AliFmLorentzVector.h:31
 AliFmLorentzVector.h:32
 AliFmLorentzVector.h:33
 AliFmLorentzVector.h:34
 AliFmLorentzVector.h:35
 AliFmLorentzVector.h:36
 AliFmLorentzVector.h:37
 AliFmLorentzVector.h:38
 AliFmLorentzVector.h:39
 AliFmLorentzVector.h:40
 AliFmLorentzVector.h:41
 AliFmLorentzVector.h:42
 AliFmLorentzVector.h:43
 AliFmLorentzVector.h:44
 AliFmLorentzVector.h:45
 AliFmLorentzVector.h:46
 AliFmLorentzVector.h:47
 AliFmLorentzVector.h:48
 AliFmLorentzVector.h:49
 AliFmLorentzVector.h:50
 AliFmLorentzVector.h:51
 AliFmLorentzVector.h:52
 AliFmLorentzVector.h:53
 AliFmLorentzVector.h:54
 AliFmLorentzVector.h:55
 AliFmLorentzVector.h:56
 AliFmLorentzVector.h:57
 AliFmLorentzVector.h:58
 AliFmLorentzVector.h:59
 AliFmLorentzVector.h:60
 AliFmLorentzVector.h:61
 AliFmLorentzVector.h:62
 AliFmLorentzVector.h:63
 AliFmLorentzVector.h:64
 AliFmLorentzVector.h:65
 AliFmLorentzVector.h:66
 AliFmLorentzVector.h:67
 AliFmLorentzVector.h:68
 AliFmLorentzVector.h:69
 AliFmLorentzVector.h:70
 AliFmLorentzVector.h:71
 AliFmLorentzVector.h:72
 AliFmLorentzVector.h:73
 AliFmLorentzVector.h:74
 AliFmLorentzVector.h:75
 AliFmLorentzVector.h:76
 AliFmLorentzVector.h:77
 AliFmLorentzVector.h:78
 AliFmLorentzVector.h:79
 AliFmLorentzVector.h:80
 AliFmLorentzVector.h:81
 AliFmLorentzVector.h:82
 AliFmLorentzVector.h:83
 AliFmLorentzVector.h:84
 AliFmLorentzVector.h:85
 AliFmLorentzVector.h:86
 AliFmLorentzVector.h:87
 AliFmLorentzVector.h:88
 AliFmLorentzVector.h:89
 AliFmLorentzVector.h:90
 AliFmLorentzVector.h:91
 AliFmLorentzVector.h:92
 AliFmLorentzVector.h:93
 AliFmLorentzVector.h:94
 AliFmLorentzVector.h:95
 AliFmLorentzVector.h:96
 AliFmLorentzVector.h:97
 AliFmLorentzVector.h:98
 AliFmLorentzVector.h:99
 AliFmLorentzVector.h:100
 AliFmLorentzVector.h:101
 AliFmLorentzVector.h:102
 AliFmLorentzVector.h:103
 AliFmLorentzVector.h:104
 AliFmLorentzVector.h:105
 AliFmLorentzVector.h:106
 AliFmLorentzVector.h:107
 AliFmLorentzVector.h:108
 AliFmLorentzVector.h:109
 AliFmLorentzVector.h:110
 AliFmLorentzVector.h:111
 AliFmLorentzVector.h:112
 AliFmLorentzVector.h:113
 AliFmLorentzVector.h:114
 AliFmLorentzVector.h:115
 AliFmLorentzVector.h:116
 AliFmLorentzVector.h:117
 AliFmLorentzVector.h:118
 AliFmLorentzVector.h:119
 AliFmLorentzVector.h:120
 AliFmLorentzVector.h:121
 AliFmLorentzVector.h:122
 AliFmLorentzVector.h:123
 AliFmLorentzVector.h:124
 AliFmLorentzVector.h:125
 AliFmLorentzVector.h:126
 AliFmLorentzVector.h:127
 AliFmLorentzVector.h:128
 AliFmLorentzVector.h:129
 AliFmLorentzVector.h:130
 AliFmLorentzVector.h:131
 AliFmLorentzVector.h:132
 AliFmLorentzVector.h:133
 AliFmLorentzVector.h:134
 AliFmLorentzVector.h:135
 AliFmLorentzVector.h:136
 AliFmLorentzVector.h:137
 AliFmLorentzVector.h:138
 AliFmLorentzVector.h:139
 AliFmLorentzVector.h:140
 AliFmLorentzVector.h:141
 AliFmLorentzVector.h:142
 AliFmLorentzVector.h:143
 AliFmLorentzVector.h:144
 AliFmLorentzVector.h:145
 AliFmLorentzVector.h:146
 AliFmLorentzVector.h:147
 AliFmLorentzVector.h:148
 AliFmLorentzVector.h:149
 AliFmLorentzVector.h:150
 AliFmLorentzVector.h:151
 AliFmLorentzVector.h:152
 AliFmLorentzVector.h:153
 AliFmLorentzVector.h:154
 AliFmLorentzVector.h:155
 AliFmLorentzVector.h:156
 AliFmLorentzVector.h:157
 AliFmLorentzVector.h:158
 AliFmLorentzVector.h:159
 AliFmLorentzVector.h:160
 AliFmLorentzVector.h:161
 AliFmLorentzVector.h:162
 AliFmLorentzVector.h:163
 AliFmLorentzVector.h:164
 AliFmLorentzVector.h:165
 AliFmLorentzVector.h:166
 AliFmLorentzVector.h:167
 AliFmLorentzVector.h:168
 AliFmLorentzVector.h:169
 AliFmLorentzVector.h:170
 AliFmLorentzVector.h:171
 AliFmLorentzVector.h:172
 AliFmLorentzVector.h:173
 AliFmLorentzVector.h:174
 AliFmLorentzVector.h:175
 AliFmLorentzVector.h:176
 AliFmLorentzVector.h:177
 AliFmLorentzVector.h:178
 AliFmLorentzVector.h:179
 AliFmLorentzVector.h:180
 AliFmLorentzVector.h:181
 AliFmLorentzVector.h:182
 AliFmLorentzVector.h:183
 AliFmLorentzVector.h:184
 AliFmLorentzVector.h:185
 AliFmLorentzVector.h:186
 AliFmLorentzVector.h:187
 AliFmLorentzVector.h:188
 AliFmLorentzVector.h:189
 AliFmLorentzVector.h:190
 AliFmLorentzVector.h:191
 AliFmLorentzVector.h:192
 AliFmLorentzVector.h:193
 AliFmLorentzVector.h:194
 AliFmLorentzVector.h:195
 AliFmLorentzVector.h:196
 AliFmLorentzVector.h:197
 AliFmLorentzVector.h:198
 AliFmLorentzVector.h:199
 AliFmLorentzVector.h:200
 AliFmLorentzVector.h:201
 AliFmLorentzVector.h:202
 AliFmLorentzVector.h:203
 AliFmLorentzVector.h:204
 AliFmLorentzVector.h:205
 AliFmLorentzVector.h:206
 AliFmLorentzVector.h:207
 AliFmLorentzVector.h:208
 AliFmLorentzVector.h:209
 AliFmLorentzVector.h:210
 AliFmLorentzVector.h:211
 AliFmLorentzVector.h:212
 AliFmLorentzVector.h:213
 AliFmLorentzVector.h:214
 AliFmLorentzVector.h:215
 AliFmLorentzVector.h:216
 AliFmLorentzVector.h:217
 AliFmLorentzVector.h:218
 AliFmLorentzVector.h:219
 AliFmLorentzVector.h:220
 AliFmLorentzVector.h:221
 AliFmLorentzVector.h:222
 AliFmLorentzVector.h:223
 AliFmLorentzVector.h:224
 AliFmLorentzVector.h:225
 AliFmLorentzVector.h:226
 AliFmLorentzVector.h:227
 AliFmLorentzVector.h:228
 AliFmLorentzVector.h:229
 AliFmLorentzVector.h:230
 AliFmLorentzVector.h:231
 AliFmLorentzVector.h:232
 AliFmLorentzVector.h:233
 AliFmLorentzVector.h:234
 AliFmLorentzVector.h:235
 AliFmLorentzVector.h:236
 AliFmLorentzVector.h:237
 AliFmLorentzVector.h:238
 AliFmLorentzVector.h:239
 AliFmLorentzVector.h:240
 AliFmLorentzVector.h:241
 AliFmLorentzVector.h:242
 AliFmLorentzVector.h:243
 AliFmLorentzVector.h:244
 AliFmLorentzVector.h:245
 AliFmLorentzVector.h:246
 AliFmLorentzVector.h:247
 AliFmLorentzVector.h:248
 AliFmLorentzVector.h:249
 AliFmLorentzVector.h:250
 AliFmLorentzVector.h:251
 AliFmLorentzVector.h:252
 AliFmLorentzVector.h:253
 AliFmLorentzVector.h:254
 AliFmLorentzVector.h:255
 AliFmLorentzVector.h:256
 AliFmLorentzVector.h:257
 AliFmLorentzVector.h:258
 AliFmLorentzVector.h:259
 AliFmLorentzVector.h:260
 AliFmLorentzVector.h:261
 AliFmLorentzVector.h:262
 AliFmLorentzVector.h:263
 AliFmLorentzVector.h:264
 AliFmLorentzVector.h:265
 AliFmLorentzVector.h:266
 AliFmLorentzVector.h:267
 AliFmLorentzVector.h:268
 AliFmLorentzVector.h:269
 AliFmLorentzVector.h:270
 AliFmLorentzVector.h:271
 AliFmLorentzVector.h:272
 AliFmLorentzVector.h:273
 AliFmLorentzVector.h:274
 AliFmLorentzVector.h:275
 AliFmLorentzVector.h:276
 AliFmLorentzVector.h:277
 AliFmLorentzVector.h:278
 AliFmLorentzVector.h:279
 AliFmLorentzVector.h:280
 AliFmLorentzVector.h:281
 AliFmLorentzVector.h:282
 AliFmLorentzVector.h:283
 AliFmLorentzVector.h:284
 AliFmLorentzVector.h:285
 AliFmLorentzVector.h:286
 AliFmLorentzVector.h:287
 AliFmLorentzVector.h:288
 AliFmLorentzVector.h:289
 AliFmLorentzVector.h:290
 AliFmLorentzVector.h:291
 AliFmLorentzVector.h:292
 AliFmLorentzVector.h:293
 AliFmLorentzVector.h:294
 AliFmLorentzVector.h:295
 AliFmLorentzVector.h:296
 AliFmLorentzVector.h:297
 AliFmLorentzVector.h:298
 AliFmLorentzVector.h:299
 AliFmLorentzVector.h:300
 AliFmLorentzVector.h:301
 AliFmLorentzVector.h:302
 AliFmLorentzVector.h:303
 AliFmLorentzVector.h:304
 AliFmLorentzVector.h:305
 AliFmLorentzVector.h:306
 AliFmLorentzVector.h:307
 AliFmLorentzVector.h:308
 AliFmLorentzVector.h:309
 AliFmLorentzVector.h:310
 AliFmLorentzVector.h:311
 AliFmLorentzVector.h:312
 AliFmLorentzVector.h:313
 AliFmLorentzVector.h:314
 AliFmLorentzVector.h:315
 AliFmLorentzVector.h:316
 AliFmLorentzVector.h:317
 AliFmLorentzVector.h:318
 AliFmLorentzVector.h:319
 AliFmLorentzVector.h:320
 AliFmLorentzVector.h:321
 AliFmLorentzVector.h:322
 AliFmLorentzVector.h:323
 AliFmLorentzVector.h:324
 AliFmLorentzVector.h:325
 AliFmLorentzVector.h:326
 AliFmLorentzVector.h:327
 AliFmLorentzVector.h:328
 AliFmLorentzVector.h:329
 AliFmLorentzVector.h:330
 AliFmLorentzVector.h:331
 AliFmLorentzVector.h:332
 AliFmLorentzVector.h:333
 AliFmLorentzVector.h:334
 AliFmLorentzVector.h:335
 AliFmLorentzVector.h:336
 AliFmLorentzVector.h:337
 AliFmLorentzVector.h:338
 AliFmLorentzVector.h:339
 AliFmLorentzVector.h:340
 AliFmLorentzVector.h:341
 AliFmLorentzVector.h:342
 AliFmLorentzVector.h:343
 AliFmLorentzVector.h:344
 AliFmLorentzVector.h:345
 AliFmLorentzVector.h:346
 AliFmLorentzVector.h:347
 AliFmLorentzVector.h:348
 AliFmLorentzVector.h:349
 AliFmLorentzVector.h:350
 AliFmLorentzVector.h:351
 AliFmLorentzVector.h:352
 AliFmLorentzVector.h:353
 AliFmLorentzVector.h:354
 AliFmLorentzVector.h:355
 AliFmLorentzVector.h:356
 AliFmLorentzVector.h:357
 AliFmLorentzVector.h:358
 AliFmLorentzVector.h:359
 AliFmLorentzVector.h:360
 AliFmLorentzVector.h:361
 AliFmLorentzVector.h:362
 AliFmLorentzVector.h:363
 AliFmLorentzVector.h:364
 AliFmLorentzVector.h:365
 AliFmLorentzVector.h:366
 AliFmLorentzVector.h:367
 AliFmLorentzVector.h:368
 AliFmLorentzVector.h:369
 AliFmLorentzVector.h:370
 AliFmLorentzVector.h:371
 AliFmLorentzVector.h:372
 AliFmLorentzVector.h:373
 AliFmLorentzVector.h:374
 AliFmLorentzVector.h:375
 AliFmLorentzVector.h:376
 AliFmLorentzVector.h:377
 AliFmLorentzVector.h:378
 AliFmLorentzVector.h:379
 AliFmLorentzVector.h:380
 AliFmLorentzVector.h:381
 AliFmLorentzVector.h:382
 AliFmLorentzVector.h:383
 AliFmLorentzVector.h:384
 AliFmLorentzVector.h:385
 AliFmLorentzVector.h:386
 AliFmLorentzVector.h:387
 AliFmLorentzVector.h:388
 AliFmLorentzVector.h:389
 AliFmLorentzVector.h:390
 AliFmLorentzVector.h:391
 AliFmLorentzVector.h:392
 AliFmLorentzVector.h:393
 AliFmLorentzVector.h:394
 AliFmLorentzVector.h:395
 AliFmLorentzVector.h:396
 AliFmLorentzVector.h:397
 AliFmLorentzVector.h:398
 AliFmLorentzVector.h:399
 AliFmLorentzVector.h:400
 AliFmLorentzVector.h:401
 AliFmLorentzVector.h:402
 AliFmLorentzVector.h:403
 AliFmLorentzVector.h:404
 AliFmLorentzVector.h:405
 AliFmLorentzVector.h:406
 AliFmLorentzVector.h:407
 AliFmLorentzVector.h:408
 AliFmLorentzVector.h:409
 AliFmLorentzVector.h:410
 AliFmLorentzVector.h:411
 AliFmLorentzVector.h:412
 AliFmLorentzVector.h:413
 AliFmLorentzVector.h:414
 AliFmLorentzVector.h:415
 AliFmLorentzVector.h:416
 AliFmLorentzVector.h:417
 AliFmLorentzVector.h:418
 AliFmLorentzVector.h:419
 AliFmLorentzVector.h:420
 AliFmLorentzVector.h:421
 AliFmLorentzVector.h:422
 AliFmLorentzVector.h:423
 AliFmLorentzVector.h:424
 AliFmLorentzVector.h:425
 AliFmLorentzVector.h:426
 AliFmLorentzVector.h:427
 AliFmLorentzVector.h:428
 AliFmLorentzVector.h:429
 AliFmLorentzVector.h:430
 AliFmLorentzVector.h:431
 AliFmLorentzVector.h:432
 AliFmLorentzVector.h:433
 AliFmLorentzVector.h:434
 AliFmLorentzVector.h:435
 AliFmLorentzVector.h:436
 AliFmLorentzVector.h:437
 AliFmLorentzVector.h:438
 AliFmLorentzVector.h:439
 AliFmLorentzVector.h:440
 AliFmLorentzVector.h:441
 AliFmLorentzVector.h:442
 AliFmLorentzVector.h:443
 AliFmLorentzVector.h:444
 AliFmLorentzVector.h:445
 AliFmLorentzVector.h:446
 AliFmLorentzVector.h:447
 AliFmLorentzVector.h:448
 AliFmLorentzVector.h:449
 AliFmLorentzVector.h:450
 AliFmLorentzVector.h:451
 AliFmLorentzVector.h:452
 AliFmLorentzVector.h:453
 AliFmLorentzVector.h:454
 AliFmLorentzVector.h:455
 AliFmLorentzVector.h:456
 AliFmLorentzVector.h:457
 AliFmLorentzVector.h:458
 AliFmLorentzVector.h:459
 AliFmLorentzVector.h:460
 AliFmLorentzVector.h:461
 AliFmLorentzVector.h:462
 AliFmLorentzVector.h:463
 AliFmLorentzVector.h:464
 AliFmLorentzVector.h:465
 AliFmLorentzVector.h:466
 AliFmLorentzVector.h:467
 AliFmLorentzVector.h:468
 AliFmLorentzVector.h:469
 AliFmLorentzVector.h:470
 AliFmLorentzVector.h:471
 AliFmLorentzVector.h:472
 AliFmLorentzVector.h:473
 AliFmLorentzVector.h:474
 AliFmLorentzVector.h:475
 AliFmLorentzVector.h:476
 AliFmLorentzVector.h:477
 AliFmLorentzVector.h:478
 AliFmLorentzVector.h:479
 AliFmLorentzVector.h:480
 AliFmLorentzVector.h:481
 AliFmLorentzVector.h:482
 AliFmLorentzVector.h:483
 AliFmLorentzVector.h:484
 AliFmLorentzVector.h:485
 AliFmLorentzVector.h:486
 AliFmLorentzVector.h:487
 AliFmLorentzVector.h:488
 AliFmLorentzVector.h:489
 AliFmLorentzVector.h:490
 AliFmLorentzVector.h:491
 AliFmLorentzVector.h:492
 AliFmLorentzVector.h:493
 AliFmLorentzVector.h:494
 AliFmLorentzVector.h:495
 AliFmLorentzVector.h:496
 AliFmLorentzVector.h:497
 AliFmLorentzVector.h:498
 AliFmLorentzVector.h:499
 AliFmLorentzVector.h:500
 AliFmLorentzVector.h:501
 AliFmLorentzVector.h:502
 AliFmLorentzVector.h:503
 AliFmLorentzVector.h:504
 AliFmLorentzVector.h:505
 AliFmLorentzVector.h:506
 AliFmLorentzVector.h:507
 AliFmLorentzVector.h:508
 AliFmLorentzVector.h:509
 AliFmLorentzVector.h:510
 AliFmLorentzVector.h:511
 AliFmLorentzVector.h:512
 AliFmLorentzVector.h:513
 AliFmLorentzVector.h:514
 AliFmLorentzVector.h:515
 AliFmLorentzVector.h:516
 AliFmLorentzVector.h:517
 AliFmLorentzVector.h:518
 AliFmLorentzVector.h:519
 AliFmLorentzVector.h:520
 AliFmLorentzVector.h:521
 AliFmLorentzVector.h:522
 AliFmLorentzVector.h:523
 AliFmLorentzVector.h:524
 AliFmLorentzVector.h:525
 AliFmLorentzVector.h:526
 AliFmLorentzVector.h:527
 AliFmLorentzVector.h:528
 AliFmLorentzVector.h:529
 AliFmLorentzVector.h:530
 AliFmLorentzVector.h:531
 AliFmLorentzVector.h:532
 AliFmLorentzVector.h:533
 AliFmLorentzVector.h:534
 AliFmLorentzVector.h:535
 AliFmLorentzVector.h:536
 AliFmLorentzVector.h:537
 AliFmLorentzVector.h:538
 AliFmLorentzVector.h:539
 AliFmLorentzVector.h:540
 AliFmLorentzVector.h:541
 AliFmLorentzVector.h:542
 AliFmLorentzVector.h:543
 AliFmLorentzVector.h:544
 AliFmLorentzVector.h:545
 AliFmLorentzVector.h:546
 AliFmLorentzVector.h:547
 AliFmLorentzVector.h:548
 AliFmLorentzVector.h:549
 AliFmLorentzVector.h:550
 AliFmLorentzVector.h:551
 AliFmLorentzVector.h:552
 AliFmLorentzVector.h:553
 AliFmLorentzVector.h:554
 AliFmLorentzVector.h:555
 AliFmLorentzVector.h:556
 AliFmLorentzVector.h:557
 AliFmLorentzVector.h:558
 AliFmLorentzVector.h:559
 AliFmLorentzVector.h:560
 AliFmLorentzVector.h:561
 AliFmLorentzVector.h:562
 AliFmLorentzVector.h:563
 AliFmLorentzVector.h:564
 AliFmLorentzVector.h:565
 AliFmLorentzVector.h:566
 AliFmLorentzVector.h:567
 AliFmLorentzVector.h:568
 AliFmLorentzVector.h:569
 AliFmLorentzVector.h:570
 AliFmLorentzVector.h:571
 AliFmLorentzVector.h:572
 AliFmLorentzVector.h:573
 AliFmLorentzVector.h:574
 AliFmLorentzVector.h:575
 AliFmLorentzVector.h:576
 AliFmLorentzVector.h:577
 AliFmLorentzVector.h:578
 AliFmLorentzVector.h:579
 AliFmLorentzVector.h:580
 AliFmLorentzVector.h:581
 AliFmLorentzVector.h:582
 AliFmLorentzVector.h:583
 AliFmLorentzVector.h:584
 AliFmLorentzVector.h:585
 AliFmLorentzVector.h:586
 AliFmLorentzVector.h:587
 AliFmLorentzVector.h:588
 AliFmLorentzVector.h:589
 AliFmLorentzVector.h:590
 AliFmLorentzVector.h:591
 AliFmLorentzVector.h:592
 AliFmLorentzVector.h:593
 AliFmLorentzVector.h:594
 AliFmLorentzVector.h:595
 AliFmLorentzVector.h:596
 AliFmLorentzVector.h:597
 AliFmLorentzVector.h:598
 AliFmLorentzVector.h:599
 AliFmLorentzVector.h:600
 AliFmLorentzVector.h:601
 AliFmLorentzVector.h:602
 AliFmLorentzVector.h:603
 AliFmLorentzVector.h:604
 AliFmLorentzVector.h:605
 AliFmLorentzVector.h:606
 AliFmLorentzVector.h:607
 AliFmLorentzVector.h:608
 AliFmLorentzVector.h:609
 AliFmLorentzVector.h:610
 AliFmLorentzVector.h:611
 AliFmLorentzVector.h:612
 AliFmLorentzVector.h:613
 AliFmLorentzVector.h:614
 AliFmLorentzVector.h:615
 AliFmLorentzVector.h:616
 AliFmLorentzVector.h:617
 AliFmLorentzVector.h:618
 AliFmLorentzVector.h:619
 AliFmLorentzVector.h:620
 AliFmLorentzVector.h:621
 AliFmLorentzVector.h:622
 AliFmLorentzVector.h:623
 AliFmLorentzVector.h:624
 AliFmLorentzVector.h:625
 AliFmLorentzVector.h:626
 AliFmLorentzVector.h:627
 AliFmLorentzVector.h:628
 AliFmLorentzVector.h:629
 AliFmLorentzVector.h:630
 AliFmLorentzVector.h:631
 AliFmLorentzVector.h:632
 AliFmLorentzVector.h:633
 AliFmLorentzVector.h:634
 AliFmLorentzVector.h:635
 AliFmLorentzVector.h:636
 AliFmLorentzVector.h:637
 AliFmLorentzVector.h:638
 AliFmLorentzVector.h:639
 AliFmLorentzVector.h:640
 AliFmLorentzVector.h:641
 AliFmLorentzVector.h:642
 AliFmLorentzVector.h:643
 AliFmLorentzVector.h:644
 AliFmLorentzVector.h:645
 AliFmLorentzVector.h:646
 AliFmLorentzVector.h:647
 AliFmLorentzVector.h:648
 AliFmLorentzVector.h:649
 AliFmLorentzVector.h:650
 AliFmLorentzVector.h:651
 AliFmLorentzVector.h:652
 AliFmLorentzVector.h:653
 AliFmLorentzVector.h:654
 AliFmLorentzVector.h:655
 AliFmLorentzVector.h:656
 AliFmLorentzVector.h:657
 AliFmLorentzVector.h:658
 AliFmLorentzVector.h:659
 AliFmLorentzVector.h:660
 AliFmLorentzVector.h:661
 AliFmLorentzVector.h:662
 AliFmLorentzVector.h:663
 AliFmLorentzVector.h:664
 AliFmLorentzVector.h:665
 AliFmLorentzVector.h:666
 AliFmLorentzVector.h:667
 AliFmLorentzVector.h:668
 AliFmLorentzVector.h:669
 AliFmLorentzVector.h:670
 AliFmLorentzVector.h:671
 AliFmLorentzVector.h:672
 AliFmLorentzVector.h:673
 AliFmLorentzVector.h:674
 AliFmLorentzVector.h:675
 AliFmLorentzVector.h:676
 AliFmLorentzVector.h:677
 AliFmLorentzVector.h:678
 AliFmLorentzVector.h:679
 AliFmLorentzVector.h:680
 AliFmLorentzVector.h:681
 AliFmLorentzVector.h:682
 AliFmLorentzVector.h:683
 AliFmLorentzVector.h:684
 AliFmLorentzVector.h:685
 AliFmLorentzVector.h:686
 AliFmLorentzVector.h:687
 AliFmLorentzVector.h:688
 AliFmLorentzVector.h:689
 AliFmLorentzVector.h:690
 AliFmLorentzVector.h:691
 AliFmLorentzVector.h:692
 AliFmLorentzVector.h:693
 AliFmLorentzVector.h:694
 AliFmLorentzVector.h:695
 AliFmLorentzVector.h:696
 AliFmLorentzVector.h:697
 AliFmLorentzVector.h:698
 AliFmLorentzVector.h:699
 AliFmLorentzVector.h:700
 AliFmLorentzVector.h:701
 AliFmLorentzVector.h:702
 AliFmLorentzVector.h:703
 AliFmLorentzVector.h:704
 AliFmLorentzVector.h:705
 AliFmLorentzVector.h:706
 AliFmLorentzVector.h:707
 AliFmLorentzVector.h:708
 AliFmLorentzVector.h:709
 AliFmLorentzVector.h:710
 AliFmLorentzVector.h:711
 AliFmLorentzVector.h:712
 AliFmLorentzVector.h:713
 AliFmLorentzVector.h:714
 AliFmLorentzVector.h:715
 AliFmLorentzVector.h:716
 AliFmLorentzVector.h:717
 AliFmLorentzVector.h:718
 AliFmLorentzVector.h:719
 AliFmLorentzVector.h:720
 AliFmLorentzVector.h:721
 AliFmLorentzVector.h:722
 AliFmLorentzVector.h:723
 AliFmLorentzVector.h:724
 AliFmLorentzVector.h:725
 AliFmLorentzVector.h:726
 AliFmLorentzVector.h:727
 AliFmLorentzVector.h:728
 AliFmLorentzVector.h:729
 AliFmLorentzVector.h:730
 AliFmLorentzVector.h:731
 AliFmLorentzVector.h:732
 AliFmLorentzVector.h:733
 AliFmLorentzVector.h:734
 AliFmLorentzVector.h:735
 AliFmLorentzVector.h:736
 AliFmLorentzVector.h:737
 AliFmLorentzVector.h:738
 AliFmLorentzVector.h:739
 AliFmLorentzVector.h:740
 AliFmLorentzVector.h:741