HHypList

class HHypList : public TObject

    public:

                        HHypList()
                        HHypList(HHypList* HypList, Int_t IdxHypKine = -1)
                        HHypList(HHypComb* HypComb, Int_t IdxHypKine = -1)
                        HHypList(Int_t Idx_HypComb, Int_t IdxHypKine = -1)
                        HHypList(const HHypList&)
                        ~HHypList()
      static HCategory* buildLinearCat(Text_t* Calssname)
         static TClass* Class()
           virtual void Clear(Option_t* opt)
                 Bool_t CombIterator()
                 Bool_t CombIteratorReset()
                Float_t getBeta(char* name, Int_t num)
                Float_t getBeta(Int_t Icomb, Int_t Ipart)
                Float_t getBeta(Int_t Ipart)
                  Int_t getIdxHypComb()
                  Int_t getIdxHypKine()
                  Int_t getIdxPidPart(Int_t Icomb, Int_t Ipart)
                  Int_t getIdxPidPart(Int_t Ipart)
                  Int_t getIdxPidPart(char* name, Int_t)
                 Bool_t getIterStatus()
                  Int_t getListId()
               TVector3 getMomentum(Int_t Ipart)
               TVector3 getMomentum(Int_t Icomb, Int_t Ipart)
                  Int_t getNcomb()
                  Int_t getNpart()
                  Int_t getOrder()
              HHypList* getParent()
                  Int_t getPid(Int_t Icomb, Int_t Ipart)
                  Int_t getPid(Int_t Ipart)
          HPidParticle* getPidParticle(Int_t Ipart)
                Float_t getProbAlg(Int_t Icomb)
                Float_t getProbAlg()
                Float_t getProbComb(Int_t Icomb)
         TLorentzVector getTLorentzVector(Int_t Icomb, Int_t Ipart)
         TLorentzVector getTLorentzVector(char*, Int_t)
         TLorentzVector getTLorentzVector(Int_t Ipart)
                 Bool_t getUserValue(Int_t valueID, Float_t& value, Int_t my_iter = -1)
                 Bool_t initcopyMomentum()
        virtual TClass* IsA() const
                 Bool_t Join(HHypList* addthis)
                   void KeepBestComb()
              HHypList& operator=(const HHypList&)
                 Bool_t prepareHypList()
                 Bool_t print()
                 Bool_t ReadNumberedUserValues(Int_t i, Int_t& my_iter, Int_t& valueID, Float_t& value)
                   void removeComb()
                 Bool_t resetProbAlg(Float_t Prob)
                   void Restore()
                 Bool_t setIdxHypComb(Int_t Idx)
                 Bool_t setIdxHypKine(Int_t Idx)
                 Bool_t setListId(Int_t Id_list)
                 Bool_t setMomentum(Int_t Icomb, Int_t Ipart, TVector3 vect)
                 Bool_t setMomentum(Int_t Ipart, TVector3 vect)
                 Bool_t setMomentum(char* name, Int_t num, TVector3 vect)
                 Bool_t setProbAlg(Int_t Icomb, Float_t Prob)
                   void setUserValue(Int_t valueID, Float_t value, Int_t my_iter = -1)
           virtual void ShowMembers(TMemberInspector& insp, char* parent)
           virtual void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)
                 Bool_t writeUserValues()

Data Members

    private:

          Int_t idx_hypkine       index of HHypKine container ( -1 -> don't use kine ) 
          Int_t idx_hypcomb       index of HHypComb container  
          Int_t idx_hyplist       index of "parent" HHypList container ( -1 -> no parent ) 
          Int_t id_list           channel list ID (see hypchannel)
        TArrayF fprobalg          probability calculated by algorythm for given combination
        TArrayF fvaluealg         storing USER defined values  (up to nvaluealg)
        TArrayI fuseralg          storing USER defined values: row0->ncomb, row1->valueID  (up to 2*nvaluealg)
          Int_t nvaluealg         number of columns of fvaluealg
        Float_t c_fvaluealg[500]  !caching table, avoids delete/new op. of TArray
          Int_t c_fuseralg[1000]  !caching table
          Int_t c_nvaluealg       ! number of columns of c_fvaluealg
      HHypComb* p_hypcomb         ! pointer to HHypComb container (! -> don't strem p_hypcomb)
          Int_t comb_iter         ! for the iterator
         Bool_t status            ! exit status
         Bool_t iterstatus        ! exit status

Class Description

///////////////////////////////////////////////////////////////////sea

 HHypList

 container class for HADES EVENT HYPOTHESIS

       This is the MAIN container for the HYP framework

 Class keeps HHypComb and table of probabilities (given by algorithms)
 coresponding to each combination of particles
 (index to HHypComb and fprobalg[] )
 HHypList object is created for every new algorithm

 User Alg's should use the list and NEVER hypcomb or hypkine
 -> This is the front-end class for all HYP actions!

 Constructor
 ===========

 Input parameters:
       OldList    : pointer to the parent HHypList object.
                    New HHypList inherits HHypComb container from OldList
                    also fprobalg values are copied
       IdxHypKine : Index to HHypKine container; put -1 to have the same as the OldList has
                    (if does not have the new HHypList will not have too)

 Constructor
 ===========

 Input parameters:
       HypComb    : pointer to the HHypComb object.
                    New HHypList base on the HypComb
       IdxHypKine : Index to HHypKine container; put -1 to have the same as the OldList has
                    (if does not have the new HHypList will not have too)

 Constructor
 ===========

 Input parameters:
             Idx_HypComb : index to HHypComb container
             IdxHypKine  : index to HHypKine container
             see previous constructors

 opt -> for future :)
 set size of 3 TArray objects to 0

restore pointer after reading from root file

 set id of the HHypList

 returns id of the HHypList

 returns index of parent HHypList if exist
 if does not returns NULL

 set variables : Ncomb, fprobalg size
 copy fprobalg from old HHypComb container to the actual one

 set user value

This returns user values from this list or any parent list
Int_t valueID: see hypinfodef.h
Float_t & value: return user value
Int_t my_iter: Iteration (comb_iter by default, to be used in Iterator)
return Bool_t: success or not...

 now the arrayed vars

 copy values from c_fuseralg to fuseralg
         and from c_fvaluealg to fuseralg
 from "cached" variables to dynamic Arrays

 returns HPidParticle for certain particle position
 iterates over combination !!!

 returns number of possible combination

 returns number of particles in each single combination

 returns probability of given combination

 returns integer from 1 to NConb
 1 - for the combination with the highest probability
 Note: same Probability will result in same order number!!!

 returns TLorentzVector for given cell
      x,y,z momentum components are taken from HPidParticle object
      mass taken according to assumed pid of the particle
     if kine container exist take momenta from this container

 returns TLorentzVector for given num (number of particle)
 iterates over combinations
      x,y,z momentum components are taken from HPidParticle object
      mass taken according to assumed pid of the particle
      if kine container exist take momenta from this container

 returns TLorentzVector for given name of particle (i.e "p")
 num is number in order : use 1 for first "p" , 2 for secound ....
 iterates over combinations
      x,y,z momentum components are taken from HPidParticle object
      mass taken according to assumed pid of the particle
      if kine container exist take momenta from this container

 returns PidParticle object index for certain cell

 returns index to HPidParticle for certain particle position
 iterates over combination

 returns index to HPidParticle for given particle name and number in order
 iterates over combination

 Inits (and if necs. copies) momentum
 This fcuntion should be called at the beginning of every
 algo which uses setMomentum
 if not there is the *possibility* that one algo is
 overwriting the momentum another algo might need

 set momentum of particle for given cell (in HHypKine)
 vect=(px,py,pz) (HHypKine is created if does not exist)

 set momentum of particle for given particle number (in HHypKine)
 vect=(px,py,pz) (HHypKine is created if does not exist)
 iterate over combinations

 set momentum of particle for given particle name (in HHypKine) and number in order
 i.e num=1 for first "p" , num=2 for secound "p"
 vect=(px,py,pz) (HHypKine is created if does not exist)
 iterate over combinations

 return TVector3 (px,py,pz) - 3-momentum components
 if HHypKine exist take TVector3 from HHypKine

 return TVector3 (px,py,pz) - 3-momentum components
 if HHypKine exist take TVector3 from HHypKine
 num : x position of paticle in HypComb table
 iterate over combination

 returns beta for given name of particle (i.e "p")
 num is number in order : use 1 for first "p" , 2 for secound ....
 iterates over combinations

 return beta of given particle according to applied algorithm
 for particle on position Ipart in combination Icomb

 return beta of given particle according to applied algorithm
 for particle on position Ipart
 iterate over combination

 set probability Prob given by algorithm for combination number Icomb

 returns probability given by algotrythm for  combination number Icomb

 returns probability given by algorythm for combination
 iterate over combination

 Use this function inside a selector to remove current combination.

 Remove all combinations, keep only the best one

 This function sets a new probability inside the Iterator()
 [Ingo]

 returns assumed pid for given cell

 returns assumed pid for given num (number of particle)
 iterates over combinations

 set index to the HHypComb

 returns index to the HHypComb

 set index to the HHypKine

 returns index to the HHypKine

 reset comb_iter

 This is the only legal method how to scan the valid
 combinations. A combination is valid, if probAlg is equal or more
 than zero. It is unvalid, if probAlg is SMALLER than zero.

 use while debuging to print HHypComb table with indexes and pids

 build linear category

 Stream an object of class HHypList.

Inline Functions

               void ~HHypList()
           HHypList HHypList(Int_t Idx_HypComb, Int_t IdxHypKine = -1)
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void StreamerNVirtual(TBuffer& b)
           HHypList HHypList(const HHypList&)
          HHypList& operator=(const HHypList&)