HLT/TPCLib/AliHLTTPCMapping.h

   1 // -*- Mode: C++ -*-
   2 // $Id$
   3
   4 #ifndef ALIHLTTPCMAPPING_H
   5 #define ALIHLTTPCMAPPING_H
   6 //* This file is property of and copyright by the ALICE HLT Project        *
   7 //* ALICE Experiment at CERN, All rights reserved.                         *
   8 //* See cxx source for full Copyright notice                               *
   9
  10 /** @file   AliHLTTPCMapping.h
  11     @author Kenneth Aamodt
  12     @date
  13     @brief  Mapping class for TPC.
  14 */
  15
  16 #include "AliHLTLogging.h"
  17
  18 /**
  19  * @class AliHLTTPCMapping
  20  * This is a mapping class for the TPC. It contains the mappping for all six partitions in static arrays.
  21  * This ensures that the asci files containing the mapping numbers is only read once per partition.
  22  * The only two methods interesting for the users are GetPad(hwaddress) and GetRow(hwaddress).
  23  *
  24  * There are several possibilities to count the rows:
  25  * - A: absolute number: 0 to 158 over all partitions
  26  * - B: sectorwise: 0 to 62 for inner, 0 to 95 for outer sector
  27  * - C: within a partition
  28  *
  29  * This mappping class is designed to return the mapping within a partition (C), while the
  30  * mapping files use scheme B. The first row of each partition counted in scheme B has to
  31  * be subtracted.
  32  *
  33  * @ingroup alihlt_tpc
  34  */
  35 class AliHLTTPCMapping : public AliHLTLogging {
  36 public:
  37   /** standard constructor */
  38   AliHLTTPCMapping(UInt_t patch);
  39
  40   /** standard destructor */
  41   virtual ~AliHLTTPCMapping();
  42
  43   /**
  44    * Create mapping for the given patch.
  45    */
  46   void InitializeMap(UInt_t patch);
  47
  48   /**
  49    * Get the pad number belonging to hardware address.
  50    * @param HWAddress    The hardware address of the given pad
  51    * @return Pad number of given HWAddress
  52    */
  53   UInt_t GetPad(UInt_t HWAddress) const;
  54
  55   /**
  56    * Get the row number belonging to hardware address.
  57    * @param HWAddress    The hardware address of the given pad you are on.
  58    * @return Row number of hardware address (Pad).
  59    */
  60   UInt_t GetRow(UInt_t HWAddress) const;
  61
  62   /**
  63    * Get the HW addess (channel no) for a row/pad coordinate.
  64    * @param row          The row in the partition
  65    * @param pad          The pad in the row
  66    * @return hardware address (channel no).
  67    */
  68   UInt_t GetHwAddress(UInt_t row, UInt_t pad) const;
  69
  70   /**
  71    * Read the mapping array from file.
  72    * @param patch           the patch (partition) to read
  73    * @param arraySize       size of the mapping arrays
  74    * @param rowArray        array of row mapping
  75    * @param padArray        array of pad mapping
  76    * @param hwaMappingSize  size of the HW address mapping
  77    * @param hwaArray        array of HW address mapping (backwards mapping)
  78    * @return kTRUE if successful
  79    */
  80   Bool_t ReadArray(UInt_t patch, UInt_t arraySize, UInt_t rowArray[], UInt_t padArray[], UInt_t hwaMappingSize, UInt_t hwaArray[]) const;
  81
  82   /**
  83    * Checks if the hw address is valid
  84    * @param HWAddress    The hardware address of the pad
  85    * @return kTRUE if valid HWAddress
  86    */
  87   Bool_t IsValidHWAddress(UInt_t HWAddress) const;
  88
  89   /**
  90    * Method which returns the row offset of the patch.
  91    * @return row offset of patch.
  92   */
  93   Int_t GetRowOffset() const {return fRowOffset;}
  94
  95  private:
  96   /** standard constructor prohibited, pad no always required */
  97   AliHLTTPCMapping();
  98   /** copy constructor prohibited */
  99   AliHLTTPCMapping(const AliHLTTPCMapping&);
 100   /** assignment operator prohibited */
 101   AliHLTTPCMapping& operator=(const AliHLTTPCMapping&);
 102
 103   /** the readout partition/patch */
 104   UInt_t fPatch;                                                     //! transient
 105
 106   /** global number of patches */
 107   static const UChar_t fgkNofPatches=6;                              //! transient
 108
 109   /** Flags to check if mapping is done for the six patches */
 110   static Bool_t fgMappingIsDone[fgkNofPatches];                      //! transient
 111
 112   /** size of mapping arrays */
 113   static const UInt_t fgkMappingSize[fgkNofPatches];                 // see above
 114
 115   /** array of the row mappings */
 116   static UInt_t* fgRowMapping[fgkNofPatches];                        //! transient
 117
 118   /** array of the pad mappings */
 119   static UInt_t* fgPadMapping[fgkNofPatches];                        //! transient
 120
 121   /** array of the HW address mappings */
 122   static UInt_t* fgHwaMapping[fgkNofPatches];                        //! transient
 123
 124   /** size of mapping array for patch 0 */
 125   static const UInt_t fgkMapping0Size=3200;                          // see above
 126   /** size of mapping array for patch 1 */
 127   static const UInt_t fgkMapping1Size=3584;                          // see above
 128   /** size of mapping array for patch 2 */
 129   static const UInt_t fgkMapping2Size=3200;                          // see above
 130   /** size of mapping array for patch 3 */
 131   static const UInt_t fgkMapping3Size=3328;                          // see above
 132   /** size of mapping array for patch 4 */
 133   static const UInt_t fgkMapping4Size=3328;                          // see above
 134   /** size of mapping array for patch 5 */
 135   static const UInt_t fgkMapping5Size=3328;                          // see above
 136
 137   /** name space for HW address mapping pad encoding */
 138   static const UInt_t fgkMappingHwaPadMask=0xff;                     //! transient
 139   /** bit shift for HW address mapping row encoding */
 140   static const UInt_t fgkMappingHwaRowMask=0x3f00;                   //! transient
 141   /** name space for HW address mapping row encoding */
 142   static const UChar_t fgkMappingHwaRowBitShift=8;                   //! transient
 143   /** size of row/pad to channel mapping
 144    * bit 0-8  encode pad
 145    * bit 9-11 encode row
 146    */
 147   static const UInt_t fgkMappingHwaSize=0x4000;                      // see above
 148
 149   /** row mapping array for patch 0 */
 150   static UInt_t fgRowMapping0[fgkMapping0Size];                      // see above
 151   /** pad mapping array for patch 0 */
 152   static UInt_t fgPadMapping0[fgkMapping0Size];                      // see above
 153   /** hw address mapping array for patch 0 */
 154   static UInt_t fgHwaMapping0[fgkMappingHwaSize];                    // see above
 155   /** row mapping array for patch 1 */
 156   static UInt_t fgRowMapping1[fgkMapping1Size];                      // see above
 157   /** pad mapping array for patch 1 */
 158   static UInt_t fgPadMapping1[fgkMapping1Size];                      // see above
 159   /** hw address mapping array for patch 1 */
 160   static UInt_t fgHwaMapping1[fgkMappingHwaSize];                    // see above
 161   /** row mapping array for patch 2 */
 162   static UInt_t fgRowMapping2[fgkMapping2Size];                      // see above
 163   /** pad mapping array for patch 2 */
 164   static UInt_t fgPadMapping2[fgkMapping2Size];                      // see above
 165   /** hw address mapping array for patch 2 */
 166   static UInt_t fgHwaMapping2[fgkMappingHwaSize];                    // see above
 167   /** row mapping array for patch 3 */
 168   static UInt_t fgRowMapping3[fgkMapping3Size];                      // see above
 169   /** pad mapping array for patch 3 */
 170   static UInt_t fgPadMapping3[fgkMapping3Size];                      // see above
 171   /** hw addres mapping array for patch 3 */
 172   static UInt_t fgHwaMapping3[fgkMappingHwaSize];                    // see above
 173   /** row mapping array for patch 4 */
 174   static UInt_t fgRowMapping4[fgkMapping4Size];                      // see above
 175   /** pad mapping array for patch 4 */
 176   static UInt_t fgPadMapping4[fgkMapping4Size];                      // see above
 177   /** hw address mapping array for patch 4 */
 178   static UInt_t fgHwaMapping4[fgkMappingHwaSize];                    // see above
 179   /** row mapping array for patch 5 */
 180   static UInt_t fgRowMapping5[fgkMapping5Size];                      // see above
 181   /** pad mapping array for patch 5 */
 182   static UInt_t fgPadMapping5[fgkMapping5Size];                      // see above
 183   /** hw address mapping array for patch 5 */
 184   static UInt_t fgHwaMapping5[fgkMappingHwaSize];                    // see above
 185
 186   /** current row mapping array */
 187   UInt_t *fCurrentRowMapping;                                        //!transient
 188   /** current pad mapping array */
 189   UInt_t *fCurrentPadMapping;                                        //!transient
 190
 191   /** number of rows */
 192   Int_t fNofRows;                                                    // see above
 193
 194   /** Maximum number of hardware addresses */
 195   UInt_t fMaxHWAdd;                                                  //!transient
 196
 197   /** row offset according to scheme A (see class description) */
 198   Int_t fRowOffset;                                                  //!transient
 199
 200   ClassDef(AliHLTTPCMapping, 0)
 201 };
 202 #endif // ALIHLTTPCMAPPING_H