class HPidTrackCand: public TObject

_HADES_CLASS_DESCRIPTION



 HPidTrackCand

 In this container matched hits from all detectors are stored.
 The class does not define the algorithm how the matching is done.
 This is defined in HMetaMatch (coarse matching) and HPidTrackFiller (refined
 matching taking into account momentum values.

 The structure of this class allows user to store information about
 the correlated hits as well as information about all hits in neighborhood
 of hits which contribute to the track candidate. The hits in
 the neighborhood are dedicated for identification close pairs
 as it was discussed at the PID subgroup meeting.
 ATTENTION: THE HANDLING OF CLOSE BY HITS IS NOT YET IMPKLEMENTED
 THE CLASS ONLY STORES THE DISTANCE OF THE CLOSEST HADRON AND LEPTON CANDIDATES!



 Track Cleaner flags
 To clean the PidTrackCand objects from unwanted fakes
 the object carries a bitfield (32 bit Int_t). The different
 qualitiy criteria can be used to select the best reconstructed
 candidate in the case of multiple use of single detector hits.
 The single bit numbers are defined by

enum EflagBits {kIsDoubleHitRICH       =  0,
kIsDoubleHitInnerMDC   =  1,
kIsDoubleHitOuterMDC   =  2,
	            kIsDoubleHitMETA       =  3,    

	            kIsBestHitRICH         =  4,    //  (by number of pads)
	            kIsBestHitInnerMDC     =  5,    //  (by chi2)
	            kIsBestHitOuterMDC     =  6,    //  (by chi2)
	            kIsBestHitMETA         =  7,    //  (by META match quality)

	            kIsBestRKMETA          =  8,    //  (by RK META match quality)
                  kIsBestRKRICH          =  9,    //  (by RK RICH match quality)
	            kIsBestRK              = 10,    //  (by RK chi2, none fitted outer segments with lower priority)
		    kIsBestSPLINE          = 11,    //  (by chi2)
	            kIsBestKICK            = 12,    //  (by pull)
	            kIsBestRKRKMETA        = 13,    //  (by RK chi2 * RK META match quality)
	            kIsBestRKRKRICH        = 14,     // (by RK chi2 * RK RICH match quality)
	            kIsBestRKMETAQA        = 15,     // (by RK chi2 * META match quality)

	            kIsAcceptedHitRICH     = 16,    // remember if the hit was been taken into account
	            kIsAcceptedHitInnerMDC = 17,    
kIsAcceptedHitOuterMDC = 18,
	            kIsAcceptedHitMETA     = 19,    
	            kIsAcceptedRKMETA      = 20,    
	            kIsAcceptedRKRICH      = 21,    
	            kIsAcceptedRK          = 22,    
	            kIsAcceptedSPLINE      = 23,    
	            kIsAcceptedKICK        = 24,    
	            kIsAcceptedRKRKMETA    = 25,    
	            kIsAcceptedRKRKRICH    = 26,    
	            kIsAcceptedRKMETAQA    = 27,    
                  kIsLepton              = 29,    //  mark the selected leptons
	            kIsUsed                = 30,    //  mark the object as arleady used
	            kIsRejected            = 31     //  mark the object as rejected

  };

  The selection of tracks and setting of the corresponding flags is performed
  by HPidTrackCleaner and HPidTrackSorter classes (see the documentation).

  For example void  setFlagBit(HPidTrackCand::kIsDoubleRICH) sets the bit flag that
  the RICH hit has been used in more than one HPidTrackCand object.
  Correspondingly one can ask for the flag with Bool_t isFlagBit(HPidTrackCand::kIsDoubleRICH)
  void   setFlagBit(Int_t bit) and  Bool_t isFlagBit(Int_t bit) works for the bitnumber (0-31) specified
  manually (if one knows what one is doing....)
  void   setFlagBit   (EflagBits bit)
  void   unsetFlagBit (EflagBits bit)
  Bool_t isFlagBit    (EflagBits bit)
  void   setFlagBit   (Int_t bit);
  void   unsetFlagBit (Int_t bit);
  Bool_t isFlagBit    (Int_t bit);
  void   setFlagBitByValue(EflagBits bit, Bool_t val) sets/unsets bit depending on val
  void   setFlagBitByValue(Int_t     bit, Bool_t val) sets/unsets bit depending on val
  Bool_t isFlagDoubleHit ()           check all Double_t hits flags simultanously (false if none set)
  Bool_t isFlagAllBestHit()           check all best hit flags simultanously    (true if all are set)
  Int_t  getDoubleHitsLeptons() returns the 4 bit Double_t hit word as Int_t //  Int_t  getDoubleHitsHadrons() returns the 3 bit Double_t hit word (excluding RICH) as Int_t //  Bool_t isFlagNoBestHit ()           check all best hit flags simultanously    (true if none set)
  Int_t  getFlagField()               do what you want with flags field
  Bool_t isFlagAND(Int_t num,Int_t fl, ...) check all flags in argument simultanously (false if none set)
  Bool_t isFlagOR(Int_t num,Int_t fl, ...)  check all flags in argument simultanously (true if any set)
  void   printFlags(TString comment="") prints all flags in binary representation.
  void   printInfo()                    prints indices of detector hits + quality criteria + flags

  The function
  Bool_t select(Bool_t (*function)(HPidTrackCand* ))  { return  (*function)(this); }
  taking a pointer to function with argument HPidTrackCand* returning a Bool_t allows
  todo complex selection on the HPidTrackCand object as one has
  full access to all members of HPidTrackCand inside the test function.
  The function pointer can be a pointer to a global function or member function
  of an Object for example:

  Bool_t test(HPidTrackCand* cand){               // global function
           if ( put all selection criteria here ) return kTRUE;
           else                                   return kFALSE;
  } or

  static Bool_t dummy::test(HPidTrackCand* cand){   // member function of object dummy
                                                    // needs to be declared static !
           if ( put all selection criteria here ) return kTRUE;
           else                                   return kFALSE;
  }
  would be called in the code like

  dummy d;
  HPidTrackCand* p= new HPidTrackCand() // just to get an object
  p->select(test))        // global function
  p->select(dummy::test)) // member function of object dummy (static call without object creation)
  p->select(d.test))      // member function of real object dummy