class HMdcBArray

_HADES_CLASS_DESCRIPTION

 HMdcTBArray

  LookupTable and some useful functions for working
  with an array of two bits.
  For MDC it can be used for keeping information about
  number of cell times:
 only time1 - 1
 only time2 - 2
 time1 & time2 - 3

   void clear(UChar_t *pF, UChar_t *pL);
   void set(UChar_t *pF, Int_t pos, UChar_t cont);
   Int_t get(UChar_t *pF, Int_t pos);
   void unset(UChar_t *pF, Int_t pos, UChar_t cont);
   Int_t getNSet(UChar_t *pF, UChar_t *pL);
   Int_t position(UChar_t *pF, UChar_t *pL, Int_t idx);
        = content of two bits or =-1
   Int_t first(UChar_t *pF, UChar_t *pL);
        = content of two bits or =-1
   Int_t last(UChar_t *pF, UChar_t *pL);
        = content of two bits or =-1
   Int_t next(UChar_t *pF, UChar_t *pL, Int_t prPos);
        = content of two bits or =-1
   Int_t previous(UChar_t *pF, UChar_t *pL, Int_t prPos);
        = content of two bits or =-1
   void shiftRight(UChar_t *pF, UChar_t *pL, UChar_t *pS);
   void shiftLeft(UChar_t *pF, UChar_t *pL, UChar_t *pS);
   Int_t compare(UChar_t *pF1, UChar_t *pF2, Int_t nBytes);

 pF - pointer to the first byte of bytes array
 pL - pointer to the last byte of bytes array
 cont - content of two bits, can be = 0,1,2,3
 pos - position of element in two bit array (for examp. - num. cell MDC)
 idx - index of element
 prPos - position of the element, used for geting position of the
         next or previous position aftre or before pos. prPos
 pS - pointer to the byte which mast be moved to *pL (shift to right)
                                        or to *pT (shift to left)


Function Members (Methods)

public:
HMdcBArray(const HMdcBArray&)
static Int_tandArr(const UChar_t* pF1, const UChar_t* pF2, Int_t nBytes, UChar_t* pOut)
static Int_tandArrAndUnset(UChar_t* pNoId, const UChar_t* pEx, Int_t nBytes, UChar_t* pIdnt)
static TClass*Class()
static voidclear(UChar_t* pF, UChar_t* pL)
static Int_tcompare(const UChar_t* pF1, const UChar_t* pF2, Int_t nBytes)
static Int_tfirst(const UChar_t* pF, const UChar_t* pL)
static UChar_tget(const UChar_t* pF, Int_t pos)
static UChar_tgetNLayOrientation(UChar_t list)
static Int_tgetNSet(const UChar_t* pF)
static Int_tgetNSet(const UChar_t byte)
static Int_tgetNSet(const UChar_t* pF, const UChar_t* pL)
static Int_tgetNSet2B(const UChar_t* pF)
static Bool_tis40DegWireCross(UChar_t list)
virtual TClass*IsA() const
static Int_tlast(const UChar_t* pF, const UChar_t* pL)
static Int_tnext(const UChar_t* pF, const UChar_t* pL, Int_t prPos)
static Int_tnextAndUnset(UChar_t* pF, UChar_t* pL, Int_t prPos)
HMdcBArray&operator=(const HMdcBArray&)
static Int_tposition(const UChar_t* pF, const UChar_t* pL, Int_t idx)
static Int_tprevAndUnset(UChar_t* pF, UChar_t* pL, Int_t prPos)
static Int_tprevious(const UChar_t* pF, const UChar_t* pL, Int_t prPos)
static voidset(UChar_t* pF, Int_t pos)
static voidshiftLeft(UChar_t* pT, UChar_t* pL, UChar_t* pS)
static voidshiftRight(UChar_t* pF, UChar_t* pL, UChar_t* pS)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
static Bool_ttestAndUnset(UChar_t* pF, Int_t pos)
static voidunset(UChar_t* pF, Int_t pos)
static Int_txorArr(const UChar_t* pF1, const UChar_t* pF2, Int_t nBytes, UChar_t* pOut)
private:
HMdcBArray()
(unknown)()

Data Members

protected:
static UChar_thighBit[256]
static UChar_tis40degCross[64]
static UChar_tnBitLookUp[256]
static UChar_tnLayOrientation[64]
static UChar_tnextBit[8]
static UChar_tpBitLookUp[8][256]
static UChar_tprevBit[8]
static UChar_tsetBitLUp[8]
static UChar_tunsetBitLUp[8]

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

void clear(UChar_t* pF, UChar_t* pL)
Int_t getNSet(const UChar_t* pF, const UChar_t* pL)
Int_t getNSet(const UChar_t *pF)
Int_t getNSet(const UChar_t byte)
Int_t getNSet2B(const UChar_t* pF)
void set(UChar_t* pF, Int_t pos)
UChar_t getNLayOrientation(UChar_t list)
 list - list of layers: 6 bits, one bit per layer
Bool_t is40DegWireCross(UChar_t list)
 list - list of layers: 6 bits, one bit per layer
void unset(UChar_t* pF, Int_t pos)
Int_t position(const UChar_t* pF, const UChar_t* pL, Int_t idx)
 return: >=0 - ok.!;
Int_t first(const UChar_t* pF, const UChar_t* pL)
 return: -1 - num.cells=0
Int_t last(const UChar_t* pF, const UChar_t* pL)
 return: >=0 - ok.!; -2 - num. of cells =0
Int_t next(const UChar_t* pF, const UChar_t* pL, Int_t prPos)
 prPos <0 eq. first
 return: -1 next is absent
Int_t nextAndUnset(UChar_t* pF, UChar_t* pL, Int_t prPos)
 The function search next seted bit after prPos in array, unset this
 bin and return a position of this one.
 The bit prPos must be unseted (=0), if not - function will return
 the same position!
 prPos <0 = seach first seted bin
 return: -1 next is absent
Int_t previous(const UChar_t* pF, const UChar_t* pL, Int_t prPos)
 prPos >size = start from latest bit
 return: -1 previous is absent
Int_t prevAndUnset(UChar_t* pF, UChar_t* pL, Int_t prPos)
 The same as nextAndUnset but do it back order.
 prPos >= (pL-pF+1)*8 = start from latest bit
 return: -1 next is absent
void shiftRight(UChar_t* pF, UChar_t* pL, UChar_t* pS)
 pF - pointer to first el., pL - pointer to last el.
 pS - pointer to el. which must be moved to *pL ((pL-pS) - shift)
void shiftLeft(UChar_t* pT, UChar_t* pL, UChar_t* pS)
 pT - pointer to first el., pL - pointer to last el.
 pS - pointer to el. which must be moved to *pT
UChar_t get(const UChar_t* pF, Int_t pos)
Returns 1 if bit is seted, 0 if not
Bool_t testAndUnset(UChar_t* pF, Int_t pos)
 Bit n=pos will unseted.
 Returns kTRUE if bit was seted, kFALSE if not
Int_t compare(const UChar_t* pF1, const UChar_t* pF2, Int_t nBytes)
Int_t andArr(const UChar_t* pF1, const UChar_t* pF2, Int_t nBytes, UChar_t* pOut)
 Function produce list of identical for pF1 & ppF2 bits - pOut
 return number of identical bits
Int_t andArrAndUnset(UChar_t* pNoId, const UChar_t* pEx, Int_t nBytes, UChar_t* pIdnt)
 Function produce list of identical for pNoId & ppEx bits - pIdnt
 and unset identical bits in pNoId
 return number of identical bits
   Int_t nIBits=0;
   const UChar_t *pExEnd = pEx + nBytes;
   for(;pEx<pExEnd;pEx++,pIdnt++,pNoId++) {
     *pIdnt  = *pNoId & *pEx;
     *pNoId ^= *pIdnt;
     nIBits += nBitLookUp[*pIdnt];
   }
Int_t xorArr(const UChar_t* pF1, const UChar_t* pF2, Int_t nBytes, UChar_t* pOut)
 Function produce list of nonidentical for pF1 & ppF2 bits - pOut
 return number of not identical bits in pF1 and pF2
HMdcBArray(const HMdcBArray& )
{}

Last change: Sat May 22 12:59:41 2010
Last generated: 2010-05-22 12:59

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.