HKickMassFit

class HKickMassFit : public TObject

    protected:

      Double_t snap(Double_t mass, Double_t errMass)

    public:

                      HKickMassFit()
                      HKickMassFit(const HKickMassFit&)
                      ~HKickMassFit()
       static TClass* Class()
                 void fitMomentum(Double_t p0, Double_t errP0, Double_t beta, Double_t errBeta, Int_t polarity)
             Double_t getMass()
             Double_t getMomentum()
             Double_t getMomentumErr()
               Char_t getPID()
             Double_t getTolerance()
      virtual TClass* IsA() const
        HKickMassFit& operator=(const HKickMassFit&)
                 void setTolerance(Double_t t)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)

Data Members

    protected:

             Double_t fMomentum       
             Double_t fMomentumErr    
             Double_t fTolerance      
             Double_t fMass           
                Int_t fPolarity       
               Char_t fPid            
      static Double_t fMassTable[10]  
        static Char_t fPidTable[10]   

Class Description

 HKickMassFit

   This class makes both particle identification and a inverse
kinematics momentum fit.

   There is a table of masses for known particles defined in the class.
When a user calls fitMomentum giving a mass and a velocity, that mass is
compared to each of the masses in the table.

   If the mass given by the user is compatible with one and only one of the
masses in the table then the corresponding Id is assigned to the particle,
as a second step the momentum of this particlei, determined from its real mass
(the one in the table) and the given velocity, is calculated.

   To check if a mass is compatible with one of those in the table the
following criterium is used

    (mass - mass_table) / error_in_mass  <  tolerance

   Where tolerance is a parameter of the class with the default value of 3.

   The table of masses consists of two static arrays: fMassTable and
fPidTable. The first table is an array of known masses plus one last element
which always equals -1 and signals the end of the table.

   Each of the entries in the fMassTable array corresponds to two entries in
fPidTable which are the two types of particles with that mass: first is
positive charged and second is negative charged.

 Constructor

Obvious

 This is the core method: a initial momentum is provided together with
 a velocity and the corresponding errors. Also a polarity (sign of charge)
 is given as an argument.

  The method will identify the particle and calculate the corresponding
PID and a new value for the momentum. Those results can be retrieved
using other class methods later

Looks which mass in the mass table is compatible with the given one
 withing the errors.

Inline Functions

                 void setTolerance(Double_t t)
             Double_t getMass()
             Double_t getMomentum()
             Double_t getMomentumErr()
             Double_t getTolerance()
               Char_t getPID()
              TClass* Class()
              TClass* IsA() const
                 void ShowMembers(TMemberInspector& insp, char* parent)
                 void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)
         HKickMassFit HKickMassFit(const HKickMassFit&)
        HKickMassFit& operator=(const HKickMassFit&)