HLT/TPCLib/AliHLTTPCDDLDataFileHandler.cxx

   1 // @(#) $Id$
   2
   3 // Author: C. Loizides <loizides@ikf.uni-frankfurt.de>
   4 //*-- Copyright &copy ALICE HLT Group
   5
   6 #include "AliHLTTPCRootTypes.h"
   7 #include "AliHLTTPCLogging.h"
   8 #include "AliHLTTPCTransform.h"
   9 #include "AliHLTTPCMemHandler.h"
  10 #include "AliHLTTPCDigitData.h"
  11 #ifdef use_newio
  12 #include "AliRawReaderRoot.h"
  13 #include "AliRawReaderDate.h"
  14 #else
  15 #include "AliHLTTPCDDLTPCRawStream.h"
  16 #include "AliHLTTPCDDLRawReaderFile.h"
  17 #endif
  18 #include "AliHLTTPCDDLDataFileHandler.h"
  19
  20 #if __GNUC__ >= 3
  21 using namespace std;
  22 #endif
  23
  24 /** \class AliHLTTPCDDLDataFileHandler
  25 <pre>
  26 //_____________________________________________________________
  27 // AliHLTTPCDDLDataFileHandler
  28 //
  29 //  This class does converts from the DDL format of offline
  30 //  into the memory I/O handling of the HLT binary files.
  31 //
  32 //  Examples: see ddl2binary in exa and the general
  33 //            AliHLTTPCMemHandler class description
  34 //
  35 </pre>
  36 */
  37
  38 ClassImp(AliHLTTPCDDLDataFileHandler)
  39
  40 AliHLTTPCDDLDataFileHandler::AliHLTTPCDDLDataFileHandler()
  41 {
  42   // default constructor
  43   fReader=0;
  44   fTPCStream=0;
  45 }
  46
  47 AliHLTTPCDDLDataFileHandler::~AliHLTTPCDDLDataFileHandler()
  48 {
  49   // destructor
  50   FreeAll();
  51 }
  52
  53 void AliHLTTPCDDLDataFileHandler::FreeAll()
  54 {
  55   // frees all heap memory
  56   if(fReader) delete fReader;
  57   fReader = 0;
  58   if(fTPCStream) delete fTPCStream;
  59   fTPCStream = 0;
  60 }
  61
  62
  63 #ifdef use_newio
  64 Bool_t AliHLTTPCDDLDataFileHandler::SetReaderInput(AliRawEvent *rawevent)
  65 {
  66   // sets the input of the reader
  67   fEvent=-1;
  68   fFilename="";
  69   if(fReader) delete fReader;
  70   fReader=new AliRawReaderRoot(rawevent);
  71   if(fTPCStream) delete fTPCStream;
  72   fTPCStream=new AliTPCRawStream(fReader);
  73
  74   return kTRUE;
  75 }
  76
  77 Bool_t AliHLTTPCDDLDataFileHandler::SetReaderInput(Char_t *name,Int_t event)
  78 {
  79   // sets the input of the reader
  80   fEvent=event;
  81   if(fReader) delete fReader;
  82   if(fTPCStream) delete fTPCStream;
  83   if(event>=0){
  84     fFilename=name;
  85     fReader=new AliRawReaderRoot(name,event);
  86   } else {
  87     fFilename="";
  88     fReader=new AliRawReaderDate((void *)name);
  89   }
  90   fTPCStream=new AliTPCRawStream(fReader);
  91
  92   return kTRUE;
  93 }
  94 #else
  95 Bool_t AliHLTTPCDDLDataFileHandler::SetReaderInput(Char_t *name, Bool_t add)
  96 {
  97   // sets the input of the reader
  98   if(fReader){
  99     LOG(AliHLTTPCLog::kError,"AliHLTTPCDDLDataFileHandler::SetReaderInput","File Open")
 100       <<"Reader ptr is already in use"<<ENDLOG;
 101     return kFALSE;
 102   }
 103
 104   fReader=new AliHLTTPCDDLRawReaderFile(name,add);
 105   fTPCStream=new AliHLTTPCDDLTPCRawStream(fReader);
 106
 107   return kTRUE;
 108 }
 109 Bool_t AliHLTTPCDDLDataFileHandler::SetReaderInput(AliHLTTPCDDLRawReaderFile *rf)
 110 {
 111   // sets the input of the reader
 112   if(fReader){
 113     LOG(AliHLTTPCLog::kError,"AliHLTTPCRawDataFileHandler::SetReaderInput","File Open")
 114       <<"Reader ptr is already in use, delete it first"<<ENDLOG;
 115     return kFALSE;
 116   }
 117
 118   //Open the raw data file with given file.
 119   fReader = rf;
 120   fTPCStream=new AliHLTTPCDDLTPCRawStream(fReader);
 121
 122   return kTRUE;
 123 }
 124 #endif
 125
 126 void AliHLTTPCDDLDataFileHandler::CloseReaderInput()
 127 {
 128   // closes the input of the reader
 129   if(!fReader){
 130     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCRawDataFileHandler::CloseReaderInput","File Close")
 131       <<"Nothing to Close"<<ENDLOG;
 132     return;
 133   }
 134
 135   delete fReader;
 136   delete fTPCStream;
 137   fReader = 0;
 138   fTPCStream = 0;
 139 }
 140
 141 #ifdef use_newio
 142 Bool_t AliHLTTPCDDLDataFileHandler::IsDigit(Int_t /*i*/) const
 143 {
 144   // dummy
 145   return kTRUE;
 146 }
 147 #endif
 148
 149 #ifndef fast_raw
 150 AliHLTTPCDigitRowData * AliHLTTPCDDLDataFileHandler::DDLData2Memory(UInt_t &nrow,Int_t event)
 151 {
 152   // transfers the DDL data to the memory
 153 #ifdef use_newio
 154   if((fEvent>=0)&&(event!=fEvent)){
 155     fEvent=event;
 156     if(fReader) delete fReader;
 157     if(fTPCStream) delete fTPCStream;
 158     fReader=new AliRawReaderRoot(fFilename,event);
 159     fTPCStream=new AliTPCRawStream(fReader);
 160   }
 161 #endif
 162   AliHLTTPCDigitRowData *data = 0;
 163   nrow=0;
 164
 165   if(!fReader){
 166     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCDDLDataFileHandler::DDLData2Memory","File")
 167     <<"No Input avalible: no object AliHLTTPCDDLRawReaderFile"<<ENDLOG;
 168     return 0;
 169   }
 170
 171   Int_t nrows=fRowMax-fRowMin+1;
 172   Int_t ndigitcount=0;
 173   Int_t * ndigits = new Int_t[nrows];
 174   UShort_t ***charges=new UShort_t**[nrows];
 175   for(Int_t r=fRowMin;r<=fRowMax;r++){
 176     Int_t lrow=r-fRowMin;
 177     charges[lrow]=new UShort_t*[AliHLTTPCTransform::GetNPads(r)];
 178     for(Int_t k=0;k<AliHLTTPCTransform::GetNPads(r);k++){
 179       charges[lrow][k]=new UShort_t[AliHLTTPCTransform::GetNTimeBins()];
 180       for(Int_t j=0;j<AliHLTTPCTransform::GetNTimeBins();j++) charges[lrow][k][j]=0;
 181     }
 182   }
 183
 184   Int_t ddlsToSearch=0;
 185   Int_t ddls[9]={-1,-1,-1,-1,-1,-1,-1,-1,-1};
 186   Int_t ddlid=-1,lddlid=-1;
 187   for(Int_t r=fRowMin;r<=fRowMax;r++){
 188     ndigits[r-fRowMin] = 0; //now digits on row
 189
 190     Int_t patch=AliHLTTPCTransform::GetPatch(r);
 191     Int_t sector,row;
 192     AliHLTTPCTransform::Slice2Sector(fSlice,r,sector,row);
 193
 194     if(sector<36) //taken from AliTPCBuffer160.cxx
 195       ddlid=sector*2+patch;
 196     else
 197       ddlid=70+(sector-36)*4+patch;
 198
 199     if((lddlid!=ddlid-1)&&(r==30)){ //dont forget the split row on the last ddl
 200       ddls[ddlsToSearch++]=ddlid-1;
 201       lddlid=ddlid-1;
 202     }
 203
 204     if((lddlid==-1)||(ddlid!=lddlid)){
 205       ddls[ddlsToSearch++]=ddlid;
 206       lddlid=ddlid;
 207     }
 208     if((r==90)||(r==139)){ //dont forget the split row on the next ddl
 209       ddls[ddlsToSearch++]=ddlid+1;
 210       lddlid=ddlid+1;
 211     }
 212   }
 213
 214   //  for(Int_t i=0;i<ddlsToSearch;i++) cout << ddls[i] <<endl;
 215
 216   if(ddls[0]>ddls[ddlsToSearch-1]) {
 217     Int_t tempddl = ddls[0];
 218     ddls[0] = ddls[ddlsToSearch-1];
 219     ddls[ddlsToSearch-1] = tempddl;
 220   }
 221 #ifdef use_newio
 222     fReader->Reset();
 223     fReader->Select(0,ddls[0],ddls[ddlsToSearch-1]);
 224     fTPCStream->Reset();
 225 #else
 226     fTPCStream->SetDDLID(ddls[i]); //ddl to read out
 227 #endif
 228     Int_t zerosup = AliHLTTPCTransform::GetZeroSup();
 229     Int_t adcsat = AliHLTTPCTransform::GetADCSat();
 230     Int_t slice,srow;
 231     Int_t lrow=-1;
 232
 233     while (fTPCStream->Next()){
 234
 235       if(fTPCStream->IsNewSector() || fTPCStream->IsNewRow()) {
 236         Int_t sector=fTPCStream->GetSector();
 237         Int_t row=fTPCStream->GetRow();
 238         AliHLTTPCTransform::Sector2Slice(slice,srow,sector,row);
 239         if(slice!=fSlice){
 240           LOG(AliHLTTPCLog::kError,"AliHLTTPCDDLDataFileHandler::DDLDigits2Memory","Slice")
 241             <<AliHLTTPCLog::kDec<<"Found slice "<<slice<<", expected "<<fSlice<<ENDLOG;
 242           continue;
 243         }
 244         lrow=srow-fRowMin;
 245       }
 246
 247       //test row criteria (patch boundaries)
 248       if((srow<fRowMin)||(srow>fRowMax))continue;
 249
 250       Int_t pad=fTPCStream->GetPad();
 251       if(fTPCStream->IsNewPad()) {
 252         if((pad<0)||(pad>=AliHLTTPCTransform::GetNPads(srow))){
 253           LOG(AliHLTTPCLog::kError,"AliHLTTPCDDLDataFileHandler::DDLDigits2Memory","Pad")
 254             <<AliHLTTPCLog::kDec<<"Pad value out of bounds "<<pad<<" "
 255             <<AliHLTTPCTransform::GetNPads(srow)<<ENDLOG;
 256           continue;
 257         }
 258       }
 259
 260       Int_t time=fTPCStream->GetTime();
 261       if((time<0)||(time>=AliHLTTPCTransform::GetNTimeBins())){
 262         LOG(AliHLTTPCLog::kError,"AliHLTTPCDDLDataFileHandler::DDLDigits2Memory","Time")
 263           <<AliHLTTPCLog::kDec<<"Time out of bounds "<<time<<" "
 264           <<AliHLTTPCTransform::GetNTimeBins()<<ENDLOG;
 265         continue;
 266       }
 267
 268       //store digit
 269       UShort_t dig=fTPCStream->GetSignal();
 270       if(dig <= zerosup) continue;
 271       if(dig >= adcsat) dig = adcsat;
 272
 273       ndigits[lrow]++; //for this row only
 274       ndigitcount++;   //total number of digits to be published
 275
 276       charges[lrow][pad][time]=dig;
 277     }
 278
 279   Int_t size = sizeof(AliHLTTPCDigitData)*ndigitcount
 280     + nrows*sizeof(AliHLTTPCDigitRowData);
 281
 282   LOG(AliHLTTPCLog::kDebug,"AliHLTTPCDDLDataFileHandler::DDLDigits2Memory","Digits")
 283     <<AliHLTTPCLog::kDec<<"Found "<<ndigitcount<<" Digits"<<ENDLOG;
 284
 285   data=(AliHLTTPCDigitRowData*) Allocate(size);
 286   nrow = (UInt_t)nrows;
 287   AliHLTTPCDigitRowData *tempPt = data;
 288
 289   for(Int_t r=fRowMin;r<=fRowMax;r++){
 290     Int_t lrow=r-fRowMin;
 291     tempPt->fRow = r;
 292     tempPt->fNDigit = ndigits[lrow];
 293
 294     Int_t localcount=0;
 295     for(Int_t pad=0;pad<AliHLTTPCTransform::GetNPads(r);pad++){
 296       for(Int_t time=0;time<AliHLTTPCTransform::GetNTimeBins();time++){
 297         UShort_t dig=charges[lrow][pad][time];
 298         if(!dig) continue;
 299
 300         if(localcount >= ndigits[lrow])
 301           LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDDLDataFileHandler::DDLDigits2Binary","Memory")
 302             <<AliHLTTPCLog::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
 303             <<ndigits[lrow]<<ENDLOG;
 304
 305
 306         tempPt->fDigitData[localcount].fCharge=dig;
 307         tempPt->fDigitData[localcount].fPad=pad;
 308         tempPt->fDigitData[localcount].fTime=time;
 309 #ifdef do_mc
 310         tempPt->fDigitData[localcount].fTrackID[0] = 0;
 311         tempPt->fDigitData[localcount].fTrackID[1] = 0;
 312         tempPt->fDigitData[localcount].fTrackID[2] = 0;
 313 #endif
 314         localcount++;
 315       }
 316     }
 317
 318     if(localcount != ndigits[lrow])
 319       LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDDLDataFileHandler::DDLDigits2Binary","Memory")
 320         <<AliHLTTPCLog::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
 321         <<ndigits[lrow]<<ENDLOG;
 322
 323
 324     Byte_t *tmp = (Byte_t*)tempPt;
 325     Int_t size = sizeof(AliHLTTPCDigitRowData)
 326                                       + ndigits[lrow]*sizeof(AliHLTTPCDigitData);
 327     tmp += size;
 328     tempPt = (AliHLTTPCDigitRowData*)tmp;
 329   }
 330
 331   //delete charge array
 332   for(Int_t r=fRowMin;r<=fRowMax;r++){
 333     Int_t lrow=r-fRowMin;
 334     for(Int_t k=0;k<AliHLTTPCTransform::GetNPads(r);k++)
 335         delete charges[lrow][k];
 336     delete charges[lrow];
 337   }
 338   delete charges;
 339   delete [] ndigits;
 340
 341   return data;
 342 }
 343 #else
 344 AliHLTTPCDigitRowData * AliHLTTPCDDLDataFileHandler::DDLData2Memory(UInt_t &nrow,Int_t event)
 345 {
 346   // transfers the DDL data to the memory
 347 #ifdef use_newio
 348   if((fEvent>=0)&&(event!=fEvent)){
 349     fEvent=event;
 350     if(fReader) delete fReader;
 351     if(fTPCStream) delete fTPCStream;
 352     fReader=new AliRawReaderRoot(fFilename,event);
 353     fTPCStream=new AliTPCRawStream(fReader);
 354   }
 355 #endif
 356   AliHLTTPCDigitRowData *data = 0;
 357   nrow=0;
 358
 359   if(!fReader){
 360     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCDDLDataFileHandler::DDLData2Memory","File")
 361     <<"No Input avalible: no object AliHLTTPCDDLRawReaderFile"<<ENDLOG;
 362     return 0;
 363   }
 364
 365   Int_t nrows=fRowMax-fRowMin+1;
 366
 367   Int_t ddlsToSearch=0;
 368   Int_t ddls[9]={-1,-1,-1,-1,-1,-1,-1,-1,-1};
 369   Int_t ddlid=-1,lddlid=-1;
 370   for(Int_t r=fRowMin;r<=fRowMax;r++){
 371
 372     Int_t patch=AliHLTTPCTransform::GetPatch(r);
 373     Int_t sector,row;
 374     AliHLTTPCTransform::Slice2Sector(fSlice,r,sector,row);
 375
 376     if(sector<36) //taken from AliTPCBuffer160.cxx
 377       ddlid=sector*2+patch;
 378     else
 379       ddlid=70+(sector-36)*4+patch;
 380
 381     if((lddlid==-1)||(ddlid!=lddlid)){
 382       ddls[ddlsToSearch++]=ddlid;
 383       lddlid=ddlid;
 384     }
 385   }
 386
 387   //  for(Int_t i=0;i<ddlsToSearch;i++) cout << ddls[i] <<endl;
 388
 389 #ifdef use_newio
 390   fReader->Reset();
 391   fReader->Select(0,ddls[0],ddls[ddlsToSearch-1]);
 392   fTPCStream->Reset();
 393 #else
 394   fTPCStream->SetDDLID(ddls[i]); //ddl to read out
 395 #endif
 396
 397   nrow = (UInt_t)nrows;
 398
 399   return data;
 400 }
 401 #endif
 402
 403 Bool_t AliHLTTPCDDLDataFileHandler::DDLData2CompBinary(Int_t event)
 404 {
 405   // transfers the DDL data to the memory and converts it
 406   // to comp binary
 407   Bool_t out = kTRUE;
 408   UInt_t ndigits=0;
 409   AliHLTTPCDigitRowData *digits=0;
 410   digits = DDLData2Memory(ndigits,event);
 411   out = Memory2CompBinary(ndigits,digits);
 412   Free();
 413   return out;
 414 }