HLT/misc/AliL3DDLDataFileHandler.cxx

   1 // @(#) $Id$
   2
   3 // Author: C. Loizides <loizides@ikf.uni-frankfurt.de>
   4 //*-- Copyright &copy ALICE HLT Group
   5
   6 #include "AliL3StandardIncludes.h"
   7
   8 #include "AliL3RootTypes.h"
   9 #include "AliL3Logging.h"
  10 #include "AliL3Transform.h"
  11 #include "AliL3MemHandler.h"
  12 #include "AliL3DigitData.h"
  13 #ifdef use_newio
  14 #include "../RAW/AliRawReaderRoot.h"
  15 #include "../RAW/AliRawReaderDate.h"
  16 #else
  17 #include "AliL3DDLTPCRawStream.h"
  18 #include "AliL3DDLRawReaderFile.h"
  19 #endif
  20 #include "AliL3DDLDataFileHandler.h"
  21
  22 #if __GNUC__ == 3
  23 using namespace std;
  24 #endif
  25
  26 /** \class AliL3DDLDataFileHandler
  27 <pre>
  28 //_____________________________________________________________
  29 // AliL3DDLDataFileHandler
  30 //
  31 //  This class does converts from the DDL format of offline
  32 //  into the memory I/O handling of the HLT binary files.
  33 //
  34 //  Examples: see ddl2binary in exa and the general
  35 //            AliL3MemHandler class description
  36 //
  37 </pre>
  38 */
  39
  40 ClassImp(AliL3DDLDataFileHandler)
  41
  42 AliL3DDLDataFileHandler::AliL3DDLDataFileHandler()
  43 {
  44   fReader=0;
  45   fTPCStream=0;
  46 }
  47
  48 AliL3DDLDataFileHandler::~AliL3DDLDataFileHandler()
  49 {
  50   FreeAll();
  51 }
  52
  53 void AliL3DDLDataFileHandler::FreeAll()
  54 {
  55   if(fReader) delete fReader;
  56   if(fTPCStream) delete fTPCStream;
  57   fReader = 0;
  58   fTPCStream = 0;
  59 }
  60
  61
  62 #ifdef use_newio
  63 Bool_t AliL3DDLDataFileHandler::SetReaderInput(Char_t *name,Int_t event)
  64 {
  65   fEvent=event;
  66   if(fReader) delete fReader;
  67   if(fTPCStream) delete fTPCStream;
  68   if(event>=0){
  69     fFilename=name;
  70     fReader=new AliRawReaderRoot(name,event);
  71   } else {
  72     fFilename="";
  73     fReader=new AliRawReaderDate(name);
  74   }
  75   fTPCStream=new AliTPCRawStream(fReader);
  76
  77   return kTRUE;
  78 }
  79 #else
  80 Bool_t AliL3DDLDataFileHandler::SetReaderInput(Char_t *name, Bool_t add)
  81 {
  82   if(fReader){
  83     LOG(AliL3Log::kError,"AliL3DDLDataFileHandler::SetReaderInput","File Open")
  84       <<"Reader ptr is already in use"<<ENDLOG;
  85     return kFALSE;
  86   }
  87
  88   fReader=new AliL3DDLRawReaderFile(name,add);
  89   fTPCStream=new AliL3DDLTPCRawStream(fReader);
  90
  91   return kTRUE;
  92 }
  93 Bool_t AliL3DDLDataFileHandler::SetReaderInput(AliL3DDLRawReaderFile *rf)
  94 {
  95   if(fReader){
  96     LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetReaderInput","File Open")
  97       <<"Reader ptr is already in use, delete it first"<<ENDLOG;
  98     return kFALSE;
  99   }
 100
 101   //Open the raw data file with given file.
 102   fReader = rf;
 103   fTPCStream=new AliL3DDLTPCRawStream(fReader);
 104
 105   return kTRUE;
 106 }
 107 #endif
 108
 109 void AliL3DDLDataFileHandler::CloseReaderInput()
 110 {
 111   if(!fReader){
 112     LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::CloseReaderInput","File Close")
 113       <<"Nothing to Close"<<ENDLOG;
 114     return;
 115   }
 116
 117   delete fReader;
 118   delete fTPCStream;
 119   fReader = 0;
 120   fTPCStream = 0;
 121 }
 122
 123 #ifdef use_newio
 124 Bool_t AliL3DDLDataFileHandler::IsDigit(Int_t i)
 125 {
 126   return kTRUE;
 127 }
 128 #endif
 129
 130 AliL3DigitRowData * AliL3DDLDataFileHandler::DDLData2Memory(UInt_t &nrow,Int_t event)
 131 {
 132 #ifdef use_newio
 133   if((fEvent>=0)&&(event!=fEvent)){
 134     fEvent=event;
 135     if(fReader) delete fReader;
 136     if(fTPCStream) delete fTPCStream;
 137     fReader=new AliRawReaderRoot(fFilename,event);
 138     fTPCStream=new AliTPCRawStream(fReader);
 139   }
 140 #endif
 141   AliL3DigitRowData *data = 0;
 142   nrow=0;
 143
 144   if(!fReader){
 145     LOG(AliL3Log::kWarning,"AliL3DDLDataFileHandler::DDLData2Memory","File")
 146     <<"No Input avalible: no object AliL3DDLRawReaderFile"<<ENDLOG;
 147     return 0;
 148   }
 149
 150   Int_t nrows=fRowMax-fRowMin+1;
 151   Int_t ndigitcount=0;
 152   //  Int_t ndigits[nrows];
 153   Int_t * ndigits = new Int_t[nrows];
 154   UShort_t ***charges=new UShort_t**[nrows];
 155   for(Int_t r=fRowMin;r<=fRowMax;r++){
 156     Int_t lrow=r-fRowMin;
 157     charges[lrow]=new UShort_t*[AliL3Transform::GetNPads(r)];
 158     for(Int_t k=0;k<AliL3Transform::GetNPads(r);k++){
 159       charges[lrow][k]=new UShort_t[AliL3Transform::GetNTimeBins()];
 160       for(Int_t j=0;j<AliL3Transform::GetNTimeBins();j++) charges[lrow][k][j]=0;
 161     }
 162   }
 163
 164   Int_t ddls_to_search=0;
 165   Int_t ddls[9]={-1,-1,-1,-1,-1,-1,-1,-1,-1};
 166   Int_t ddlid=-1,lddlid=-1;
 167   for(Int_t r=fRowMin;r<=fRowMax;r++){
 168     ndigits[r-fRowMin] = 0; //now digits on row
 169
 170     Int_t patch=AliL3Transform::GetPatch(r);
 171     Int_t sector,row;
 172     AliL3Transform::Slice2Sector(fSlice,r,sector,row);
 173
 174     if(sector<36) //taken from AliTPCBuffer160.cxx
 175       ddlid=sector*2+patch;
 176     else
 177       ddlid=70+(sector-36)*4+patch;
 178
 179     if((lddlid!=ddlid-1)&&(r==30)){ //dont forget the split row on the last ddl
 180       ddls[ddls_to_search++]=ddlid-1;
 181       lddlid=ddlid-1;
 182     }
 183     if((lddlid==-1)||(ddlid!=lddlid)){
 184       ddls[ddls_to_search++]=ddlid;
 185       lddlid=ddlid;
 186     }
 187     if((r==90)||(r==139)){ //dont forget the split row on the next ddl
 188       ddls[ddls_to_search++]=ddlid+1;
 189       lddlid=ddlid+1;
 190     }
 191   }
 192   //for(Int_t i=0;i<ddls_to_search;i++) cout << ddls[i] <<endl;
 193
 194   for(Int_t i=0;i<ddls_to_search;i++){
 195 #ifdef use_newio
 196     fReader->Reset();
 197     fReader->Select(0,ddls[i],ddls[i]+1);
 198 #else
 199     fTPCStream->SetDDLID(ddls[i]); //ddl to read out
 200 #endif
 201
 202     while (fTPCStream->Next()){
 203
 204       UShort_t dig=fTPCStream->GetSignal();
 205       if(dig <= AliL3Transform::GetZeroSup()) continue;
 206       if(dig >= AliL3Transform::GetADCSat())
 207         dig = AliL3Transform::GetADCSat();
 208
 209       Int_t time=fTPCStream->GetTime();
 210       Int_t pad=fTPCStream->GetPad();
 211       Int_t sector=fTPCStream->GetSector();
 212       Int_t row=fTPCStream->GetRow();
 213       Int_t slice,srow;
 214
 215       //test row criteria (patch boundaries)
 216       AliL3Transform::Sector2Slice(slice,srow,sector,row);
 217       if((srow<fRowMin)||(srow>fRowMax))continue;
 218       if(slice!=fSlice){
 219         LOG(AliL3Log::kError,"AliL3DDLDataFileHandler::DDLDigits2Memory","Slice")
 220           <<AliL3Log::kDec<<"Found slice "<<slice<<", expected "<<fSlice<<ENDLOG;
 221         continue;
 222       }
 223
 224       //cut out the inner cone
 225       Float_t xyz[3];
 226       AliL3Transform::Raw2Local(xyz,sector,row,pad,time);
 227       if(AliL3Transform::Row2X(srow)<230./250.*fabs(xyz[2]))
 228         continue; // why 230???
 229
 230       Int_t lrow=srow-fRowMin;
 231       if((lrow<0)||lrow>=nrows){
 232         LOG(AliL3Log::kError,"AliL3DDLDataFileHandler::DDLDigits2Memory","Row")
 233           <<AliL3Log::kDec<<"Row value out of bounds "<<lrow<<" "<<nrows<<ENDLOG;
 234         continue;
 235       }
 236       if((pad<0)||(pad>=AliL3Transform::GetNPads(srow))){
 237         LOG(AliL3Log::kError,"AliL3DDLDataFileHandler::DDLDigits2Memory","Pad")
 238           <<AliL3Log::kDec<<"Pad value out of bounds "<<pad<<" "
 239           <<AliL3Transform::GetNPads(srow)<<ENDLOG;
 240         continue;
 241       }
 242       if((time<0)||(time>=AliL3Transform::GetNTimeBins())){
 243         LOG(AliL3Log::kError,"AliL3DDLDataFileHandler::DDLDigits2Memory","Time")
 244           <<AliL3Log::kDec<<"Time out of bounds "<<time<<" "
 245           <<AliL3Transform::GetNTimeBins()<<ENDLOG;
 246         continue;
 247       }
 248
 249       //store digit
 250       ndigits[lrow]++; //for this row only
 251       ndigitcount++;   //total number of digits to be published
 252
 253       charges[lrow][pad][time]=dig;
 254     }
 255   }
 256
 257   Int_t size = sizeof(AliL3DigitData)*ndigitcount
 258     + nrows*sizeof(AliL3DigitRowData);
 259
 260   LOG(AliL3Log::kDebug,"AliL3DDLDataFileHandler::DDLDigits2Memory","Digits")
 261     <<AliL3Log::kDec<<"Found "<<ndigitcount<<" Digits"<<ENDLOG;
 262
 263   data=(AliL3DigitRowData*) Allocate(size);
 264   nrow = (UInt_t)nrows;
 265   AliL3DigitRowData *tempPt = data;
 266
 267   for(Int_t r=fRowMin;r<=fRowMax;r++){
 268     Int_t lrow=r-fRowMin;
 269     tempPt->fRow = r;
 270     tempPt->fNDigit = ndigits[lrow];
 271
 272     Int_t localcount=0;
 273     for(Int_t pad=0;pad<AliL3Transform::GetNPads(r);pad++){
 274       for(Int_t time=0;time<AliL3Transform::GetNTimeBins();time++){
 275         UShort_t dig=charges[lrow][pad][time];
 276         if(!dig) continue;
 277
 278         if(localcount >= ndigits[lrow])
 279           LOG(AliL3Log::kFatal,"AliL3DDLDataFileHandler::DDLDigits2Binary","Memory")
 280             <<AliL3Log::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
 281             <<ndigits[lrow]<<ENDLOG;
 282
 283
 284         tempPt->fDigitData[localcount].fCharge=dig;
 285         tempPt->fDigitData[localcount].fPad=pad;
 286         tempPt->fDigitData[localcount].fTime=time;
 287 #ifdef do_mc
 288         tempPt->fDigitData[localcount].fTrackID[0] = 0;
 289         tempPt->fDigitData[localcount].fTrackID[1] = 0;
 290         tempPt->fDigitData[localcount].fTrackID[2] = 0;
 291 #endif
 292         localcount++;
 293       }
 294     }
 295
 296     if(localcount != ndigits[lrow])
 297       LOG(AliL3Log::kFatal,"AliL3DDLDataFileHandler::DDLDigits2Binary","Memory")
 298         <<AliL3Log::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
 299         <<ndigits[lrow]<<ENDLOG;
 300
 301
 302     Byte_t *tmp = (Byte_t*)tempPt;
 303     Int_t size = sizeof(AliL3DigitRowData)
 304                                       + ndigits[lrow]*sizeof(AliL3DigitData);
 305     tmp += size;
 306     tempPt = (AliL3DigitRowData*)tmp;
 307   }
 308
 309   //delete charge array
 310   for(Int_t r=fRowMin;r<=fRowMax;r++){
 311     Int_t lrow=r-fRowMin;
 312     for(Int_t k=0;k<AliL3Transform::GetNPads(r);k++)
 313         delete charges[lrow][k];
 314     delete charges[lrow];
 315   }
 316   delete charges;
 317   delete [] ndigits;
 318
 319   return data;
 320 }
 321
 322
 323 Bool_t AliL3DDLDataFileHandler::DDLData2CompBinary(Int_t event)
 324 {
 325   Bool_t out = kTRUE;
 326   UInt_t ndigits=0;
 327   AliL3DigitRowData *digits=0;
 328   digits = DDLData2Memory(ndigits,event);
 329   out = Memory2CompBinary(ndigits,digits);
 330   Free();
 331   return out;
 332 }