HLT/RCU/AliHLTAltroGenerator.h

   1 //-*- Mode: C++ -*-
   2 // $Id$
   3
   4 #ifndef ALIHLTALTROGENERATOR_H
   5 #define ALIHLTALTROGENERATOR_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   AliHLTAltroGenerator.h
  11     @author Matthias Richter
  12     @date
  13     @brief  Simulation class of 10/40bit Altro Data.
  14 */
  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 "AliHLTLogging.h"
  24 #include <vector>
  25 #include <ostream>
  26
  27 class AliRawDataHeader;
  28 class TArrayS;
  29 class TArrayC;
  30 class TRandom;
  31
  32 /**
  33  * @class AliHLTAltroGenerator
  34  */
  35 class AliHLTAltroGenerator : AliHLTLogging {
  36  public:
  37   /** constructor */
  38   AliHLTAltroGenerator(int maxChannels=1000,
  39                        int maxBunches=50,
  40                        int maxBunchLength=10,
  41                        int maxTimebin=1024,
  42                        int maxSignal=500);
  43   /** destructor */
  44   virtual ~AliHLTAltroGenerator();
  45
  46   /**
  47    * Generate a new event.
  48    * Simulate new data and store internally in plain format.
  49    *
  50    * @return size of the encoded data in byte. If the CDH and/or RCU
  51    * trailer was set, the size includes those.
  52    */
  53   int Generate();
  54
  55   /**
  56    * Get the number of 40bit Altro words of the current data set.
  57    * @return number of 40bit Altro words.
  58    */
  59   int GetNof40BitAltroWords() const;
  60
  61   /**
  62    * Get the data size of the current data set.
  63    * @return size of the encoded data in byte. If the CDH and/or RCU
  64    * trailer was set, the size includes those.
  65    */
  66   int GetDataSize();
  67
  68   /**
  69    * Get the simulated data.
  70    * Get a pointer to the internal buffer. The buffer is filled with
  71    * the encoded data from the previous simulation.
  72    * @param pBuffer     target variable to receive the pointer
  73    * @return size in byte, neg. error if failed
  74    */
  75   int GetData(AliHLTUInt8_t* &pBuffer);
  76
  77   /**
  78    * Get the simulated data.
  79    * The provided buffer is filled with the encoded data from the
  80    * previous simulation.
  81    * @param pBuffer     target variable to receive the pointer
  82    * @param size        size of the target buffer
  83    * @return size in byte, neg. error if failed
  84    */
  85   int GetData(AliHLTUInt8_t* pBuffer, int size);
  86
  87   /**
  88    * Set the Common Data Header.
  89    * @param pCDH        the CDH
  90    * @param size        size of the header in byte
  91    * @return neg. error code if failed
  92    */
  93   int SetCDH(AliRawDataHeader* pCDH, int size);
  94
  95   /**
  96    * Set the RCU trailer.
  97    * @param pTrailer    the trailer
  98    * @param size        size of the header in byte
  99    * @return neg. error code if failed
 100    */
 101   int SetRCUTrailer(AliHLTUInt8_t* pTrailer, int size);
 102
 103   /**
 104    * Get list of channels in the current data set.
 105    */
 106   int GetChannels(vector<AliHLTUInt16_t> list);
 107
 108   /**
 109    * Set array of channels for sorting of channels.
 110    * The encoded data will be sorted according to the specified
 111    * list.
 112    * @param array       array of channels
 113    * @param arraySize   size of the array
 114    */
 115   int SetSorting(AliHLTUInt16_t *array, int arraySize);
 116
 117   /**
 118    * Get a random number in the given range.
 119    */
 120   int GetRandom(int min, int max);
 121
 122   /**
 123    * Set parsing direction for the Next functions.
 124    * @param direction   @ref AliHLTAltroGenerator::kBackwards (default),
 125    *                    @ref AliHLTAltroGenerator::kForwards
 126    */
 127   void SetDirection(int direction) {fDirection=direction;}
 128
 129   /**
 130    * Position at the next signal.
 131    * The function follows the pure stream model.
 132    * @return true if there is a new signal available
 133    */
 134   bool Next();
 135
 136   /**
 137    * Get the current signal.
 138    * The current time value can be retrieved by ::GetStartTime or
 139    * ::GetEndTime which return both the current time in the stream
 140    * model.
 141    * @return signal value
 142    */
 143   AliHLTUInt16_t GetSignal();
 144
 145   /**
 146    * Position at the beginning of the next channel.
 147    * Depending on the mode, the function works either back or
 148    * forwards.
 149    * @return true if there is a new channel available
 150    */
 151   bool NextChannel();
 152
 153   /**
 154    * Get the hardware address of the current channel.
 155    */
 156   AliHLTUInt16_t GetHwAddress();
 157
 158   /**
 159    * Get bunch count of the current channel
 160    */
 161   int GetBunchCount();
 162
 163   /**
 164    * Position at the beginning of the next bunch.
 165    * Depending on the mode, the function works either back or
 166    * forwards.
 167    * @return true if there is a new bunch available
 168    */
 169   bool NextBunch();
 170
 171   /**
 172    * Get size of the current bunch.
 173    */
 174   AliHLTUInt16_t GetBunchSize();
 175
 176   /**
 177    * Get start time of the current bunch or signal.
 178    */
 179   AliHLTUInt16_t  GetStartTime();
 180
 181   /**
 182    * Get end time of the current bunch or signal.
 183    */
 184   AliHLTUInt16_t  GetEndTime();
 185
 186   /**
 187    * Get pointer to signals of current bunch.
 188    * The signals are always in ascending order.
 189    */
 190   const Short_t* GetSignals();
 191
 192   /**
 193    * Reset the internal position variables.
 194    */
 195   int Reset();
 196
 197   /**
 198    * Rewind stream position for Next funxtions
 199    */
 200   int Rewind();
 201
 202   /**
 203    * Print content of simulated data to cout.
 204    */
 205   void Print();
 206
 207   /**
 208    * Printout of simulated data.
 209    */
 210   friend ostream &operator<<(ostream &str, AliHLTAltroGenerator &generator);
 211
 212   enum {
 213     kBackwards = 0,
 214     kForwards = 1
 215   };
 216
 217  protected:
 218
 219  private:
 220   /** copy constructor prohibited */
 221   AliHLTAltroGenerator(const AliHLTAltroGenerator&);
 222   /** assignment operator prohibited */
 223   AliHLTAltroGenerator& operator=(const AliHLTAltroGenerator&);
 224
 225   /**
 226    * Encode the simulated data into Altro format
 227    */
 228   int EncodeData(AliHLTUInt8_t* pBuffer, int size);
 229
 230   /// internal data buffer
 231   TArrayC* fpData; //!transient
 232
 233   /// array of simulated data
 234   TArrayS* fpSimData; //! transient
 235
 236   struct AliChannelPosition {
 237     AliHLTUInt16_t fChannel; //! transient
 238     int fPosition; //! transient
 239     int fEnd; //! transient
 240   };
 241
 242   /// channels and their positions in the simulated data
 243   vector<AliChannelPosition> fChannelPositions; //! transient
 244
 245   /// the Altro payload in the simulated data
 246   int fNof10BitWords; //! transient
 247
 248   /// the Common Data Header
 249   AliRawDataHeader* fpCDH; //!transient
 250
 251   /// size of the Common Data Header in byte
 252   int fCDHSize; //! transient
 253
 254   /// the RCU trailer
 255   AliHLTUInt8_t* fpTrailer; //!transient
 256
 257   /// size of the trailer
 258   int fTrailerSize; //!transient
 259
 260   /// maximum number of channels
 261   int fMaxChannels; //! transient
 262
 263   /// maximum number of bunches
 264   int fMaxBunches; //! transient
 265
 266   /// maximum bunche length
 267   int fMaxBunchLength; //! transient
 268
 269   /// max timebin
 270   int fMaxTimebin; //!transient
 271
 272   /// maximum signal
 273   int fMaxSignal; // transient
 274
 275   /// the random number generator
 276   TRandom* fpRand; //! transient
 277
 278   /// direction of parsing
 279   int fDirection; //! transient
 280
 281   /// current channel position for the Next functions
 282   int fCurrentPosition; //! transient
 283
 284   /// current bunch position in the simulated data
 285   int fCurrentBunch; //! transient
 286
 287   /// current offset in the current bunch
 288   int fCurrentTimeOffset; //! transient
 289
 290   ClassDef(AliHLTAltroGenerator, 0);
 291 };
 292
 293 #endif