HLT/TPCLib/AliHLTTPCHWCFData.h

   1 //-*- Mode: C++ -*-
   2 // $Id$
   3 #ifndef ALIHLTTPCHWCFDATA_H
   4 #define ALIHLTTPCHWCFDATA_H
   5 //* This file is property of and copyright by the ALICE HLT Project        *
   6 //* ALICE Experiment at CERN, All rights reserved.                         *
   7 //* See cxx source for full Copyright notice                               *
   8
   9 /// @file   AliHLTTPCHWCFData.h
  10 /// @author Matthias Richter
  11 /// @date   2011-08-04
  12 /// @brief  Decoder methods for the HWCF format
  13 ///
  14
  15 #include "Rtypes.h"
  16 #include "AliHLTDataTypes.h"
  17 #include "AliHLTLogging.h"
  18 #include "AliHLTErrorGuard.h"
  19
  20 class TArrayC;
  21
  22 /**
  23  * @class AliHLTTPCHWCFData
  24  * The class provides decoding functionality for the output format of the
  25  * TPC HW ClusterFinder
  26  *
  27  * Two formats have been defined in the past and can be detected:
  28  * version 0: 5 32bit words 20 Byte
  29  * <pre>
  30  *   word 0: header (big endian 32bit unsigned)
  31  *           bit 31-30: 0x11 indicates cluster
  32  *           bit 29-24: row number in partition
  33  *           bit 23-0: Qtot, fixed point number with 6 bits after the point
  34  *   word 1: pad (float)
  35  *   word 2: time (float)
  36  *   word 3: pad variance (float)
  37  *   word 4: time variance (float)
  38  * </pre>
  39  *
  40  * version 1: 6 32bit words 24 Byte
  41  * <pre>
  42  *   word 0: header (big endian 32bit unsigned)
  43  *           bit 31-30: 0x11 indicates cluster
  44  *           bit 29-24: row number in partition
  45  *           bit 23-0: Qmax, fixed point number with 6 bits after the point
  46  *   word 1: total charge 32bit  big endian, fixed point number with 12 bits after the point
  47  *   word 2: pad (float)
  48  *   word 3: time (float)
  49  *   word 4: pad variance (float)
  50  *   word 5: time variance (float)
  51  * </pre>
  52  */
  53 class AliHLTTPCHWCFData : public AliHLTLogging {
  54  public:
  55   AliHLTTPCHWCFData(int forceVersion=-1);
  56   virtual ~AliHLTTPCHWCFData();
  57
  58   int Init(const AliHLTUInt8_t* pBuffer, int bufferSize);
  59   int Reset();
  60
  61   Int_t    GetNumberOfClusters() const;
  62
  63   Int_t    GetPadRow(int i)  const;
  64   Float_t  GetPad(int i)     const;
  65   Float_t  GetTime(int i)    const;
  66   Float_t  GetSigmaY2(int i) const;
  67   Float_t  GetSigmaZ2(int i) const;
  68   Int_t    GetCharge(int i)  const;
  69   Int_t    GetQMax(int i)    const;
  70
  71   int CheckVersion();
  72   bool CheckAssumption(int format, const AliHLTUInt8_t* pData, int size) const;
  73
  74   // check if index is within bounds
  75
  76   bool CheckBounds(int i) const {
  77     if (fVersion<0) {
  78       ErrorMsg("");
  79       return false;
  80     }
  81     int elementsize=GetElementSize(fVersion);
  82     if (elementsize<0) return false;
  83     return ((i+1)*elementsize+fRCUTrailerSize<=fBufferSize);
  84   }
  85
  86   // get the size of one element
  87   int GetElementSize(int version) const {
  88     switch (version) {
  89     case 0: return sizeof(AliHLTTPCHWClusterV0);
  90     case 1: return sizeof(AliHLTTPCHWClusterV1);
  91     default:
  92       ErrorMsg(Form("invalid format version %d", fVersion));
  93     }
  94     return -1;
  95   }
  96
  97   // pointer to RCU trailer
  98   const AliHLTUInt8_t*  GetRCUTrailer() const
  99   {
 100     if (fRCUTrailerSize<=0 || fpBuffer==NULL || fBufferSize<fRCUTrailerSize) return NULL;
 101     return fpBuffer+(fBufferSize-fRCUTrailerSize);
 102   }
 103
 104   // size of RCU trailer
 105   int GetRCUTrailerSize() const { return fRCUTrailerSize; }
 106
 107   // print info
 108   void Print(const char* option);
 109
 110   // print error message
 111   void ErrorMsg( const char *str ) const;
 112
 113   // open a file and init
 114   int Open(const char* filename);
 115
 116   enum {
 117     kHWCFDataV0 = 0,
 118     kHWCFDataV1 = 1,
 119   };
 120
 121   struct AliHLTTPCHWClusterV0 {
 122     AliHLTUInt32_t fHeader;
 123     Float_t        fPad;
 124     Float_t        fTime;
 125     Float_t        fSigmaY2;
 126     Float_t        fSigmaZ2;
 127
 128     Int_t    GetPadRow()  const;
 129     Float_t  GetPad()     const {return fPad+0.5;}
 130     Float_t  GetTime()    const {return fTime;}
 131     Float_t  GetSigmaY2() const {
 132       Float_t sy2 = fSigmaY2 - fPad*fPad;
 133       return (sy2>0) ?sy2 :0.;
 134     }
 135     Float_t  GetSigmaZ2() const {
 136       Float_t sz2 = fSigmaZ2 - fTime*fTime;
 137       return (sz2>0) ?sz2 :0.;
 138     }
 139     Int_t    GetCharge()  const;
 140     Int_t    GetQMax()    const {return -1;}
 141   };
 142
 143   struct AliHLTTPCHWClusterV1 {
 144     AliHLTUInt32_t fHeader;
 145     AliHLTUInt32_t fCharge;
 146     Float_t        fPad;
 147     Float_t        fTime;
 148     Float_t        fSigmaY2;
 149     Float_t        fSigmaZ2;
 150
 151     Int_t    GetPadRow()  const;
 152     Float_t  GetPad()     const {return fPad+0.5;}
 153     Float_t  GetTime()    const {return fTime;}
 154     Float_t  GetSigmaY2() const {
 155       Float_t sy2 = fSigmaY2 - fPad*fPad;
 156       return (sy2>0) ?sy2 :0.;
 157     }
 158     Float_t  GetSigmaZ2() const {
 159       Float_t sz2 = fSigmaZ2 - fTime*fTime;
 160       return (sz2>0) ?sz2 :0.;
 161     }
 162     Int_t    GetCharge()  const;
 163     Int_t    GetQMax()    const;
 164   };
 165
 166   template<typename T>
 167   class AliHLTTPCHWClusterDecoder {
 168   public:
 169     AliHLTTPCHWClusterDecoder(const T* pClusterArray, int entries);
 170     ~AliHLTTPCHWClusterDecoder();
 171
 172     // i'th element, no bounds check for performance reasons
 173     const T& operator[](unsigned i) {
 174       return fpClusterArray[i];
 175     }
 176
 177     Int_t    GetPadRow(int i)  const {return fpClusterArray[i]->GetPadRow();}
 178     Float_t  GetPad(int i)     const {return fpClusterArray[i]->GetPad();}
 179     Float_t  GetTime(int i)    const {return fpClusterArray[i]->GetTime();}
 180     Float_t  GetSigmaY2(int i) const {return fpClusterArray[i]->GetSigmaY2();}
 181     Float_t  GetSigmaZ2(int i) const {return fpClusterArray[i]->GetSigmaZ2();}
 182     Int_t    GetCharge(int i)  const {return fpClusterArray[i]->GetCharge();}
 183     Int_t    GetQMax(int i)    const {return fpClusterArray[i]->GetQMax();}
 184
 185   private:
 186     const T* fpClusterArray; //! array of clusters
 187     int fEntries;            //! number of entries
 188   };
 189
 190   class iterator {
 191   public:
 192     iterator()
 193       : fData(NULL), fVersion(-1), fElementSize(0) {}
 194     iterator(const AliHLTUInt8_t* pData, int version, int elementSize)
 195       : fData(pData), fVersion(version), fElementSize(elementSize) {}
 196     iterator(const iterator& i)
 197       : fData(i.fData), fVersion(i.fVersion), fElementSize(i.fElementSize) {}
 198     iterator& operator=(const iterator& i) {
 199       if (this==&i) return *this;
 200       fData=i.fData; fVersion=i.fVersion; fElementSize=i.fElementSize; return *this;
 201     }
 202     ~iterator() {fData=NULL;}
 203
 204     bool operator==(const iterator& i) const  {return (fData!=NULL) && (fData==i.fData);}
 205     bool operator!=(const iterator& i) const  {return (fData!=NULL) && (fData!=i.fData);}
 206     // prefix operators
 207     iterator& operator++() {fData+=fElementSize; return *this;}
 208     iterator& operator--() {fData-=fElementSize; return *this;}
 209     // postfix operators
 210     iterator operator++(int) {iterator i(*this); fData+=fElementSize; return i;}
 211     iterator operator--(int) {iterator i(*this); fData-=fElementSize; return i;}
 212
 213     iterator& operator+=(int step) {fData+=step*fElementSize; return *this;}
 214
 215     Int_t    GetPadRow()  const {
 216       switch (fVersion) {
 217       case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetPadRow();
 218       case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetPadRow();
 219       } return -1;
 220     }
 221     Float_t  GetPad()     const {
 222       switch (fVersion) {
 223       case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetPad();
 224       case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetPad();
 225       } return -10000.;
 226     }
 227     Float_t  GetTime()    const {
 228       switch (fVersion) {
 229       case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetTime();
 230       case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetTime();
 231       } return -10000.;
 232     }
 233     Float_t  GetSigmaY2() const {
 234       switch (fVersion) {
 235       case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetSigmaY2();
 236       case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetSigmaY2();
 237       } return -10000.;
 238     }
 239     Float_t  GetSigmaZ2() const {
 240       switch (fVersion) {
 241       case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetSigmaZ2();
 242       case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetSigmaZ2();
 243       } return -10000.;
 244     }
 245     Int_t    GetCharge()  const {
 246       switch (fVersion) {
 247       case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetCharge();
 248       case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetCharge();
 249       } return -1;
 250     }
 251     Int_t    GetQMax()    const {
 252       switch (fVersion) {
 253       case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetQMax();
 254       case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetQMax();
 255       } return -1;
 256     }
 257
 258   protected:
 259   private:
 260     const AliHLTUInt8_t* fData; //! data
 261     int fVersion; //! format version
 262     int fElementSize; //! element size
 263   };
 264
 265   // prepare iterator and end marker
 266   iterator& begin() {
 267     fIterator.~iterator();
 268     new (&fIterator) iterator(fpBuffer, fVersion, GetElementSize(fVersion));
 269     fIteratorEnd=fIterator;
 270     fIteratorEnd+=GetNumberOfClusters();
 271     return fIterator;
 272   }
 273
 274   // get loop end marker
 275   iterator& end() {
 276     return fIteratorEnd;
 277   }
 278
 279   // find one single element
 280   iterator& find(int i) {
 281     fIterator.~iterator();
 282     fIteratorEnd.~iterator();
 283     if (i>=GetNumberOfClusters()) return fIterator;
 284     new (&fIterator) iterator(fpBuffer, fVersion, GetElementSize(fVersion));
 285     fIterator+=i;
 286     fIteratorEnd=fIterator;
 287     fIteratorEnd+=1;
 288     return fIterator;
 289   }
 290
 291   static const unsigned  fgkAliHLTTPCHWClusterSize;
 292  protected:
 293
 294  private:
 295   AliHLTTPCHWCFData(const AliHLTTPCHWCFData&);
 296   AliHLTTPCHWCFData& operator=(const AliHLTTPCHWCFData&);
 297
 298   // get pointer to i'th element
 299   const AliHLTUInt8_t* Get(int i) const
 300   {
 301     if (!fpBuffer) return NULL;
 302     int elementsize=GetElementSize(fVersion);
 303     if (elementsize<0) return NULL;
 304     return fpBuffer+(i*elementsize);
 305   }
 306
 307
 308   const AliHLTUInt8_t* fpBuffer; //! pointer to data buffer
 309   int fBufferSize; //! size of data buffer
 310
 311   int fVersion; //! format version
 312   int fForcedVersion; //! forced format version
 313   int fRCUTrailerSize; //! size of the RCU trailer in Byte
 314
 315   TArrayC* fpFileBuffer; //! internal buffer for file content
 316
 317   iterator fIterator; //! iterator
 318   iterator fIteratorEnd; //! end iterator
 319
 320   ClassDef(AliHLTTPCHWCFData, 0)
 321 };
 322 #endif