MFormulary

class MFormulary : public TMath

    public:

           MFormulary MFormulary()
           MFormulary MFormulary(MFormulary&)
         virtual void ~MFormulary()
             Double_t Abs(const Double_t* p, Int_t dim)
             Double_t Angle(const Double_t* x1, const Double_t* x2, Int_t dim = 3)
             Double_t C()
       static TClass* Class()
                 void Diff(const Double_t* p1, const Double_t* p2, Double_t* P, Int_t n)
             Double_t Dist(const Double_t* p1, const Double_t* p2, Int_t dim)
             Double_t Dist_squared(const Double_t* p1, const Double_t* p2, Int_t dim)
             Double_t Energy(const Double_t* p)
             Double_t Eta(const Double_t* p, const Char_t t)
             Double_t Eta(const Double_t* y, const Double_t* mt, const Double_t* m)
             Double_t Gamma(const Double_t* v)
             Double_t InvDist(const Double_t* x1, const Double_t* x2)
             Double_t InvDist_squared(const Double_t* x1, const Double_t* x2)
      virtual TClass* IsA() const
                 void Lorentz(const Double_t* v, Double_t* p)
                 void LorentzBoost(const Double_t* x, Double_t* x_prime, const Double_t* v)
             Double_t Mt(const Double_t* m, const Double_t* pt)
             Double_t N_charged(Double_t* s)
                 void Pq(const Double_t* p, const Double_t* q, Double_t* x)
             Double_t Pt(const Double_t* p)
             Double_t RelativisticScalarProd(const Double_t* x1, const Double_t* x2)
             Double_t RelativisticSum(const Double_t* v1, const Double_t* v2)
             Double_t S(const Double_t* p_a, const Double_t* p_b)
             Double_t ScalarProd(const Double_t* a, const Double_t* b, Int_t dim)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
             Double_t Sigma_el_pp(Double_t* p)
             Double_t Sigma_tot_pp(Double_t* p)
             Double_t Square(const Double_t* p, Int_t dim)
         virtual void Streamer(TBuffer& b)
                 void Sum(const Double_t* p1, const Double_t* p2, Double_t* P, Int_t n)
             Double_t T(const Double_t* p_a, const Double_t* p_c)
             Double_t U(const Double_t* p_a, const Double_t* p_d)
                 void VectorProd(const Double_t* a, const Double_t* b, Double_t* c)
             Double_t Y(const Double_t* p, const Char_t t)
             Double_t Y(const Double_t* eta, const Double_t* pt, const Double_t* m)

  Data Members

Class Description

 MFormulary                                                                
                                                                           
 The MFormulary class improves the TMath class by adding some often used   
 functions, constants, and calulations, especially for physicists,         
 i.e. for me :)                                                            

 Constructor. Creates a MFormulary object.

 MFormulary destructor.

 Calculates the transverse mass of a particle with a given mass and
 transverse momentum.

 Calculates the transverse momentum of a particle with a given momentum.

 Calculates the rapidity y. In the second argument you have to specify
 the nature of the first argument:
                        v for an ordinary velocity
                        b for betha, the velocity in units of c
                     or p for a four-momentum

 Calculates the rapidity of a particle with a given pseudorapidity eta,
 transverse momentum pt, and mass m.

 Calculates the pseudorapidity eta. In the second argument you have
 to specify the nature of the first argument:
                               a for the angle of the particle relative
                                 to the beam axis
                            or p for the (three dimensional) momentum

 Calculates the pseudorapidity of a particle with a given rapidity y,
 transverse mass mt, and mass m.

 Calculates with the given four momentum the energy of an particle.

 Calculates gamma for a given velocity (v has to be in units of c!).

 Calculates the sum of two velocities with respect to the special
 relativity. The function will return a warning if at least one of the
 input velocities is greater than c, but regardless of that it will
 return the (mathematically correct, but non-physical) result.

 This function returns the relativistic invariant distance squared of
 two four vectors.

 This function returns the relativistic invariant distance of two four vectors.
 It gives a warning, if the result inherits a factor i, but it will still
 return a value which is the result divided by i.

 This function returns the scalar product of two four vectors in Minkowsky metrik.

 Lorentz transform for a given velocity in the direction of the x-axis.

 Calculates a Lorentz boost with the given velocity v of the input four
 vector x. The result is stored in x_prime.

 Returns the square of the center of mass energy of two colliding particles
 with the four momenta p_a and p_b. This is the Mandelstam variable s.

 Calculates the Mandelstam variable t.

 This is the Mandelstam variable u.

 This function calculates the total cross section of a proton-proton-reaction.
 p specifies the momentum of the incident proton in the laboratory frame.
 The result is in units of mb, the momentum has to be in GeV.
 The formula applies only for high energies!

 This function calculates the elastic cross section of a proton-proton-reaction.
 p specifies the momentum of the incident proton in the laboratory frame.
 The result is in units of mb, the momentum has to be in GeV.
 The formula applies only for high energies!

 This function calculates the charged multiplicity of a proton-proton collision
 at high energies. s specifies the center of mass energy squared (!) in GeV^2.

 Calculates the x(y=0)-values of a parabola of the form
 x^2 + p * x + q = 0.

 Returns the angle between to vectors (in dim dimensions).

 Calculates the distance squared of two points in euclidian geometry.

 Calculates the distance of two points in euclidian geometry.

 Calculates the (euclidian) vector product of two vectors in three dimensions.

 Calculates the (euclidian) scalar product of two vectors

 Calculates the scalar product of the given vector with itself.

 Calculates the sum of the two n-dimensional vectors and stores the
 result in the vector P.

 Calculates the difference of the two n-dimensional vectors and stores the
 result in the vector P.

 Calculates the length of a vector in ordinary euclidian geometry.

Inline Functions

           Double_t C()
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
         MFormulary MFormulary(MFormulary&)