HLT/benchmark/AliHLTBenchExternalTrackComponent.h

   1 //-*- Mode: C++ -*-
   2 // $Id$
   3
   4 #ifndef ALIHLTBENCHEXTERNALTRACKCOMPONENT_H
   5 #define ALIHLTBENCHEXTERNALTRACKCOMPONENT_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   AliHLTBenchExternalTrackComponent.h
  11     @author Matthias Richter
  12     @date   2008-10-30
  13     @brief  Benchmark component for AliExternalTrackParam transportation.
  14 */
  15
  16 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  17
  18 #include "AliHLTProcessor.h"
  19
  20 class AliExternalTrackParam;
  21 class AliHLTExternalTrackParam;
  22 class TClonesArray;
  23 class TObjArray;
  24 class TRandom;
  25 class TList;
  26
  27 /**
  28  * @class AliHLTBenchExternalTrackComponent
  29  * A component publishing arrays of randomly filled AliExternalTrackParam
  30  * structures in different forms. Currently supported is TClonesArray,
  31  * TObjArray, and C Array.
  32  *
  33  * The component can both publish and receive data blocks. If data blocks
  34  * are available on the input, the array is restored and forwarded in the
  35  * specified publishing mode with specified compression level.
  36  *
  37  * <h2>General properties:</h2>
  38  *
  39  * Component ID: \b BenchmarkAliExternalTrackParam <br>
  40  * Library: \b libAliHLTBenchmark.so     <br>
  41  * Input Data Types: ::kAliHLTDataTypeTrack, ::kAliHLTDataTypeTObjArray <br>
  42  * Output Data Types: ::kAliHLTDataTypeTrack, ::kAliHLTDataTypeTObjArray <br>
  43  *
  44  * <h2>Mandatory arguments:</h2>
  45  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
  46  * By default, publishing of the array is switched off. It has to be enabled
  47  * by one of the three options
  48  * \li -tobjarray <br>
  49  *      publish TObjArray
  50  * \li -tclonesarray <br>
  51  *      publish TClonesArray
  52  * \li -carray <br>
  53  *      publish as C-array
  54  *
  55  * <h2>Optional arguments:</h2>
  56  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
  57  * \li -maxsize      <i> max array size  </i> <br>
  58  * \li -minsize      <i> min array size  </i> <br>
  59  *
  60  * \li -rangemodulo  <i> count  </i> <br>
  61  *      number of events after which the range is changed
  62  * \li -rangeoffset  <i> offset  </i> <br>
  63  *      offset is added to min and max range after the specified number of
  64  *      events. Idially, this offset is negative, causing decreasing range
  65  *      over run time.
  66  * \li -rangefactor  <i> factor  </i> <br>
  67  *      min and max range are multiplied by the factor (float) after the
  68  *      specified number of events.
  69  *
  70  * \li -verbosity      <i> level  </i> <br>
  71  *      different levels of verbosity: 0 (default) is silent
  72  *
  73  * <h2>Configuration:</h2>
  74  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
  75  *
  76  * <h2>Default CDB entries:</h2>
  77  * The component has no default CDB entries.
  78  *
  79  * <h2>Performance:</h2>
  80  *
  81  *
  82  * <h2>Memory consumption:</h2>
  83  *
  84  *
  85  * <h2>Output size:</h2>
  86  *
  87  *
  88  * By using the range alterator options, the range can be changed after a
  89  * certain number of events.
  90  *
  91  * @ingroup alihlt_benchmark_components
  92  */
  93 class AliHLTBenchExternalTrackComponent : public AliHLTProcessor {
  94  public:
  95   /** default constructor */
  96   AliHLTBenchExternalTrackComponent();
  97   /** destructor */
  98   virtual ~AliHLTBenchExternalTrackComponent();
  99
 100   // interface functions: property getters
 101   const char* GetComponentID();
 102   void GetInputDataTypes(AliHLTComponentDataTypeList& list);
 103   AliHLTComponentDataType GetOutputDataType();
 104   int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
 105   void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
 106   AliHLTComponent* Spawn();
 107
 108   /**
 109    * Fill members of the track object with random float values.
 110    * @param track     reference to AliExternalTrackParam object
 111    * @param fillCov   number of elements of the covar members to be filled
 112    *                  max 15
 113    */
 114   static int FillRandom(AliExternalTrackParam* track, int fillCov=15);
 115
 116   /**
 117    * Serialize an object or clones array of AliExternalTrackParam objects
 118    * to a buffer using the definition AliHLTExternalTrackParam.
 119    * @param pArray    the array
 120    * @param buffer    target buffer
 121    * @param size      buffer size
 122    * @return bytes filled to the buffer, neg. error code if failed
 123    */
 124   static int SerializeToStruct(const TObjArray* pArray, AliHLTUInt8_t* buffer, unsigned int size);
 125
 126   /**
 127    * Translate AliHLTExternalTrackParam struct into objects.
 128    * The TObjArray can also be a TClonesArray and must have enough capacity.
 129    */
 130   static int ReadFromStruct(TObjArray* pTgtArray, AliHLTExternalTrackParam* pArray, unsigned int arraySize);
 131
 132   /**
 133    * Calculate a crc checksum for the object array
 134    */
 135   static AliHLTUInt32_t CalcChecksum(const TObjArray* pArray);
 136
 137   /**
 138    * Compare two arrays of AliExternalTrackParamElements
 139    */
 140   static bool Compare(const TObjArray* array1, const TObjArray* array2);
 141
 142   /**
 143    * Find object in the registry
 144    */
 145   static TObject* FindObject(AliHLTUInt32_t id);
 146
 147   enum {
 148     kPublishingOff = 0,
 149     ktobjarray = 1,
 150     ktclonesarray,
 151     kcarray,
 152   };
 153
 154  protected:
 155   // interface functions: processing
 156   int DoInit(int argc, const char** argv);
 157   int DoDeinit();
 158   int DoEvent( const AliHLTComponentEventData& evtData,
 159                const AliHLTComponentBlockData* blocks,
 160                AliHLTComponentTriggerData& trigData,
 161                AliHLTUInt8_t* outputPtr,
 162                AliHLTUInt32_t& size,
 163                AliHLTComponentBlockDataList& outputBlocks );
 164
 165   /**
 166    * Register object and create reference id
 167    * The registry is used for consistency checks in a single threaded system.
 168    * The dump component can access the original object and compare the two.
 169    */
 170   AliHLTUInt32_t Register(TObject* pObject);
 171
 172   /**
 173    * Remove object from registry
 174    */
 175   int Unregister(TObject* pObject);
 176
 177  private:
 178   /** copy constructor prohibited */
 179   AliHLTBenchExternalTrackComponent(const AliHLTBenchExternalTrackComponent&);
 180   /** assignment operator prohibited */
 181   AliHLTBenchExternalTrackComponent& operator=(const AliHLTBenchExternalTrackComponent&);
 182
 183   /** verbosity */
 184   int fVerbosity; //!transient
 185
 186   /** disable global object registry, no check pf received objects */
 187   bool fDisableRegistry; //! transient
 188
 189   /** publishing mode: off, ktclonesarray, ktobjarray, kcarray */
 190   int fMode; //! transient
 191
 192   /** maximum array size */
 193   int fMaxSize; //! transient
 194
 195   /** minimum array size */
 196   int fMinSize; //! transient
 197
 198   /** event count for the next automatic change of range */
 199   int fEventModulo;
 200
 201   /** offset is added to range after fEventModulo events */
 202   int fRangeOffset;
 203
 204   /** range is multiplied after fEventModulo events */
 205   float fRangeMultiplicator;
 206
 207   /** the internal array */
 208   TClonesArray* fpTcArray; //! transient
 209
 210   /** TObjArray this publishing mode was used */
 211   TObjArray* fpTObjArray; //! transient
 212
 213   /** random number generator */
 214   TRandom* fpDice; //! transient
 215
 216   /** registry of object arrays */
 217   static TList* fgpRegistry; //! transient
 218
 219   ClassDef(AliHLTBenchExternalTrackComponent, 0);
 220 };
 221
 222 #endif