HLT/BASE/util/AliHLTRawReaderPublisherComponent.cxx

   1 // $Id$
   2
   3 ///**************************************************************************
   4 ///* This file is property of and copyright by the                          *
   5 ///* ALICE Experiment at CERN, All rights reserved.                         *
   6 ///*                                                                        *
   7 ///* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
   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   AliHLTRawReaderPublisherComponent.cxx
  19 /// @author Matthias Richter
  20 /// @date
  21 /// @brief  Publisher component for raw data blocks through the AliRawReader
  22 ///         of the offline environment
  23
  24 #include "AliHLTRawReaderPublisherComponent.h"
  25 #include "AliRawReader.h"
  26 #include "AliDAQ.h"
  27 #include "AliLog.h"
  28 #include "AliHLTCDHWrapper.h"
  29 #include <cerrno>
  30 #include <cassert>
  31 #include <list>
  32
  33 /** ROOT macro for the implementation of ROOT specific class methods */
  34 ClassImp(AliHLTRawReaderPublisherComponent)
  35
  36 AliHLTRawReaderPublisherComponent::AliHLTRawReaderPublisherComponent()
  37   :
  38   fMaxSize(5000000),
  39   fDetector(),
  40   fMinEquId(-1),
  41   fMaxEquId(-1),
  42   fVerbosity(0),
  43   fDataType(kAliHLTVoidDataType),
  44   fSpecification(kAliHLTVoidDataSpec),
  45   fSkipEmpty(kFALSE)
  46 {
  47   // constructor
  48 }
  49
  50 AliHLTRawReaderPublisherComponent::~AliHLTRawReaderPublisherComponent()
  51 {
  52   // destructor
  53 }
  54
  55 const char* AliHLTRawReaderPublisherComponent::GetComponentID()
  56 {
  57   /// inherited from AliHLTComponent: id of the component
  58   return "AliRawReaderPublisher";
  59 }
  60
  61 AliHLTComponentDataType AliHLTRawReaderPublisherComponent::GetOutputDataType()
  62 {
  63   /// inherited from AliHLTComponent: output data type of the component.
  64   return fDataType;
  65 }
  66
  67 void AliHLTRawReaderPublisherComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  68 {
  69   /// inherited from AliHLTComponent: output data size estimator
  70   constBase=fMaxSize;
  71   inputMultiplier=1;
  72 }
  73
  74 AliHLTComponent* AliHLTRawReaderPublisherComponent::Spawn()
  75 {
  76   /// inherited from AliHLTComponent: spawn function.
  77   return new AliHLTRawReaderPublisherComponent;
  78 }
  79
  80 int AliHLTRawReaderPublisherComponent::DoInit( int argc, const char** argv )
  81 {
  82   /// inherited from AliHLTComponent: component initialisation and argument scan.
  83   int iResult=0;
  84
  85   // scan arguments
  86   if (argc && (iResult = ConfigureFromArgumentString(argc, argv)) < 0)
  87     return iResult;
  88
  89   if (!fDetector.IsNull()) {
  90     int ddloffset=-1;
  91     int ddlcount=-1;
  92     if ((ddloffset=AliDAQ::DdlIDOffset(fDetector))<0 ||
  93         (ddlcount=AliDAQ::NumberOfDdls(fDetector))<0) {
  94       return -EINVAL;
  95     }
  96     if (fMinEquId<0) fMinEquId=ddloffset;
  97     else fMinEquId+=ddloffset;
  98
  99     if (fMaxEquId<0 || fMaxEquId>ddlcount) fMaxEquId=ddloffset+ddlcount-1;
 100     else fMaxEquId+=ddloffset;
 101   }
 102
 103   if (fMinEquId>fMaxEquId) fMaxEquId=fMinEquId;
 104
 105   if (fMinEquId<0) {
 106     AliErrorStream() << "equipment id required, use \'-equipmentid\' or \'-detector\' option" << endl;
 107     return -EINVAL;
 108   }
 109
 110   AliHLTUInt32_t dummy;
 111   if (fMinEquId!=fMaxEquId && GetSpecificationFromEquipmentId(0, dummy)==-ENOSYS) {
 112     AliWarningStream() << "publication of multiple equipment ids needs implementation of a child and function GetSpecificationFromEquipmentId to set correct specifications" << endl;
 113     //return -EINVAL;
 114   }
 115
 116   if (GetRawReader()!=NULL) {
 117   } else {
 118     AliErrorStream() << "RawReader instance needed" << endl;
 119     return -EINVAL;
 120   }
 121
 122   return iResult;
 123 }
 124
 125 int AliHLTRawReaderPublisherComponent::DoDeinit()
 126 {
 127   /// inherited from AliHLTComponent: component cleanup
 128   int iResult=0;
 129   return iResult;
 130 }
 131
 132 int AliHLTRawReaderPublisherComponent::ScanConfigurationArgument(int argc, const char** argv)
 133 {
 134   /// inherited from AliHLTComponent: argument scan
 135   if (argc<1) return 0;
 136   int bMissingParam=0;
 137   int i=0;
 138   TString argument=argv[i];
 139
 140   do {
 141     // -detector
 142     if (argument.CompareTo("-detector")==0) {
 143       if ((bMissingParam=(++i>=argc))) break;
 144       fDetector=argv[i];
 145       return 2;
 146
 147       // -equipmentid, -minid
 148     } else if (argument.CompareTo("-equipmentid")==0 ||
 149                argument.CompareTo("-minid")==0) {
 150       if ((bMissingParam=(++i>=argc))) break;
 151       TString parameter(argv[i]);
 152       parameter.Remove(TString::kLeading, ' '); // remove all blanks
 153       if (parameter.IsDigit()) {
 154         fMinEquId=(AliHLTUInt32_t)parameter.Atoi();
 155         return 2;
 156       } else {
 157         HLTError("wrong parameter for argument %s, number expected", argument.Data());
 158         return -EINVAL;
 159       }
 160
 161       // -maxid
 162     } else if (argument.CompareTo("-maxid")==0) {
 163       if ((bMissingParam=(++i>=argc))) break;
 164       TString parameter(argv[i]);
 165       parameter.Remove(TString::kLeading, ' '); // remove all blanks
 166       if (parameter.IsDigit()) {
 167         fMaxEquId=(AliHLTUInt32_t)parameter.Atoi();
 168         return 2;
 169       } else {
 170         HLTError("wrong parameter for argument %s, number expected", argument.Data());
 171         return -EINVAL;
 172       }
 173
 174       // -verbose
 175     } else if (argument.CompareTo("-verbose")==0) {
 176       fVerbosity++;
 177       return 1;
 178
 179       // -silent
 180     } else if (argument.CompareTo("-silent")==0) {
 181       fVerbosity=0;
 182       return 1;
 183
 184       // -skipempty
 185     } else if (argument.CompareTo("-skipempty")==0) {
 186       fSkipEmpty=kTRUE;
 187       return 1;
 188
 189       // -datatype
 190     } else if (argument.CompareTo("-datatype")==0) {
 191       if ((bMissingParam=(++i>=argc))) break;
 192       memcpy(&fDataType.fID, argv[i], TMath::Min(kAliHLTComponentDataTypefIDsize, (Int_t)strlen(argv[i])));
 193       if ((bMissingParam=(++i>=argc))) break;
 194       memcpy(&fDataType.fOrigin, argv[i], TMath::Min(kAliHLTComponentDataTypefOriginSize, (Int_t)strlen(argv[i])));
 195       return 3;
 196
 197       // -dataspec
 198     } else if (argument.CompareTo("-dataspec")==0) {
 199       if ((bMissingParam=(++i>=argc))) break;
 200       TString parameter(argv[i]);
 201       parameter.Remove(TString::kLeading, ' '); // remove all blanks
 202       if (parameter.IsDigit()) {
 203         fSpecification=(AliHLTUInt32_t)parameter.Atoi();
 204       } else if (parameter.BeginsWith("0x") &&
 205                  parameter.Replace(0,2,"",0).IsHex()) {
 206         sscanf(parameter.Data(),"%x", &fSpecification);
 207       } else {
 208         HLTError("wrong parameter for argument %s, number expected", argument.Data());
 209         return -EINVAL;
 210       }
 211       return 2;
 212     }
 213   } while (0); // using do-while only to have break available
 214   if (bMissingParam) {
 215     HLTError("missing parameter for argument %s", argument.Data());
 216     return -EINVAL;
 217   }
 218
 219   return -EPROTO;
 220 }
 221
 222 int AliHLTRawReaderPublisherComponent::GetEvent(const AliHLTComponentEventData& /*evtData*/,
 223                                                 AliHLTComponentTriggerData& /*trigData*/,
 224                                                 AliHLTUInt8_t* outputPtr,
 225                                                 AliHLTUInt32_t& size,
 226                                                 vector<AliHLTComponentBlockData>& outputBlocks)
 227 {
 228   /// inherited from AliHLTDataSource: get the event
 229   int iResult=0;
 230   AliHLTUInt32_t capacity=size;
 231   size=0;
 232
 233   // process data events only
 234   if (!IsDataEvent()) return 0;
 235
 236   unsigned int offset=0;
 237   assert(outputPtr!=NULL || size==0);
 238   AliRawReader* pRawReader=GetRawReader();
 239   if (pRawReader) {
 240     pRawReader->Reset();
 241     pRawReader->SelectEquipment(-1, fMinEquId, fMaxEquId);
 242     if (fVerbosity>1) {
 243       AliInfo(Form("get event from RawReader %p equipment id range [%d,%d]", pRawReader, fMinEquId, fMaxEquId));
 244     } else {
 245       AliDebug(0, Form("get event from RawReader %p equipment id range [%d,%d]", pRawReader, fMinEquId, fMaxEquId));
 246     }
 247     list<int> processedIds;
 248     while (pRawReader->ReadHeader() && (iResult>=0 || iResult==-ENOSPC)) {
 249       const AliRawDataHeader* pHeaderV2=pRawReader->GetDataHeader();
 250       const AliRawDataHeaderV3* pHeaderV3=pRawReader->GetDataHeaderV3();
 251       AliHLTCDHWrapper pHeader;
 252       if(pHeaderV2) {
 253         pHeader=pHeaderV2;
 254       } else if (pHeaderV3) {
 255         pHeader=pHeaderV3;
 256       } else {
 257         HLTError("can not get data header from RawReader, skipping data block ...");
 258         continue;
 259       }
 260       unsigned int headerSize=pHeader.GetHeaderSize();
 261       unsigned int readSize=pRawReader->GetDataSize()+headerSize;
 262       int id=pRawReader->GetEquipmentId();
 263       if (fMinEquId>id || fMaxEquId<id) {
 264         AliError(Form("id %d returned from RawReader is outside range [%d,%d]", id, fMinEquId, fMaxEquId));
 265         continue;
 266       }
 267       processedIds.push_back(id);
 268       bool isSelected=IsSelected(id);
 269       if (fVerbosity>0) {
 270         AliInfo(Form("got header for id %d, size %d, %s", id, readSize, isSelected?"selected":"discarded"));
 271       } else {
 272         AliDebug(0, Form("got header for id %d, size %d", id, readSize));
 273       }
 274       if (!isSelected) continue;
 275       if (readSize+offset<=capacity) {
 276         memcpy(outputPtr+offset, pHeader.GetHeader(), headerSize);
 277         if (readSize>headerSize) {
 278           if (!pRawReader->ReadNext(outputPtr+offset+headerSize, readSize-headerSize)) {
 279             AliError(Form("error reading %d bytes from RawReader %p", readSize-headerSize, pRawReader));
 280             iResult=-ENODATA;
 281             break;
 282           }
 283         }
 284         AliHLTComponentBlockData bd;
 285         FillBlockData( bd );
 286         bd.fOffset = offset;
 287         bd.fSize = readSize;
 288         bd.fDataType = fDataType;
 289         if (fSpecification == kAliHLTVoidDataSpec) {
 290           GetSpecificationFromEquipmentId(id, bd.fSpecification);
 291         } else {
 292           bd.fSpecification=fSpecification;
 293         }
 294         outputBlocks.push_back( bd );
 295       } else {
 296         // we keep the loop going in order to collect the full size
 297         fMaxSize=offset+readSize;
 298         iResult=-ENOSPC;
 299       }
 300       offset+=readSize;
 301     }
 302     if (!fSkipEmpty && processedIds.size()!=size_t(fMaxEquId-fMinEquId+1)) {
 303       // add further empty data blocks
 304       AliHLTCDHWrapper header;
 305       if(pRawReader->GetVersion()==2){
 306         AliRawDataHeader headerV2;
 307         headerV2.fSize=sizeof(AliRawDataHeader);
 308         const UInt_t* triggermask=pRawReader->GetTriggerPattern();
 309         if (triggermask) {
 310           headerV2.fTriggerClassLow=triggermask[0];
 311           headerV2.fROILowTriggerClassHigh=triggermask[1];
 312         }
 313         header=&headerV2;
 314       } else if (pRawReader->GetVersion()==3){
 315         AliRawDataHeaderV3 headerV3;
 316         headerV3.fSize=sizeof(AliRawDataHeaderV3);
 317         const UInt_t* triggermask=pRawReader->GetTriggerPattern();
 318         if (triggermask) {
 319           headerV3.fTriggerClassLow=triggermask[0];
 320           headerV3.fTriggerClassesMiddleLow=triggermask[1] & 0x3FFFF;
 321           headerV3.fTriggerClassesMiddleHigh= (triggermask[1]>>18) | (triggermask[2]<<14);
 322           headerV3.fROILowTriggerClassHigh=(triggermask[2]>>18) | (triggermask[3]<<14);
 323         }
 324         header=&headerV3;
 325       }
 326       unsigned int headerSize=header.GetHeaderSize();
 327       processedIds.sort();
 328       list<int>::iterator curr=processedIds.begin();
 329       for (int id=fMinEquId; id<=fMaxEquId; id++) {
 330         if (curr!=processedIds.end() && *curr<=id) {
 331           curr++;
 332         } else {
 333           if (headerSize<=capacity-offset) {
 334             HLTInfo("add empty data block for equipment id %d", id);
 335             memcpy(outputPtr+offset, header.GetHeader(), headerSize);
 336             AliHLTComponentBlockData bd;
 337             FillBlockData( bd );
 338             bd.fOffset = offset;
 339             bd.fSize = headerSize;
 340             bd.fDataType = fDataType;
 341             if (fSpecification == kAliHLTVoidDataSpec) {
 342               GetSpecificationFromEquipmentId(id, bd.fSpecification);
 343             } else {
 344               bd.fSpecification=fSpecification;
 345             }
 346             outputBlocks.push_back( bd );
 347           } else {
 348             // we keep the loop going in order to collect the full size
 349             fMaxSize=offset+headerSize;
 350             iResult=-ENOSPC;
 351           }
 352           offset+=headerSize;
 353         }
 354       }
 355     }
 356     if (offset<=capacity) {
 357       size=offset;
 358     } else {
 359       outputBlocks.clear();
 360     }
 361   } else {
 362     AliErrorStream() << "RawReader uninitialized" << endl;
 363     iResult=-EFAULT;
 364   }
 365   return iResult;
 366 }
 367
 368 int AliHLTRawReaderPublisherComponent::GetSpecificationFromEquipmentId(int id, AliHLTUInt32_t& specification) const {
 369   /// get the data specification from the equipment id
 370   /// default method just returns the equipment id
 371   return specification=id;
 372 }