HLT/TPCLib/AliHLTTPCDigitDumpComponent.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  *                  for The ALICE HLT Project.                            *
   9  *                                                                        *
  10  * Permission to use, copy, modify and distribute this software and its   *
  11  * documentation strictly for non-commercial purposes is hereby granted   *
  12  * without fee, provided that the above copyright notice appears in all   *
  13  * copies and that both the copyright notice and this permission notice   *
  14  * appear in the supporting documentation. The authors make no claims     *
  15  * about the suitability of this software for any purpose. It is          *
  16  * provided "as is" without express or implied warranty.                  *
  17  **************************************************************************/
  18
  19 /** @file   AliHLTTPCDigitDumpComponent.cxx
  20     @author Matthias Richter
  21     @date
  22     @brief  Special file writer converting TPC digit input to ASCII. */
  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 #include <cassert>
  31 #include "AliHLTTPCDigitDumpComponent.h"
  32 #include "AliHLTTPCTransform.h"
  33 #include "AliHLTTPCDigitReader.h"
  34 #include "AliHLTTPCDigitReaderUnpacked.h"
  35 #include "AliHLTTPCDigitReader32Bit.h"
  36 #include "AliHLTTPCDefinitions.h"
  37
  38 /** ROOT macro for the implementation of ROOT specific class methods */
  39 ClassImp(AliHLTTPCDigitDumpComponent)
  40
  41 AliHLTTPCDigitDumpComponent::AliHLTTPCDigitDumpComponent()
  42   :
  43   AliHLTFileWriter(),
  44   fDigitReaderType(kDigitReader32Bit),
  45   fRcuTrailerSize(2),
  46   fUnsorted(true),
  47   fbBulkMode(true),
  48   fpReader(NULL),
  49   f32BitFormat(kFALSE)
  50 {
  51   // see header file for class documentation
  52   // or
  53   // refer to README to build package
  54   // or
  55   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  56 }
  57
  58 AliHLTTPCDigitDumpComponent::~AliHLTTPCDigitDumpComponent()
  59 {
  60   // see header file for class documentation
  61 }
  62
  63 const char* AliHLTTPCDigitDumpComponent::GetComponentID()
  64 {
  65   // see header file for class documentation
  66   return "TPCDigitDump";
  67 }
  68
  69 void AliHLTTPCDigitDumpComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  70 {
  71   // see header file for class documentation
  72   list.clear();
  73   list.push_back(kAliHLTAnyDataType);
  74 }
  75
  76 AliHLTComponent* AliHLTTPCDigitDumpComponent::Spawn()
  77 {
  78   // see header file for class documentation
  79   return new AliHLTTPCDigitDumpComponent;
  80 }
  81
  82 int AliHLTTPCDigitDumpComponent::InitWriter()
  83 {
  84   // see header file for class documentation
  85   int iResult=0;
  86   switch (fDigitReaderType) {
  87   case kDigitReaderUnpacked:
  88     HLTInfo("create DigitReaderUnpacked");
  89     fpReader=new AliHLTTPCDigitReaderUnpacked;
  90     break;
  91   case kDigitReader32Bit:
  92     HLTInfo("create DigitReader32Bit");
  93     fpReader=new AliHLTTPCDigitReader32Bit();
  94     f32BitFormat = kTRUE;
  95     break;
  96   }
  97   if (!fpReader) {
  98     HLTError("can not create digit reader of type %d", fDigitReaderType);
  99     iResult=-EFAULT;
 100   } else {
 101     fpReader->SetUnsorted(fUnsorted);
 102   }
 103   return iResult;
 104 }
 105
 106 int AliHLTTPCDigitDumpComponent::ScanArgument(int argc, const char** argv)
 107 {
 108   // see header file for class documentation
 109   int iResult=0;
 110   TString argument="";
 111   bool bMissingParam=0;
 112   int i=0;
 113   do {
 114     if (i>=argc || (argument=argv[i]).IsNull()) continue;
 115
 116     // -rawreadermode
 117     if (argument.CompareTo("-rawreadermode")==0) {
 118       if ((bMissingParam=(++i>=argc))) break;
 119       HLTWarning("argument '-rawreadermode' deprecated");
 120       break;
 121     }
 122
 123     // -digitreader
 124     if (argument.CompareTo("-digitreader")==0) {
 125       if ((bMissingParam=(++i>=argc))) break;
 126       TString param=argv[i];
 127       if (param.CompareTo("unpacked", TString::kIgnoreCase)==0) {
 128         fDigitReaderType=kDigitReaderUnpacked;
 129       } else if (param.CompareTo("packed", TString::kIgnoreCase)==0) {
 130         HLTWarning("argument 'packed' is deprecated, falling back to DigitReader32Bit");
 131         fDigitReaderType=kDigitReader32Bit;
 132       } else if (param.CompareTo("raw", TString::kIgnoreCase)==0) {
 133         HLTWarning("argument 'raw' is deprecated, falling back to DigitReader32Bit");
 134         fDigitReaderType=kDigitReader32Bit;
 135       } else if (param.CompareTo("decoder", TString::kIgnoreCase)==0) {
 136         HLTWarning("argument 'decoder' is deprecated, falling back to DigitReader32Bit");
 137         fDigitReaderType=kDigitReader32Bit;
 138       } else if (param.CompareTo("32bit", TString::kIgnoreCase)==0) {
 139         fDigitReaderType=kDigitReader32Bit;
 140       } else {
 141         HLTError("unknown digit reader type %s", param.Data());
 142         iResult=-EINVAL;
 143       }
 144
 145       break;
 146     }
 147
 148     // -rcutrailersize
 149     if (argument.CompareTo("-rcutrailersize")==0) {
 150       if ((bMissingParam=(++i>=argc))) break;
 151       char *endptr=NULL;
 152       fRcuTrailerSize=strtoul(argv[i], &endptr, 0);
 153       if (/*endptr ||*/ fRcuTrailerSize<1) {
 154         HLTError("invalid parameter '%s', %s", argv[i], endptr==NULL?"number >= 1 expected":"can not convert string to number");
 155         iResult=-EINVAL;
 156       }
 157       break;
 158     }
 159
 160     // -unsorted
 161     if (argument.CompareTo("-unsorted")==0) {
 162       fUnsorted=true;
 163       break;
 164     }
 165
 166     // -sorted
 167     if (argument.CompareTo("-sorted")==0) {
 168       fUnsorted=false;
 169       break;
 170     }
 171
 172     // -bulk
 173     if (argument.CompareTo("-bulk")==0) {
 174       fbBulkMode=true;
 175       break;
 176     }
 177
 178     // -stream
 179     if (argument.CompareTo("-stream")==0) {
 180       fbBulkMode=false;
 181       break;
 182     }
 183   } while (0); // just use the do/while here to have the option of breaking
 184
 185   if (bMissingParam) iResult=-EPROTO;
 186   else if (iResult>=0) iResult=i;
 187
 188   return iResult;
 189 }
 190
 191 int AliHLTTPCDigitDumpComponent::CloseWriter()
 192 {
 193   // see header file for class documentation
 194   if (fpReader) delete fpReader;
 195   fpReader=NULL;
 196   return 0;
 197 }
 198
 199 int AliHLTTPCDigitDumpComponent::DumpEvent( const AliHLTComponentEventData& evtData,
 200                                             const AliHLTComponentBlockData* /*blocks*/,
 201                                             AliHLTComponentTriggerData& /*trigData*/ )
 202 {
 203   // see header file for class documentation
 204   int iResult=0;
 205   int iPrintedSlice=-1;
 206   int iPrintedPart=-1;
 207   int blockno=0;
 208   const AliHLTComponentBlockData* pDesc=NULL;
 209
 210   AliHLTTPCDigitReader* pReader=fpReader;
 211   if (!pReader) return -ENODEV;
 212
 213   for (pDesc=GetFirstInputBlock(kAliHLTAnyDataType); pDesc!=NULL; pDesc=GetNextInputBlock(), blockno++) {
 214     HLTDebug("event %Lu block %d: %s 0x%08x size %d", evtData.fEventID, blockno, DataType2Text(pDesc->fDataType).c_str(), pDesc->fSpecification, pDesc->fSize);
 215
 216     if (fDigitReaderType==kDigitReaderUnpacked && pDesc->fDataType!=AliHLTTPCDefinitions::fgkUnpackedRawDataType) continue;
 217     else if (fDigitReaderType!=kDigitReaderUnpacked && pDesc->fDataType!=(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC)) continue;
 218
 219     TString filename;
 220     iResult=BuildFileName(evtData.fEventID, blockno, pDesc->fDataType, pDesc->fSpecification, filename);
 221     ios::openmode filemode=(ios::openmode)0;
 222     if (fCurrentFileName.CompareTo(filename)==0) {
 223       // append to the file
 224       filemode=ios::app;
 225     } else {
 226       // store the file for the next block
 227       fCurrentFileName=filename;
 228     }
 229     if (iResult>=0) {
 230       ofstream dump(filename.Data(), filemode);
 231       if (dump.good()) {
 232         int part=AliHLTTPCDefinitions::GetMinPatchNr(*pDesc);
 233         assert(part==AliHLTTPCDefinitions::GetMaxPatchNr(*pDesc));
 234         int slice=AliHLTTPCDefinitions::GetMinSliceNr(*pDesc);
 235         assert(slice==AliHLTTPCDefinitions::GetMaxSliceNr(*pDesc));
 236         int firstRow=AliHLTTPCTransform::GetFirstRow(part);
 237         int lastRow=AliHLTTPCTransform::GetLastRow(part);
 238
 239         iResult=pReader->InitBlock(pDesc->fPtr,pDesc->fSize,firstRow,lastRow,part,slice);
 240
 241         int iPrintedRow=-1;
 242         int iPrintedPad=-1;
 243         int iLastTime=-1;
 244         if (fbBulkMode) {
 245           while (pReader->NextChannel()) {
 246             if (PrintHeaders(slice, iPrintedSlice, part, iPrintedPart, pReader, iPrintedRow, iPrintedPad, dump)) {
 247               iLastTime=-1;
 248             }
 249             while (pReader->NextBunch()) {
 250               int bunchLength=pReader->GetBunchSize();
 251
 252               // Kenneth: 20-04-09. The following if have been added because of inconsistency in the 40 bit decoder and the 32 bit decoder.
 253               // GetSignals() in the 40 bit decoder returns an array of UInt_t while the 32 bit one returns UShort_t
 254               if(f32BitFormat == kTRUE){
 255                 const  UShort_t* bunchData=pReader->GetSignalsShort();
 256
 257                 // bunch data is printed in 'reverse' order in order to produce
 258                 // the same output as in stream reading mode
 259                 dump << "                     Time " << pReader->GetTime()+bunchLength-1 << ":  ";
 260                 for (int bin=bunchLength-1; bin>=0; bin--) {
 261                   dump << "  " << bunchData[bin];
 262                 }
 263                 dump << "    -> Time: " << pReader->GetTime() << endl;
 264               }
 265               else{
 266                 const  UInt_t* bunchData=pReader->GetSignals();
 267                 dump << "                     Time " << pReader->GetTime()+bunchLength-1 << ":  ";
 268                 for (int bin=0; bin<bunchLength; bin++) {
 269                   dump << "  " << bunchData[bin];
 270                 }
 271                 dump << "    -> Time: " << pReader->GetTime() << endl;
 272               }
 273             }
 274           }
 275           dump << endl;
 276         } else {
 277         while (pReader->Next()) {
 278           if ((iPrintedSlice!=-1 && iLastTime!=-1 && iLastTime!=pReader->GetTime()+1 && iLastTime!=pReader->GetTime()-1)) {
 279             dump << "    -> Time: " << iLastTime << endl;
 280           } else if ((iPrintedPad!=-1 && iPrintedPad!=pReader->GetPad()) ||
 281                      (iPrintedRow!=-1 && iPrintedRow!=pReader->GetRow())) {
 282             dump << "    -> Time: " << iLastTime << endl;
 283             //dump << endl;
 284           }
 285
 286           if (PrintHeaders(slice, iPrintedSlice, part, iPrintedPart, pReader, iPrintedRow, iPrintedPad, dump)) {
 287             iLastTime=-1;
 288           }
 289           if (iLastTime==-1 || (iLastTime!=pReader->GetTime()+1 && iLastTime!=pReader->GetTime()-1)) {
 290             dump << "                     Time " << pReader->GetTime() << ":  ";
 291           }
 292           iLastTime=pReader->GetTime();
 293           dump << "  " << pReader->GetSignal();
 294         }
 295         if (iLastTime>=0) dump << "    -> Time: " << iLastTime << endl << endl;
 296         }
 297       } else {
 298         HLTError("can not open file %s for writing", filename.Data());
 299         iResult=-EBADF;
 300       }
 301       dump.close();
 302     }
 303     pReader->Reset();
 304   }
 305   return iResult;
 306 }
 307
 308 int AliHLTTPCDigitDumpComponent::PrintHeaders(int slice, int &iPrintedSlice,
 309                                               int part, int &iPrintedPart,
 310                                               AliHLTTPCDigitReader* pReader,
 311                                               int &iPrintedRow, int &iPrintedPad,
 312                                               ofstream &dump) const
 313 {
 314   // see header file for class documentation
 315   int iResult=0;
 316   assert(pReader);
 317   if (iPrintedSlice!=slice || iPrintedPart!=part) {
 318     iPrintedSlice=slice;
 319     iPrintedPart=part;
 320     dump << "====================================================================" << endl;
 321     dump << "    Slice: " << iPrintedSlice << "   Partition: " << iPrintedPart << endl;
 322     iPrintedRow=-1;
 323   }
 324   if (iPrintedRow!=pReader->GetRow()) {
 325     iPrintedRow=pReader->GetRow();
 326     dump << "--------------------------------------------------------------------" << endl;
 327     dump << "Row: " << iPrintedRow << endl;
 328     iPrintedPad=-1;
 329   }
 330   if (iPrintedPad!=pReader->GetPad()) {
 331     iPrintedPad=pReader->GetPad();
 332     dump << "Row: " << iPrintedRow << "  Pad: " << iPrintedPad << "  HW address: " << pReader->GetAltroBlockHWaddr() << endl;
 333     iResult=1;
 334   }
 335
 336   return iResult;
 337 }