HLT/rec/AliRawReaderHLT.h

   1 //-*- Mode: C++ -*-
   2 // $Id$
   3
   4 #ifndef ALIRAWREADERHLT_H
   5 #define ALIRAWREADERHLT_H
   6 //* This file is property of and copyright by the ALICE HLT Project        *
   7 //* ALICE Experiment at CERN, All rights reserved.                         *
   8 //* See cxx source for full Copyright notice                               *
   9
  10 /** @file   AliRawReaderHLT.h
  11     @author Matthias Richter
  12     @date
  13     @brief  AliRawReader implementation which replaces original input of
  14             detectors with the appropriate HLT output.                    */
  15
  16 // see below for class documentation
  17 // or
  18 // refer to README to build package
  19 // or
  20 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  21
  22 #include "AliHLTDataTypes.h"
  23 #include "AliRawReader.h"      // RAW, base class
  24 #include "AliHLTReconstructorBase.h"
  25 #include "TString.h"
  26 #include <vector>
  27
  28 class AliHLTOUT;
  29 class AliHLTOUTHandler;
  30
  31 /**
  32  * @class AliRawReaderHLT
  33  * A specific AliRawReader for detector input replacement by HLTOUT data blocks.
  34  *
  35  * HLT components can produce output data in the detector ddl raw format.
  36  * Data blocks of this format can be fed into the normal detector reconstruction
  37  * without changes in the actual reconstruction code by means of the
  38  * AliRawReaderHLT implementation of the AliRawReader.
  39  *
  40  * @section sec_alirawreaderhlt_concept Conceptual design
  41  * The AliRawReader provides an abstract interface to the ddl raw data. All
  42  * reconstruction code uses this interface to access the data.
  43  * HLT components can send their data in the original ddl raw format. The only
  44  * difference of such data blocks is the location since they are shipped as
  45  * part of the HLTOUT data stream. The AliRawReaderHLT provides redirection of
  46  * those data blocks.
  47  *
  48  * @section sec_alirawreaderhlt_usage   Selection of the HLTOUT data stream
  49  * The input data of a detector can be replaced by the corresponding HLT
  50  * data by calling the <tt>AliReconstruction::SetUseHLTData("...")</tt>, e.g.
  51  * <pre>
  52  *    AliReconstruction rec;
  53  *    rec.SetUseHLTData("TPC TRD");
  54  * </pre>
  55  * will replace the input of TPC and TRD.
  56  *
  57  * @section sec_alirawreaderhlt_module  Module implementation
  58  * In order to determine the equipment id for the data block, the HLT module
  59  * must implement an HLTOUT handler of class AliHLTOUTHandlerEquId which is of
  60  * type @ref AliHLTModuleAgent::AliHLTOUTHandlerType ::kRawReader.
  61  * The handler must implement the method
  62  * <pre>
  63  *  // AliHLTOUTHandlerEquId::ProcessData(AliHLTOUT*)
  64  *  virtual int ProcessData(AliHLTOUT* pData);
  65  * </pre>
  66  * which returns the equipment id and eventually decodes data to be retrieved
  67  * by calling AliHLTOUTHandler::GetProcessedData().
  68  *
  69  * Secondly, the AliHLTModuleAgent implementation of the module has to create
  70  * the handler for the data blocks. Depending on the data type and specification,
  71  * the the following interface methods return handler description and handler.
  72  * <pre>
  73  *   int AliHLTModuleAgent::GetHandlerDescription(AliHLTComponentDataType dt,
  74  *                                                AliHLTUInt32_t spec,
  75  *                                                AliHLTOUTHandlerDesc& desc) const;
  76  *
  77  *   AliHLTOUTHandler* AliHLTModuleAgent::GetOutputHandler(AliHLTComponentDataType dt,
  78  *                                                         AliHLTUInt32_t spec);
  79  * </pre>
  80  *
  81  * @ingroup alihlt_aliroot_reconstruction
  82  */
  83 class AliRawReaderHLT : public AliRawReader, public AliHLTReconstructorBase {
  84  public:
  85   /** constructor */
  86   AliRawReaderHLT(AliRawReader* pParentReader, const char* options=NULL);
  87   /** destructor */
  88   virtual ~AliRawReaderHLT();
  89
  90   // interface methods of AliRawReader
  91   void     Select(Int_t detectorID,
  92                   Int_t minDDLID = -1, Int_t maxDDLID = -1);
  93 //   void     Select(const char *detectorName,
  94 //                Int_t minDDLID = -1, Int_t maxDDLID = -1);
  95
  96   using AliRawReader::Select;
  97
  98   void     SelectEquipment(Int_t equipmentType,
  99                            Int_t minEquipmentId = -1,
 100                            Int_t maxEquipmentId = -1);
 101   void     SkipInvalid(Bool_t skip = kTRUE);
 102   //  void     SelectEvents(Int_t type);
 103
 104   UInt_t   GetType() const;
 105   UInt_t   GetRunNumber() const;
 106   const UInt_t* GetEventId() const;
 107   const UInt_t* GetTriggerPattern() const;
 108   const UInt_t* GetDetectorPattern() const;
 109   const UInt_t* GetAttributes() const;
 110   const UInt_t* GetSubEventAttributes() const;
 111   UInt_t   GetLDCId() const;
 112   UInt_t   GetGDCId() const;
 113   UInt_t   GetTimestamp() const;
 114
 115   const UInt_t* GetEquipmentAttributes() const;
 116   Int_t    GetEquipmentElementSize() const;
 117   Int_t    GetEquipmentHeaderSize() const;
 118
 119   Int_t    GetEquipmentSize() const;
 120   Int_t    GetEquipmentType() const;
 121   Int_t    GetEquipmentId() const;
 122   Bool_t   ReadHeader();
 123   Bool_t   ReadNextData(UChar_t*& data);
 124   Bool_t   ReadNextInt(UInt_t& data);
 125   Bool_t   ReadNextShort(UShort_t& data);
 126   Bool_t   ReadNextChar(UChar_t& data);
 127   Bool_t   ReadNext(UChar_t* data, Int_t size);
 128
 129   Bool_t   Reset();
 130
 131   Bool_t   NextEvent();
 132   Bool_t   RewindEvents();
 133
 134  protected:
 135
 136  private:
 137   /** standard constructor prohibited */
 138   AliRawReaderHLT();
 139   /** copy constructor prohibited */
 140   AliRawReaderHLT(const AliRawReaderHLT&);
 141   /** assignment operator prohibited */
 142   AliRawReaderHLT& operator=(const AliRawReaderHLT&);
 143
 144   /**
 145    * Scan the options.
 146    * Set the ids for the specified detectors in the detector
 147    * list. Currently, no other options are available.
 148    */
 149   int ScanOptions(const char* options);
 150
 151   /**
 152    * Read the next data block from the HLT stream
 153    */
 154   Bool_t ReadNextHLTData();
 155
 156   /**
 157    * Check if a ddlid is part of the ones which are selected for
 158    * input replacement.
 159    */
 160   Bool_t IsHLTInput(int ddlid);
 161
 162   /**
 163    * Check if redirection is enabled for at least one detector in the
 164    * selected range.
 165    * Set the fbHaveHLTData variable
 166    * @return true if data has to be read from the HLT stream.
 167    */
 168   Bool_t EvaluateSelection();
 169
 170   /**
 171    * Release the current HLT data.
 172    * Releases the current buffer of either the active HLTOUT data
 173    * block handler or the HLTOUT instance. The latter implies a
 174    * reset of the reader concerning the HLT data blocks.
 175    * @param bReleaseHLTOUT   release HLTOUT instance if \em true
 176    *                         only current data buffer if \em false
 177    * @return neg. error code if failed
 178    */
 179   int ReleaseHLTData(bool bReleaseHLTOUT=true);
 180
 181   /**
 182    * Backbone of all Read functions.
 183    * Reads the next data into the internal buffer and switches to next
 184    * block if enabled.
 185    *
 186    * @param data             target to receive pointer
 187    * @param readHeader       kTRUE: switch to next block if no more data
 188    */
 189   Bool_t   ReadNextData(UChar_t*& data, Bool_t readHeader);
 190
 191   /** the rawreader */
 192   AliRawReader* fpParentReader; //!transient
 193
 194   /** options */
 195   TString fOptions; //!transient
 196
 197   /** system options = options w/o detector strings */
 198   TString fSystemOptions; //!transient
 199
 200   /** current data set, either extracted from the HLT stream or parent raw reader */
 201   const AliHLTUInt8_t* fpData; // !transient
 202
 203   /** size of the current data set */
 204   int fDataSize; // !transient
 205
 206   /** current stream offset in the data set */
 207   int fOffset; // !transient
 208
 209   /** current stream position for the ReadNextData function */
 210   int fPosition; // !transient
 211
 212   /** equipment id of the current data set, >0 indicates data set from HLT stream */
 213   int fEquipmentId; // !transient
 214
 215   /** indicates the availibility of data from the HLT stream */
 216   bool fbHaveHLTData; // !transient
 217
 218   /** list of detectors for which data will be taken from HLT stream */
 219   vector<int> fDetectors; // !transient
 220
 221   /** instance of the HLTOUT handler */
 222   AliHLTOUT* fpHLTOUT; // !transient
 223
 224   /** start reading HLTOUT from beginning */
 225   bool fbReadFirst; //!transient
 226
 227   /** instance of the data handler providing the current data buffer */
 228   AliHLTOUTHandler* fpDataHandler; // !transient
 229
 230   ClassDef(AliRawReaderHLT, 4)
 231 };
 232
 233 #define ALIHLTREC_LIBRARY                   "libHLTrec.so"
 234 #define ALIHLTREC_LIBRARY_VERSION           0
 235 #define ALIRAWREADERHLT_CREATE_INSTANCE     "AliRawReaderHLTCreateInstance"
 236
 237 #ifdef __cplusplus
 238 extern "C" {
 239 #endif
 240   typedef AliRawReader* (*AliRawReaderHLTCreateInstance_t)(AliRawReader* pParentReader, const char* options);
 241
 242   /**
 243    * Create an instance of the AliRawReader class
 244    */
 245   AliRawReader* AliRawReaderHLTCreateInstance(AliRawReader* pParentReader, const char* options);
 246 #ifdef __cplusplus
 247 }
 248 #endif
 249 #endif