HLT/TPCLib/AliHLTTPCDigitReaderPacked.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * This file is property of and copyright by the ALICE HLT Project        *
   5  * ALICE Experiment at CERN, All rights reserved.                         *
   6  *                                                                        *
   7  * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
   8  *                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
   9  *                  Jochen Thaeder <thaeder@kip.uni-heidelberg.de>        *
  10  *                  for The ALICE HLT Project.                            *
  11  *                                                                        *
  12  * Permission to use, copy, modify and distribute this software and its   *
  13  * documentation strictly for non-commercial purposes is hereby granted   *
  14  * without fee, provided that the above copyright notice appears in all   *
  15  * copies and that both the copyright notice and this permission notice   *
  16  * appear in the supporting documentation. The authors make no claims     *
  17  * about the suitability of this software for any purpose. It is          *
  18  * provided "as is" without express or implied warranty.                  *
  19  **************************************************************************/
  20
  21 /** @file   AliHLTTPCDigitReaderPacked.cxx
  22     @author Timm Steinbeck, Jochen Thaeder, Matthias Richter, Kenneth Aamodt
  23     @date
  24     @brief  A digit reader implementation for simulated, packed TPC 'raw' data.
  25 */
  26
  27 #if __GNUC__>= 3
  28 using namespace std;
  29 #endif
  30
  31 #include "AliHLTTPCDigitReaderPacked.h"
  32
  33 #include "AliTPCRawStream.h"
  34 #include "AliRawReaderMemory.h"
  35 #include "AliRawDataHeader.h"
  36
  37 //#if ENABLE_PAD_SORTING
  38 #include "AliHLTTPCTransform.h"
  39 //#endif // ENABLE_PAD_SORTING
  40 #include "AliHLTStdIncludes.h"
  41
  42 ClassImp(AliHLTTPCDigitReaderPacked)
  43
  44 #if defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
  45 AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked()
  46   :
  47   //#if ENABLE_PAD_SORTING
  48   fCurrentRow(0),
  49   fCurrentPad(0),
  50   fCurrentBin(-1),
  51   fNRows(0),
  52   fRowOffset(0),
  53   fNMaxRows(0),
  54   fNMaxPads(0),
  55   fNTimeBins(0),
  56   fData(NULL),
  57   //#endif // ENABLE_PAD_SORTING
  58   fRawMemoryReader(NULL),
  59   fTPCRawStream(NULL),
  60   fOldRCUFormat(kFALSE),
  61   fUnsorted(kFALSE)
  62 {
  63   fRawMemoryReader = new AliRawReaderMemory;
  64
  65   fTPCRawStream = new AliTPCRawStream( fRawMemoryReader );
  66
  67   //#if ENABLE_PAD_SORTING
  68   // get max number of rows
  69   for (Int_t ii=0; ii < 6; ii++)
  70       if (AliHLTTPCTransform::GetNRows(ii) > fNMaxRows)
  71           fNMaxRows = AliHLTTPCTransform::GetNRows(ii);
  72
  73   // get max number of pads
  74   for (Int_t ii=0; ii < AliHLTTPCTransform::GetNRows();ii++ )
  75       if (AliHLTTPCTransform::GetNPads(ii) > fNMaxPads)
  76           fNMaxPads = AliHLTTPCTransform::GetNPads(ii);
  77
  78   // get max number of bins
  79   fNTimeBins = AliHLTTPCTransform::GetNTimeBins();
  80
  81   HLTDebug("Array Borders  ||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d",
  82            fNMaxPads, fNMaxRows, fNTimeBins, fNTimeBins*fNMaxRows*fNMaxPads);
  83
  84   // init Data array
  85   fData = new Int_t[ fNMaxRows*fNMaxPads*fNTimeBins ];
  86   //#endif // ENABLE_PAD_SORTING
  87 }
  88
  89 AliHLTTPCDigitReaderPacked::~AliHLTTPCDigitReaderPacked(){
  90   if ( fRawMemoryReader )
  91     delete fRawMemoryReader;
  92   fRawMemoryReader = NULL;
  93   if ( fTPCRawStream )
  94       delete fTPCRawStream;
  95   fTPCRawStream = NULL;
  96   //#if ENABLE_PAD_SORTING
  97   if ( fData )
  98       delete [] fData;
  99   fData = NULL;
 100   //#endif // ENABLE_PAD_SORTING
 101 }
 102
 103 Int_t AliHLTTPCDigitReaderPacked::InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice){
 104
 105   fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( ptr ), size );
 106
 107   //get DDL ID in order to tell the memory reader which slice/patch to use
 108   Int_t DDLid= 0;
 109   if (patch < 2)
 110     DDLid = 768 + 2*slice + patch;
 111   else
 112     DDLid = 840 + 4*slice + patch-2;
 113
 114   fRawMemoryReader->SetEquipmentID(DDLid);
 115   //fRawMemoryReader->SetEquipmentID(1);
 116   if(fOldRCUFormat)
 117     fTPCRawStream->SetOldRCUFormat(kTRUE);
 118
 119   if(!fUnsorted){
 120   //#if ENABLE_PAD_SORTING
 121
 122   fCurrentRow = 0;
 123   fCurrentPad = 0;
 124   fCurrentBin = -1;
 125
 126   Int_t firstrow=AliHLTTPCTransform::GetFirstRow(patch);
 127   Int_t lastrow=AliHLTTPCTransform::GetLastRow(patch);
 128   fNRows = lastrow - firstrow + 1;
 129
 130   Int_t offset=0;
 131   if (patch > 1) offset =  AliHLTTPCTransform::GetFirstRow( 2 );
 132
 133   fRowOffset = firstrow - offset;
 134   firstrow -= offset;
 135   lastrow  -= offset;
 136
 137   // Init array with -1
 138   memset( fData, 0xFF, sizeof(Int_t)*(fNMaxRows*fNMaxPads*fNTimeBins) );
 139
 140   // read data and fill in array
 141   while( fTPCRawStream->Next()){
 142
 143       Int_t row = fTPCRawStream->GetRow();
 144       Int_t pad = fTPCRawStream->GetPad();
 145       Int_t bin = fTPCRawStream->GetTime();
 146
 147       if ( row < firstrow || row > lastrow || pad > AliHLTTPCTransform::GetNPads(row + offset) || bin > fNTimeBins){
 148         HLTFatal("Index out of Range Probably wrong patch! %d - %d", slice, patch);
 149         if ( row < firstrow || row > lastrow )
 150           HLTFatal("Row out of Range %d < %d < %d",firstrow, row, lastrow);
 151         if ( pad > AliHLTTPCTransform::GetNPads(row + offset) )
 152           HLTFatal("Pad out of Range %d < %d < %d",pad, AliHLTTPCTransform::GetNPads(row + offset));
 153         if ( bin > fNTimeBins )
 154           HLTFatal("Bin out of Range %d < %d < %d",bin, fNTimeBins);
 155       }
 156       else {
 157           if ((row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin >=  fNMaxRows*fNMaxPads*fNTimeBins ) {
 158               HLTFatal("Index out of array range PAD=%d ||| ROW=%d ||| BIN=%d ||| OFFSET=%d ||| ROWOFFSET=%d", pad, row, bin, offset, fRowOffset);
 159               continue;
 160           }
 161           else {
 162               fData[ (row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin ] = fTPCRawStream->GetSignal() ;
 163           }
 164       }
 165   }
 166   //#endif // ENABLE_PAD_SORTING
 167   }
 168   return 0;
 169 }
 170
 171 Bool_t AliHLTTPCDigitReaderPacked::NextSignal(){
 172   Bool_t readvalue = kTRUE;
 173
 174   if(!fUnsorted){//added for test
 175     //#if ENABLE_PAD_SORTING
 176     while (1) {
 177       fCurrentBin++;
 178       if (fCurrentBin >= fNTimeBins){
 179           fCurrentBin = 0;
 180           fCurrentPad++;
 181
 182           if (fCurrentPad >=fNMaxPads){
 183               fCurrentPad = 0;
 184               fCurrentRow++;
 185
 186               if (fCurrentRow >= fNMaxRows){
 187                   readvalue = kFALSE;
 188                   break;
 189               }
 190           }
 191       }
 192
 193       if (fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin >=  fNMaxRows*fNMaxPads*fNTimeBins ) {
 194           HLTFatal("Overflow: row=%d pad=%d bin=%d", fCurrentRow, fCurrentPad, fCurrentBin);
 195           readvalue = kFALSE;
 196           break;
 197       }
 198
 199       if (fData[ fCurrentRow*fNMaxPads*fNTimeBins + fCurrentPad*fNTimeBins + fCurrentBin  ] != -1) break;
 200     }
 201   }// added for test
 202   else{//added for test
 203     //#else // !ENABLE_PAD_SORTING
 204     readvalue = fTPCRawStream->Next();
 205   }//added for test
 206   //#endif // ENABLE_PAD_SORTING
 207
 208   return readvalue;
 209 }
 210
 211 Int_t AliHLTTPCDigitReaderPacked::GetRow(){
 212   /*#if ENABLE_PAD_SORTING
 213   return (fCurrentRow + fRowOffset);
 214 #else // !ENABLE_PAD_SORTING
 215   return (Int_t) fTPCRawStream->GetRow();
 216 #endif // ENABLE_PAD_SORTING
 217   */
 218   if(!fUnsorted){
 219   return (fCurrentRow + fRowOffset);
 220   }
 221   else{
 222   return (Int_t) fTPCRawStream->GetRow();
 223   }
 224 }
 225
 226 int AliHLTTPCDigitReaderPacked::GetPad(){
 227   /*#if ENABLE_PAD_SORTING
 228     return fCurrentPad;
 229     #else // !ENABLE_PAD_SORTING
 230     return fTPCRawStream->GetPad();
 231     #endif // ENABLE_PAD_SORTING
 232   */
 233   if(!fUnsorted){
 234     return fCurrentPad;
 235   }
 236   else{
 237     return fTPCRawStream->GetPad();
 238   }
 239 }
 240
 241 Int_t AliHLTTPCDigitReaderPacked::GetSignal(){
 242   /*
 243     #if ENABLE_PAD_SORTING
 244     return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ];
 245     #else // !ENABLE_PAD_SORTING
 246     return fTPCRawStream->GetSignal();
 247     #endif // ENABLE_PAD_SORTING
 248   */
 249   if(!fUnsorted){
 250     return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ];
 251   }
 252   else{
 253     return fTPCRawStream->GetSignal();
 254   }
 255 }
 256
 257 Int_t AliHLTTPCDigitReaderPacked::GetTime(){
 258   /*
 259     #if ENABLE_PAD_SORTING
 260     return fCurrentBin;
 261     #else // !ENABLE_PAD_SORTING
 262     return fTPCRawStream->GetTime();
 263     #endif // ENABLE_PAD_SORTING
 264   */
 265   if(!fUnsorted){
 266     return fCurrentBin;
 267   }
 268   else{
 269     return fTPCRawStream->GetTime();
 270   }
 271 }
 272 #endif //defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)