added 'backwards' mapping: row/pad to channel; code cleanup
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 31 Mar 2008 13:26:44 +0000 (13:26 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 31 Mar 2008 13:26:44 +0000 (13:26 +0000)
HLT/TPCLib/AliHLTTPCMapping.cxx
HLT/TPCLib/AliHLTTPCMapping.h
HLT/TPCLib/test/testAliHLTTPCMapping.C

index c91a865..7d25be0 100644 (file)
@@ -38,9 +38,10 @@ ClassImp(AliHLTTPCMapping)
 
 AliHLTTPCMapping::AliHLTTPCMapping(UInt_t patch)
   :
+  fPatch(patch),
   fCurrentRowMapping(NULL),
   fCurrentPadMapping(NULL),
-  fNHWAdd(0),
+  fNofRows(0),
   fMaxHWAdd(0),
   fRowOffset(0)
 {
@@ -50,94 +51,92 @@ AliHLTTPCMapping::AliHLTTPCMapping(UInt_t patch)
   // or
   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 
-  switch(patch){
-  case 0:
-    if(!fgMapping0IsDone){
-      memset(fgRowMapping0, 0, fgkMapping0Size*sizeof(UInt_t));
-      memset(fgPadMapping0, 0, fgkMapping0Size*sizeof(UInt_t));
-      InitializeMap(patch);
-    }
-    fCurrentRowMapping=fgRowMapping0;
-    fCurrentPadMapping=fgPadMapping0;
-    fMaxHWAdd=fgkMapping0Size;
-    fRowOffset=AliHLTTPCTransform::GetFirstRow(patch);
-    break;
-  case 1:
-    if(!fgMapping1IsDone){
-      memset(fgRowMapping1, 0, fgkMapping1Size*sizeof(UInt_t));
-      memset(fgPadMapping1, 0, fgkMapping1Size*sizeof(UInt_t));
-      InitializeMap(patch);
-    }
-    fCurrentRowMapping=fgRowMapping1;
-    fCurrentPadMapping=fgPadMapping1;
-    fMaxHWAdd=fgkMapping1Size;
-    fRowOffset=AliHLTTPCTransform::GetFirstRow(patch);
-    break;
-  case 2:
-    if(!fgMapping2IsDone){
-      memset(fgRowMapping2, 0, fgkMapping2Size*sizeof(UInt_t));
-      memset(fgPadMapping2, 0, fgkMapping2Size*sizeof(UInt_t));
-      InitializeMap(patch);
-    }
-    fCurrentRowMapping=fgRowMapping2;
-    fCurrentPadMapping=fgPadMapping2;
-    fMaxHWAdd=fgkMapping2Size;
-    fRowOffset=AliHLTTPCTransform::GetFirstRow(patch);
-    break;
-  case 3:
-    if(!fgMapping3IsDone){
-      memset(fgRowMapping3, 0, fgkMapping3Size*sizeof(UInt_t));
-      memset(fgPadMapping3, 0, fgkMapping3Size*sizeof(UInt_t));
-      InitializeMap(patch);
-    }
-    fCurrentRowMapping=fgRowMapping3;
-    fCurrentPadMapping=fgPadMapping3;
-    fMaxHWAdd=fgkMapping3Size;
-    fRowOffset=AliHLTTPCTransform::GetFirstRow(patch);
-    break;
-  case 4:
-    if(!fgMapping4IsDone){
-      memset(fgRowMapping4, 0, fgkMapping4Size*sizeof(UInt_t));
-      memset(fgPadMapping4, 0, fgkMapping4Size*sizeof(UInt_t));
-      InitializeMap(patch);
-    }
-    fCurrentRowMapping=fgRowMapping4;
-    fCurrentPadMapping=fgPadMapping4;
-    fMaxHWAdd=fgkMapping4Size;
-    fRowOffset=AliHLTTPCTransform::GetFirstRow(patch);
-    break;
-  case 5:
-    if(!fgMapping5IsDone){
-      memset(fgRowMapping5, 0, fgkMapping5Size*sizeof(UInt_t));
-      memset(fgPadMapping5, 0, fgkMapping5Size*sizeof(UInt_t));
-      InitializeMap(patch);
-    }
-    fCurrentRowMapping=fgRowMapping5;
-    fCurrentPadMapping=fgPadMapping5;
-    fMaxHWAdd=fgkMapping5Size;
-    fRowOffset=AliHLTTPCTransform::GetFirstRow(patch);
-    break;
+  assert(patch<fgkNofPatches);
+  if (patch>=fgkNofPatches) fPatch=0; // just to avoid boundary overflow
+
+  // Get the row offset.
+  // we have several possibilities to count the rows:
+  // - A: absolute number: 0 to 158 over all partitions
+  // - B: sectorwise: 0 to 62 for inner, 0 to 95 for outer sector
+  // - C: within a partition: the mappping class is designed to return the
+  //   mapping within a partition.
+  // The mapping files use scheme B. We have to subtract the first row.
+  // AliHLTTPCTransform::GetFirstRow returns first row in scheme A.
+  fNofRows=AliHLTTPCTransform::GetNRows(patch);
+  fRowOffset=AliHLTTPCTransform::GetFirstRow(patch);
+
+  if(!fgMappingIsDone[patch]){
+    ReadArray(patch, fgkMappingSize[patch], fgRowMapping[patch], fgPadMapping[patch], fgkMappingHwaSize, fgHwaMapping[patch]);
+    fgMappingIsDone[patch]=kTRUE;
   }
+  fCurrentRowMapping=fgRowMapping[patch];
+  fCurrentPadMapping=fgPadMapping[patch];
+  fMaxHWAdd=fgkMappingSize[patch];
 }
 
-Bool_t AliHLTTPCMapping::fgMapping0IsDone=kFALSE;
-Bool_t AliHLTTPCMapping::fgMapping1IsDone=kFALSE;
-Bool_t AliHLTTPCMapping::fgMapping2IsDone=kFALSE;
-Bool_t AliHLTTPCMapping::fgMapping3IsDone=kFALSE;
-Bool_t AliHLTTPCMapping::fgMapping4IsDone=kFALSE;
-Bool_t AliHLTTPCMapping::fgMapping5IsDone=kFALSE;
+Bool_t AliHLTTPCMapping::fgMappingIsDone[fgkNofPatches]={
+  kFALSE,
+  kFALSE,
+  kFALSE,
+  kFALSE,
+  kFALSE,
+  kFALSE
+};
+
+const UInt_t AliHLTTPCMapping::fgkMappingSize[fgkNofPatches]={
+  AliHLTTPCMapping::fgkMapping0Size,
+  AliHLTTPCMapping::fgkMapping1Size,
+  AliHLTTPCMapping::fgkMapping2Size,
+  AliHLTTPCMapping::fgkMapping3Size,
+  AliHLTTPCMapping::fgkMapping4Size,
+  AliHLTTPCMapping::fgkMapping5Size
+};
+
 UInt_t AliHLTTPCMapping::fgRowMapping0[fgkMapping0Size];
 UInt_t AliHLTTPCMapping::fgPadMapping0[fgkMapping0Size];
+UInt_t AliHLTTPCMapping::fgHwaMapping0[fgkMappingHwaSize];
 UInt_t AliHLTTPCMapping::fgRowMapping1[fgkMapping1Size];
 UInt_t AliHLTTPCMapping::fgPadMapping1[fgkMapping1Size];
+UInt_t AliHLTTPCMapping::fgHwaMapping1[fgkMappingHwaSize];
 UInt_t AliHLTTPCMapping::fgRowMapping2[fgkMapping2Size];
 UInt_t AliHLTTPCMapping::fgPadMapping2[fgkMapping2Size];
+UInt_t AliHLTTPCMapping::fgHwaMapping2[fgkMappingHwaSize];
 UInt_t AliHLTTPCMapping::fgRowMapping3[fgkMapping3Size];
 UInt_t AliHLTTPCMapping::fgPadMapping3[fgkMapping3Size];
+UInt_t AliHLTTPCMapping::fgHwaMapping3[fgkMappingHwaSize];
 UInt_t AliHLTTPCMapping::fgRowMapping4[fgkMapping4Size];
 UInt_t AliHLTTPCMapping::fgPadMapping4[fgkMapping4Size];
+UInt_t AliHLTTPCMapping::fgHwaMapping4[fgkMappingHwaSize];
 UInt_t AliHLTTPCMapping::fgRowMapping5[fgkMapping5Size];
 UInt_t AliHLTTPCMapping::fgPadMapping5[fgkMapping5Size];
+UInt_t AliHLTTPCMapping::fgHwaMapping5[fgkMappingHwaSize];
+
+UInt_t* AliHLTTPCMapping::fgRowMapping[fgkNofPatches]={
+  AliHLTTPCMapping::fgRowMapping0,
+  AliHLTTPCMapping::fgRowMapping1,
+  AliHLTTPCMapping::fgRowMapping2,
+  AliHLTTPCMapping::fgRowMapping3,
+  AliHLTTPCMapping::fgRowMapping4,
+  AliHLTTPCMapping::fgRowMapping5
+};
+
+UInt_t* AliHLTTPCMapping::fgPadMapping[fgkNofPatches]={
+  AliHLTTPCMapping::fgPadMapping0,
+  AliHLTTPCMapping::fgPadMapping1,
+  AliHLTTPCMapping::fgPadMapping2,
+  AliHLTTPCMapping::fgPadMapping3,
+  AliHLTTPCMapping::fgPadMapping4,
+  AliHLTTPCMapping::fgPadMapping5
+};
+
+UInt_t* AliHLTTPCMapping::fgHwaMapping[fgkNofPatches]={
+  AliHLTTPCMapping::fgHwaMapping0,
+  AliHLTTPCMapping::fgHwaMapping1,
+  AliHLTTPCMapping::fgHwaMapping2,
+  AliHLTTPCMapping::fgHwaMapping3,
+  AliHLTTPCMapping::fgHwaMapping4,
+  AliHLTTPCMapping::fgHwaMapping5
+};
 
 AliHLTTPCMapping::~AliHLTTPCMapping(){
   // see header file for class documentation
@@ -146,6 +145,7 @@ AliHLTTPCMapping::~AliHLTTPCMapping(){
 void AliHLTTPCMapping::InitializeMap(UInt_t patch)
 {
   // see header file for class documentation
+  // method is deprecated, just kept as history for a while
 
   UInt_t fNRowsToSubtract=0;
   //The row numbers returned by digit readers used are not from zero always
@@ -182,16 +182,16 @@ void AliHLTTPCMapping::InitializeMap(UInt_t patch)
     HLTFatal("Unable to open file: %s      This means no mapping is provided.", filename.Data());
   }
   else{
-    fNHWAdd=0;
-    if(inFile >> fNHWAdd){
+    UInt_t nHWAdd=0;
+    if(inFile >> nHWAdd){
       if(inFile >> fMaxHWAdd){
         UInt_t hwAdd=0;
         UInt_t row=0;
         UInt_t pad=0;
        switch(patch){
        case 0:
-         if(fgkMapping0Size<fMaxHWAdd){
-           HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMapping0Size ,fMaxHWAdd);
+         if(fgkMappingSize[patch]<fMaxHWAdd){
+           HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
            break;
          }
          while(inFile>>hwAdd && inFile>>row && inFile>>pad){
@@ -202,11 +202,11 @@ void AliHLTTPCMapping::InitializeMap(UInt_t patch)
            fgRowMapping0[hwAdd]=row-fNRowsToSubtract;
            fgPadMapping0[hwAdd]=pad;
          }
-         fgMapping0IsDone=kTRUE;
+         fgMappingIsDone[patch]=kTRUE;
          break;
        case 1:
-         if(fgkMapping1Size<fMaxHWAdd){
-           HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMapping1Size ,fMaxHWAdd);
+         if(fgkMappingSize[patch]<fMaxHWAdd){
+           HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
            break;
          }
          while(inFile>>hwAdd && inFile>>row && inFile>>pad){
@@ -217,11 +217,11 @@ void AliHLTTPCMapping::InitializeMap(UInt_t patch)
            fgRowMapping1[hwAdd]=row-fNRowsToSubtract;
            fgPadMapping1[hwAdd]=pad;
          }
-         fgMapping1IsDone=kTRUE;
+         fgMappingIsDone[patch]=kTRUE;
          break;
        case 2:
-         if(fgkMapping2Size<fMaxHWAdd){
-           HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMapping2Size ,fMaxHWAdd);
+         if(fgkMappingSize[patch]<fMaxHWAdd){
+           HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
            break;
          }
          while(inFile>>hwAdd && inFile>>row && inFile>>pad){
@@ -232,11 +232,11 @@ void AliHLTTPCMapping::InitializeMap(UInt_t patch)
            fgRowMapping2[hwAdd]=row-fNRowsToSubtract;
            fgPadMapping2[hwAdd]=pad;
          }
-         fgMapping2IsDone=kTRUE;
+         fgMappingIsDone[patch]=kTRUE;
          break;
        case 3:
-         if(fgkMapping3Size<fMaxHWAdd){
-           HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMapping3Size ,fMaxHWAdd);
+         if(fgkMappingSize[patch]<fMaxHWAdd){
+           HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
            break;
          }
          while(inFile>>hwAdd && inFile>>row && inFile>>pad){
@@ -247,11 +247,11 @@ void AliHLTTPCMapping::InitializeMap(UInt_t patch)
            fgRowMapping3[hwAdd]=row-fNRowsToSubtract;
            fgPadMapping3[hwAdd]=pad;
          }
-         fgMapping3IsDone=kTRUE;
+         fgMappingIsDone[patch]=kTRUE;
          break;
        case 4:
-         if(fgkMapping4Size<fMaxHWAdd){
-           HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMapping4Size ,fMaxHWAdd);
+         if(fgkMappingSize[patch]<fMaxHWAdd){
+           HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
            break;
          }
          while(inFile>>hwAdd && inFile>>row && inFile>>pad){
@@ -262,11 +262,11 @@ void AliHLTTPCMapping::InitializeMap(UInt_t patch)
            fgRowMapping4[hwAdd]=row-fNRowsToSubtract;
            fgPadMapping4[(UInt_t)hwAdd]=(UInt_t)pad;
          }
-         fgMapping4IsDone=kTRUE;
+         fgMappingIsDone[patch]=kTRUE;
          break;
        case 5:
-         if(fgkMapping5Size<fMaxHWAdd){
-           HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMapping5Size ,fMaxHWAdd);
+         if(fgkMappingSize[patch]<fMaxHWAdd){
+           HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
            break;
          }
          while(inFile>>hwAdd && inFile>>row && inFile>>pad){
@@ -277,7 +277,7 @@ void AliHLTTPCMapping::InitializeMap(UInt_t patch)
            fgRowMapping5[hwAdd]=row-fNRowsToSubtract;
            fgPadMapping5[hwAdd]=pad;
          }
-         fgMapping5IsDone=kTRUE;
+         fgMappingIsDone[patch]=kTRUE;
          break;
        }
       }
@@ -290,7 +290,6 @@ UInt_t AliHLTTPCMapping::GetRow(UInt_t hwadd) const
 {
   // see header file for class documentation
   assert(fCurrentRowMapping);
-  //  assert(hwadd<=fMaxHWAdd);
   if (!fCurrentRowMapping) return 0;
   if (hwadd>fMaxHWAdd) return 0;
   return fCurrentRowMapping[hwadd];
@@ -300,12 +299,84 @@ UInt_t AliHLTTPCMapping::GetPad(UInt_t hwadd) const
 {
   // see header file for class documentation
   assert(fCurrentPadMapping);
-  //  assert(hwadd<=fMaxHWAdd);
   if (!fCurrentPadMapping) return 0;
   if (hwadd>fMaxHWAdd) return 0;
   return fCurrentPadMapping[hwadd];
 }
 
+UInt_t AliHLTTPCMapping::GetHwAddress(UInt_t row, UInt_t pad) const
+{
+  // see header file for class documentation
+  assert(fPatch<fgkNofPatches);
+  assert(fgHwaMapping[fPatch]);
+  UInt_t hwaIndex=(row<<fgkMappingHwaRowBitShift) + pad;
+  if (hwaIndex<fgkMappingHwaSize) {
+    return (fgHwaMapping[fPatch])[hwaIndex];
+  }
+  return ~((UInt_t)0);
+}
+
+Bool_t AliHLTTPCMapping::ReadArray(UInt_t patch, UInt_t arraySize, UInt_t rowArray[], UInt_t padArray[], UInt_t hwaMappingSize, UInt_t hwaArray[]) const
+{
+  // see header file for class documentation
+  //Making mapping arrays for the given patch
+  Bool_t result=kTRUE;
+
+  assert(rowArray!=NULL || padArray!=NULL || hwaArray!=NULL);
+  if (!rowArray || !padArray || !hwaArray) return kFALSE;
+
+  memset(rowArray, 0, arraySize*sizeof(rowArray[0]));
+  memset(padArray, 0, arraySize*sizeof(padArray[0]));
+  memset(hwaArray, 0, hwaMappingSize*sizeof(padArray[0]));
+
+  ifstream inFile;
+  TString filename;
+  const char* basePath=getenv("ALICE_ROOT");
+  if (basePath) {
+    filename.Form("%s/TPC/mapping/Patch%d.data", basePath,patch);
+  }
+  inFile.open(filename.Data());
+  if (!inFile) {
+    HLTFatal("Unable to open file: %s      This means no mapping is provided.", filename.Data());
+    return kFALSE;
+  }
+
+  UInt_t nHWAdd=0;
+  UInt_t maxHWAdd=0;
+  if(inFile >> nHWAdd){
+    if(inFile >> maxHWAdd){
+      if(arraySize<maxHWAdd){
+       HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch, arraySize ,fMaxHWAdd);
+       result=kFALSE;
+      }
+      UInt_t hwAdd=0;
+      UInt_t row=0;
+      UInt_t pad=0;
+      while(result && inFile>>hwAdd && inFile>>row && inFile>>pad){
+       if (hwAdd>maxHWAdd) {
+         HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", maxHWAdd);
+         result=kFALSE;
+         break;
+       }
+       Int_t dummy=0;
+       // AliHLTTPCTransform::GetFirstRow returns first row in scheme A.
+       // We have to transform to scheme B by AliHLTTPCTransform::Slice2Sector.
+       Int_t offsetSchemeB=0;
+       AliHLTTPCTransform::Slice2Sector(0, fRowOffset, dummy, offsetSchemeB);
+       rowArray[hwAdd]=row-offsetSchemeB;
+       padArray[hwAdd]=pad;
+       UInt_t hwaIndex=(rowArray[hwAdd]<<fgkMappingHwaRowBitShift) + padArray[hwAdd];
+       assert(hwaIndex<hwaMappingSize);
+       if (hwaIndex<hwaMappingSize) {
+         hwaArray[hwaIndex]=hwAdd;
+       }
+      }
+    }
+  }
+  inFile.close();
+  return result;
+}
+
 Bool_t AliHLTTPCMapping::IsValidHWAddress(UInt_t hwadd) const
 {
   if (hwadd>fMaxHWAdd){
index 56f323b..599043b 100644 (file)
@@ -3,9 +3,9 @@
 
 #ifndef ALIHLTTPCMAPPING_H
 #define ALIHLTTPCMAPPING_H
-/* This file is property of and copyright by the ALICE HLT Project        * 
- * ALICE Experiment at CERN, All rights reserved.                         *
- * See cxx source for full Copyright notice                               */
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 /** @file   AliHLTTPCMapping.h
     @author Kenneth Aamodt
     @brief  Mapping class for TPC.
 */
 
-// see below for class documentation
-// or
-// refer to README to build package
-// or
-// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
-
 #include "AliHLTLogging.h"
 
 /**
  * This is a mapping class for the TPC. It contains the mappping for all six partitions in static arrays.
  * This ensures that the asci files containing the mapping numbers is only read once per partition.
  * The only two methods interesting for the users are GetPad(hwaddress) and GetRow(hwaddress).
+ *
+ * There are several possibilities to count the rows:
+ * - A: absolute number: 0 to 158 over all partitions
+ * - B: sectorwise: 0 to 62 for inner, 0 to 95 for outer sector
+ * - C: within a partition
+ *
+ * This mappping class is designed to return the mapping within a partition (C), while the
+ * mapping files use scheme B. The first row of each partition counted in scheme B has to
+ * be subtracted.
+ *
  * @ingroup alihlt_tpc
  */
 class AliHLTTPCMapping : public AliHLTLogging {
@@ -56,6 +60,26 @@ public:
   UInt_t GetRow(UInt_t HWAddress) const;
 
   /**
+   * Get the HW addess (channel no) for a row/pad coordinate.
+   * @param row          The row in the partition
+   * @param pad          The pad in the row
+   * @return hardware address (channel no).
+   */
+  UInt_t GetHwAddress(UInt_t row, UInt_t pad) const;
+
+  /**
+   * Read the mapping array from file.
+   * @param patch           the patch (partition) to read
+   * @param arraySize       size of the mapping arrays
+   * @param rowArray        array of row mapping
+   * @param padArray        array of pad mapping
+   * @param hwaMappingSize  size of the HW address mapping
+   * @param hwaArray        array of HW address mapping (backwards mapping)
+   * @return kTRUE if successful
+   */
+  Bool_t ReadArray(UInt_t patch, UInt_t arraySize, UInt_t rowArray[], UInt_t padArray[], UInt_t hwaMappingSize, UInt_t hwaArray[]) const;
+  
+  /**
    * Checks if the hw address is valid
    * @param HWAddress    The hardware address of the pad
    * @return kTRUE if valid HWAddress 
@@ -75,23 +99,29 @@ public:
   AliHLTTPCMapping(const AliHLTTPCMapping&);
   /** assignment operator prohibited */
   AliHLTTPCMapping& operator=(const AliHLTTPCMapping&);
-  
-  //Flags to check if mapping is done for the six patches
-  /** flag to check if mapping is done for patch 0 */
-  static Bool_t fgMapping0IsDone;
-  /** flag to check if mapping is done for patch 1 */
-  static Bool_t fgMapping1IsDone;
-  /** flag to check if mapping is done for patch 2 */
-  static Bool_t fgMapping2IsDone;
-  /** flag to check if mapping is done for patch 3 */
-  static Bool_t fgMapping3IsDone;
-  /** flag to check if mapping is done for patch 4 */
-  static Bool_t fgMapping4IsDone;
-  /** flag to check if mapping is done for patch 5 */
-  static Bool_t fgMapping5IsDone;
 
+  /** the readout partition/patch */
+  UInt_t fPatch;                                                     //! transient
+
+  /** global number of patches */
+  static const UChar_t fgkNofPatches=6;                              //! transient
+
+  /** Flags to check if mapping is done for the six patches */
+  static Bool_t fgMappingIsDone[fgkNofPatches];                      //! transient
 
   /** size of mapping arrays */
+  static const UInt_t fgkMappingSize[fgkNofPatches];                 // see above
+
+  /** array of the row mappings */
+  static UInt_t* fgRowMapping[fgkNofPatches];                        //! transient
+
+  /** array of the pad mappings */
+  static UInt_t* fgPadMapping[fgkNofPatches];                        //! transient
+
+  /** array of the HW address mappings */
+  static UInt_t* fgHwaMapping[fgkNofPatches];                        //! transient
+
+  /** size of mapping array for patch 0 */
   static const UInt_t fgkMapping0Size=3200;                          // see above
   /** size of mapping array for patch 1 */
   static const UInt_t fgkMapping1Size=3584;                          // see above
@@ -104,45 +134,69 @@ public:
   /** size of mapping array for patch 5 */
   static const UInt_t fgkMapping5Size=3328;                          // see above
 
+  /** name space for HW address mapping pad encoding */
+  static const UInt_t fgkMappingHwaPadMask=0xff;                     //! transient
+  /** bit shift for HW address mapping row encoding */
+  static const UInt_t fgkMappingHwaRowMask=0x3f00;                   //! transient
+  /** name space for HW address mapping row encoding */
+  static const UChar_t fgkMappingHwaRowBitShift=8;                   //! transient
+  /** size of row/pad to channel mapping
+   * bit 0-8  encode pad
+   * bit 9-11 encode row
+   */
+  static const UInt_t fgkMappingHwaSize=0x4000;                      // see above
+
   /** row mapping array for patch 0 */
   static UInt_t fgRowMapping0[fgkMapping0Size];                      // see above
   /** pad mapping array for patch 0 */
   static UInt_t fgPadMapping0[fgkMapping0Size];                      // see above
+  /** hw address mapping array for patch 0 */
+  static UInt_t fgHwaMapping0[fgkMappingHwaSize];                    // see above
   /** row mapping array for patch 1 */
   static UInt_t fgRowMapping1[fgkMapping1Size];                      // see above
   /** pad mapping array for patch 1 */
   static UInt_t fgPadMapping1[fgkMapping1Size];                      // see above
+  /** hw address mapping array for patch 1 */
+  static UInt_t fgHwaMapping1[fgkMappingHwaSize];                    // see above
   /** row mapping array for patch 2 */
   static UInt_t fgRowMapping2[fgkMapping2Size];                      // see above
   /** pad mapping array for patch 2 */
   static UInt_t fgPadMapping2[fgkMapping2Size];                      // see above
+  /** hw address mapping array for patch 2 */
+  static UInt_t fgHwaMapping2[fgkMappingHwaSize];                    // see above
   /** row mapping array for patch 3 */
   static UInt_t fgRowMapping3[fgkMapping3Size];                      // see above
   /** pad mapping array for patch 3 */
   static UInt_t fgPadMapping3[fgkMapping3Size];                      // see above
+  /** hw addres mapping array for patch 3 */
+  static UInt_t fgHwaMapping3[fgkMappingHwaSize];                    // see above
   /** row mapping array for patch 4 */
   static UInt_t fgRowMapping4[fgkMapping4Size];                      // see above
   /** pad mapping array for patch 4 */
   static UInt_t fgPadMapping4[fgkMapping4Size];                      // see above
+  /** hw address mapping array for patch 4 */
+  static UInt_t fgHwaMapping4[fgkMappingHwaSize];                    // see above
   /** row mapping array for patch 5 */
   static UInt_t fgRowMapping5[fgkMapping5Size];                      // see above
   /** pad mapping array for patch 5 */
   static UInt_t fgPadMapping5[fgkMapping5Size];                      // see above
+  /** hw address mapping array for patch 5 */
+  static UInt_t fgHwaMapping5[fgkMappingHwaSize];                    // see above
 
   /** current row mapping array */
   UInt_t *fCurrentRowMapping;                                        //!transient
   /** current pad mapping array */
   UInt_t *fCurrentPadMapping;                                        //!transient
 
-  /** Number of hardware adresses */
-  UInt_t fNHWAdd;                                                    //!transient
+  /** number of rows */
+  Int_t fNofRows;                                                    // see above
 
   /** Maximum number of hardware addresses */
   UInt_t fMaxHWAdd;                                                  //!transient
 
-  /** The row offset of the patch*/
+  /** row offset according to scheme A (see class description) */
   Int_t fRowOffset;                                                  //!transient
 
-  ClassDef(AliHLTTPCMapping, 1)
+  ClassDef(AliHLTTPCMapping, 2)
 };
 #endif // ALIHLTTPCMAPPING_H
index 9ca80f5..184db71 100644 (file)
@@ -137,7 +137,12 @@ bool compareMapping(int patch, AliHLTTPCMapping* mapper)
     while(result && inFile>>hwAdd && inFile>>row && inFile>>pad){
       row-=rowOffset;
       if (row!=mapper->GetRow(hwAdd) || pad!=mapper->GetPad(hwAdd)) {
-       cout << "mismatch at channel " << hwAdd << ": expected " << row << "/" << pad << "  got " << mapper->GetRow(hwAdd) << "/" << mapper->GetPad(hwAdd) << endl;
+       cout << "channel to row/pad mapping mismatch at channel " << hwAdd << ": expected " << row << "/" << pad << "  got " << mapper->GetRow(hwAdd) << "/" << mapper->GetPad(hwAdd) << endl;
+       result=false;
+       break;
+      }
+      if (hwAdd!=mapper->GetHwAddress(row, pad)) {
+       cout << "row/pad to channel mapping mismatch for " << row << "/" << pad << ": expected channel:" << hwAdd << "  got " << mapper->GetHwAddress(row,pad) << endl;
        result=false;
        break;
       }