HLT/TPCLib/AliHLTTPCMapping.cxx

   1 // $Id$
   2 /**************************************************************************
   3  * This file is property of and copyright by the ALICE HLT Project        *
   4  * ALICE Experiment at CERN, All rights reserved.                         *
   5  *                                                                        *
   6  * Primary Authors: Kenneth Aamodt <kenneth@ift.uib.no>                   *
   7  *                  for The ALICE HLT Project.                            *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 /** @file   AliHLTTPCMapping.cxx
  19     @author Kenneth Aamodt
  20     @date
  21     @brief  A mapping class for the TPC.
  22 */
  23
  24 // see header file for class documentation                                   //
  25 // or                                                                        //
  26 // refer to README to build package                                          //
  27 // or                                                                        //
  28 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt                          //
  29
  30 #if __GNUC__>= 3
  31 using namespace std;
  32 #endif
  33 #include <cassert>
  34 #include "AliHLTTPCMapping.h"
  35
  36 ClassImp(AliHLTTPCMapping)
  37
  38 AliHLTTPCMapping::AliHLTTPCMapping(UInt_t patch)
  39   :
  40   fCurrentRowMapping(NULL),
  41   fCurrentPadMapping(NULL),
  42   fNHWAdd(0),
  43   fMaxHWAdd(0)
  44 {
  45   // see header file for class documentation
  46   // or
  47   // refer to README to build package
  48   // or
  49   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  50
  51   switch(patch){
  52   case 0:
  53     if(!fgMapping0IsDone){
  54       memset(fgRowMapping0, 0, fgkMapping0Size*sizeof(UInt_t));
  55       memset(fgPadMapping0, 0, fgkMapping0Size*sizeof(UInt_t));
  56       InitializeMap(patch);
  57     }
  58     fCurrentRowMapping=fgRowMapping0;
  59     fCurrentPadMapping=fgPadMapping0;
  60     fMaxHWAdd=fgkMapping0Size;
  61     break;
  62   case 1:
  63     if(!fgMapping1IsDone){
  64       memset(fgRowMapping1, 0, fgkMapping1Size*sizeof(UInt_t));
  65       memset(fgPadMapping1, 0, fgkMapping1Size*sizeof(UInt_t));
  66       InitializeMap(patch);
  67     }
  68     fCurrentRowMapping=fgRowMapping1;
  69     fCurrentPadMapping=fgPadMapping1;
  70     fMaxHWAdd=fgkMapping1Size;
  71     break;
  72   case 2:
  73     if(!fgMapping2IsDone){
  74       memset(fgRowMapping2, 0, fgkMapping2Size*sizeof(UInt_t));
  75       memset(fgPadMapping2, 0, fgkMapping2Size*sizeof(UInt_t));
  76       InitializeMap(patch);
  77     }
  78     fCurrentRowMapping=fgRowMapping2;
  79     fCurrentPadMapping=fgPadMapping2;
  80     fMaxHWAdd=fgkMapping2Size;
  81     break;
  82   case 3:
  83     if(!fgMapping3IsDone){
  84       memset(fgRowMapping3, 0, fgkMapping3Size*sizeof(UInt_t));
  85       memset(fgPadMapping3, 0, fgkMapping3Size*sizeof(UInt_t));
  86       InitializeMap(patch);
  87     }
  88     fCurrentRowMapping=fgRowMapping3;
  89     fCurrentPadMapping=fgPadMapping3;
  90     fMaxHWAdd=fgkMapping3Size;
  91     break;
  92   case 4:
  93     if(!fgMapping4IsDone){
  94       memset(fgRowMapping4, 0, fgkMapping4Size*sizeof(UInt_t));
  95       memset(fgPadMapping4, 0, fgkMapping4Size*sizeof(UInt_t));
  96       InitializeMap(patch);
  97     }
  98     fCurrentRowMapping=fgRowMapping4;
  99     fCurrentPadMapping=fgPadMapping4;
 100     fMaxHWAdd=fgkMapping4Size;
 101     break;
 102   case 5:
 103     if(!fgMapping5IsDone){
 104       memset(fgRowMapping5, 0, fgkMapping5Size*sizeof(UInt_t));
 105       memset(fgPadMapping5, 0, fgkMapping5Size*sizeof(UInt_t));
 106       InitializeMap(patch);
 107     }
 108     fCurrentRowMapping=fgRowMapping5;
 109     fCurrentPadMapping=fgPadMapping5;
 110     fMaxHWAdd=fgkMapping5Size;
 111     break;
 112   }
 113 }
 114
 115 Bool_t AliHLTTPCMapping::fgMapping0IsDone=kFALSE;
 116 Bool_t AliHLTTPCMapping::fgMapping1IsDone=kFALSE;
 117 Bool_t AliHLTTPCMapping::fgMapping2IsDone=kFALSE;
 118 Bool_t AliHLTTPCMapping::fgMapping3IsDone=kFALSE;
 119 Bool_t AliHLTTPCMapping::fgMapping4IsDone=kFALSE;
 120 Bool_t AliHLTTPCMapping::fgMapping5IsDone=kFALSE;
 121 UInt_t AliHLTTPCMapping::fgRowMapping0[fgkMapping0Size];
 122 UInt_t AliHLTTPCMapping::fgPadMapping0[fgkMapping0Size];
 123 UInt_t AliHLTTPCMapping::fgRowMapping1[fgkMapping1Size];
 124 UInt_t AliHLTTPCMapping::fgPadMapping1[fgkMapping1Size];
 125 UInt_t AliHLTTPCMapping::fgRowMapping2[fgkMapping2Size];
 126 UInt_t AliHLTTPCMapping::fgPadMapping2[fgkMapping2Size];
 127 UInt_t AliHLTTPCMapping::fgRowMapping3[fgkMapping3Size];
 128 UInt_t AliHLTTPCMapping::fgPadMapping3[fgkMapping3Size];
 129 UInt_t AliHLTTPCMapping::fgRowMapping4[fgkMapping4Size];
 130 UInt_t AliHLTTPCMapping::fgPadMapping4[fgkMapping4Size];
 131 UInt_t AliHLTTPCMapping::fgRowMapping5[fgkMapping5Size];
 132 UInt_t AliHLTTPCMapping::fgPadMapping5[fgkMapping5Size];
 133
 134 AliHLTTPCMapping::~AliHLTTPCMapping(){
 135   // see header file for class documentation
 136 }
 137
 138 void AliHLTTPCMapping::InitializeMap(UInt_t patch)
 139 {
 140   // see header file for class documentation
 141
 142   UInt_t fNRowsToSubtract=0;
 143   //The row numbers returned by digit readers used are not from zero always
 144   switch(patch){
 145   case 0:
 146     fNRowsToSubtract=0;
 147     break;
 148   case 1:
 149     fNRowsToSubtract=30;
 150     break;
 151   case 2:
 152     fNRowsToSubtract=0;
 153     break;
 154   case 3:
 155     fNRowsToSubtract=27;
 156     break;
 157   case 4:
 158     fNRowsToSubtract=54;
 159     break;
 160   case 5:
 161     fNRowsToSubtract=76;
 162     break;
 163   }
 164
 165   //Making mapping arrays for the given patch
 166   ifstream inFile;
 167   TString filename;
 168   const char* basePath=getenv("ALICE_ROOT");
 169   if (basePath) {
 170     filename.Form("%s/TPC/mapping/Patch%d.data", basePath,patch);
 171   }
 172   inFile.open(filename.Data());
 173   if (!inFile) {
 174     HLTFatal("Unable to open file: %s      This means no mapping is provided.", filename.Data());
 175   }
 176   else{
 177     fNHWAdd=0;
 178     if(inFile >> fNHWAdd){
 179       if(inFile >> fMaxHWAdd){
 180         UInt_t hwAdd=0;
 181         UInt_t row=0;
 182         UInt_t pad=0;
 183         switch(patch){
 184         case 0:
 185           if(fgkMapping0Size<fMaxHWAdd){
 186             HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMapping0Size ,fMaxHWAdd);
 187             break;
 188           }
 189           while(inFile>>hwAdd && inFile>>row && inFile>>pad){
 190             if (hwAdd>fMaxHWAdd) {
 191               HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
 192               break;
 193             }
 194             fgRowMapping0[hwAdd]=row-fNRowsToSubtract;
 195             fgPadMapping0[hwAdd]=pad;
 196           }
 197           fgMapping0IsDone=kTRUE;
 198           break;
 199         case 1:
 200           if(fgkMapping1Size<fMaxHWAdd){
 201             HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMapping1Size ,fMaxHWAdd);
 202             break;
 203           }
 204           while(inFile>>hwAdd && inFile>>row && inFile>>pad){
 205             if (hwAdd>fMaxHWAdd) {
 206               HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
 207               break;
 208             }
 209             fgRowMapping1[hwAdd]=row-fNRowsToSubtract;
 210             fgPadMapping1[hwAdd]=pad;
 211           }
 212           fgMapping1IsDone=kTRUE;
 213           break;
 214         case 2:
 215           if(fgkMapping2Size<fMaxHWAdd){
 216             HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMapping2Size ,fMaxHWAdd);
 217             break;
 218           }
 219           while(inFile>>hwAdd && inFile>>row && inFile>>pad){
 220             if (hwAdd>fMaxHWAdd) {
 221               HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
 222               break;
 223             }
 224             fgRowMapping2[hwAdd]=row-fNRowsToSubtract;
 225             fgPadMapping2[hwAdd]=pad;
 226           }
 227           fgMapping2IsDone=kTRUE;
 228           break;
 229         case 3:
 230           if(fgkMapping3Size<fMaxHWAdd){
 231             HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMapping3Size ,fMaxHWAdd);
 232             break;
 233           }
 234           while(inFile>>hwAdd && inFile>>row && inFile>>pad){
 235             if (hwAdd>fMaxHWAdd) {
 236               HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
 237               break;
 238             }
 239             fgRowMapping3[hwAdd]=row-fNRowsToSubtract;
 240             fgPadMapping3[hwAdd]=pad;
 241           }
 242           fgMapping3IsDone=kTRUE;
 243           break;
 244         case 4:
 245           if(fgkMapping4Size<fMaxHWAdd){
 246             HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMapping4Size ,fMaxHWAdd);
 247             break;
 248           }
 249           while(inFile>>hwAdd && inFile>>row && inFile>>pad){
 250             if (hwAdd>fMaxHWAdd) {
 251               HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
 252               break;
 253             }
 254             fgRowMapping4[hwAdd]=row-fNRowsToSubtract;
 255             fgPadMapping4[(UInt_t)hwAdd]=(UInt_t)pad;
 256           }
 257           fgMapping4IsDone=kTRUE;
 258           break;
 259         case 5:
 260           if(fgkMapping5Size<fMaxHWAdd){
 261             HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMapping5Size ,fMaxHWAdd);
 262             break;
 263           }
 264           while(inFile>>hwAdd && inFile>>row && inFile>>pad){
 265             if (hwAdd>fMaxHWAdd) {
 266               HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
 267               break;
 268             }
 269             fgRowMapping5[hwAdd]=row-fNRowsToSubtract;
 270             fgPadMapping5[hwAdd]=pad;
 271           }
 272           fgMapping5IsDone=kTRUE;
 273           break;
 274         }
 275       }
 276     }
 277   }
 278   inFile.close();
 279 }
 280
 281 UInt_t AliHLTTPCMapping::GetRow(UInt_t hwadd) const
 282 {
 283   // see header file for class documentation
 284   assert(fCurrentRowMapping);
 285   //  assert(hwadd<=fMaxHWAdd);
 286   if (!fCurrentRowMapping) return 0;
 287   if (hwadd>fMaxHWAdd) return 1000;
 288   return fCurrentRowMapping[hwadd];
 289 }
 290
 291 UInt_t AliHLTTPCMapping::GetPad(UInt_t hwadd) const
 292 {
 293   // see header file for class documentation
 294   assert(fCurrentPadMapping);
 295   //  assert(hwadd<=fMaxHWAdd);
 296   if (!fCurrentPadMapping) return 0;
 297   if (hwadd>fMaxHWAdd) return 1000;
 298   return fCurrentPadMapping[hwadd];
 299 }