HLT/BASE/AliHLTHOMERManager.h

   1 //-*- Mode: C++ -*-\r
   2 \r
   3 // $Id: AliHLTHOMERManager.h $\r
   4 \r
   5 #ifndef ALIHLTHOMERMANAGER_H\r
   6 #define ALIHLTHOMERMANAGER_H\r
   7 \r
   8 /* This file is property of and copyright by the ALICE HLT Project        * \r
   9  * ALICE Experiment at CERN, All rights reserved.                         *\r
  10  * See cxx source for full Copyright notice     \r
  11  */\r
  12 \r
  13 /** @file   AliHLTHOMERManager.h\r
  14     @author Jochen Thaeder\r
  15     @date\r
  16     @brief  Manager for HOMER in aliroot\r
  17 */\r
  18 \r
  19 \r
  20 #include "TClonesArray.h"\r
  21 #include "TString.h"\r
  22 #include "TList.h"\r
  23 \r
  24 #include "AliHLTHOMERSourceDesc.h"\r
  25 #include "AliHLTHOMERBlockDesc.h"\r
  26 #include "AliHLTHOMERReader.h"\r
  27 #include "AliHLTHOMERProxyHandler.h"\r
  28 \r
  29 #include "AliHLTLoggingVariadicFree.h"\r
  30 \r
  31 #define BUFFERSIZE 100\r
  32 \r
  33 class AliHLTHOMERLibManager;\r
  34 \r
  35 /**\r
  36  * @class AliHLTHOMERManager\r
  37  * This Class should handle the communication\r
  38  * from the HLT to aliroot. The HLT sends data via \r
  39  * the HOMER interface on several TCP ports of nodes \r
  40  * in the CERN GPN and DCS network.\r
  41  * All this communication is hidden from the user.\r
  42  * \r
  43  * Right now, a xml file ( SCC1 ) is used to get the\r
  44  * configuration, this will/ has to change to a proxy\r
  45  * running on dedicated nodes.\r
  46  *\r
  47  * @ingroup alihlt_homer\r
  48  */\r
  49 \r
  50 class AliHLTHOMERManager : public AliHLTLogging \r
  51 {\r
  52 public:\r
  53   \r
  54   /*\r
  55    * ---------------------------------------------------------------------------------\r
  56    *                            Constructor / Destructor\r
  57    * ---------------------------------------------------------------------------------\r
  58    */\r
  59 \r
  60   /** default constructor */\r
  61   AliHLTHOMERManager();\r
  62 \r
  63   /** destructor */\r
  64   virtual ~AliHLTHOMERManager();\r
  65 \r
  66   /** Initialize \r
  67    *  @return 0 on success, <0 for failure\r
  68    */\r
  69   Int_t Initialize();\r
  70 \r
  71   /*\r
  72    * ---------------------------------------------------------------------------------\r
  73    *                            Source Handling - public\r
  74    * ---------------------------------------------------------------------------------\r
  75    */\r
  76 \r
  77   /** Create Sources List from HOMER-Proxy \r
  78    *  @return 0 on success, <0 for failure, 1 for no active service\r
  79    */\r
  80   virtual Int_t CreateSourcesList();\r
  81 \r
  82   /** Set state of a source \r
  83    *  @param source      Pointer to AliHLTHOMERSourceDesc object.\r
  84    *  @param state       New (selected/not selected) state.\r
  85    */\r
  86   void   SetSourceState( AliHLTHOMERSourceDesc* source, Bool_t state);\r
  87 \r
  88   /** Get pointer to source List */\r
  89   TList* GetSourceList() { return fSourceList; }\r
  90 \r
  91   /*\r
  92    * ---------------------------------------------------------------------------------\r
  93    *                            Connection Handling - public\r
  94    * ---------------------------------------------------------------------------------\r
  95    */\r
  96 \r
  97   /** Connect to HOMER sources, of a certain detector.\r
  98    *  which gets created when state has changed \r
  99    *  @param detector    Detector to be connected to\r
 100    *  @return            0 on success, <0 for failure\r
 101    */\r
 102   Int_t ConnectHOMER( TString detector="ALL" );\r
 103 \r
 104   /** Disconnect from HOMER sources */\r
 105   void  DisconnectHOMER();\r
 106 \r
 107   /** Reconnect from HOMER sources \r
 108    *  @param detector    Detector to be connected to\r
 109    *  @return            0 on success, <0 for failure\r
 110    */\r
 111   Int_t ReconnectHOMER( TString detector);\r
 112 \r
 113   /*\r
 114    * ---------------------------------------------------------------------------------\r
 115    *                            Event Handling - public\r
 116    * ---------------------------------------------------------------------------------\r
 117    */\r
 118 \r
 119   /** Loads the next Event, after being connected \r
 120    *  @return 0 on success, <0 for failure\r
 121    */\r
 122   virtual Int_t NextEvent();\r
 123 \r
 124   /** Loads the next Cycle, after being connected \r
 125    *  @return 0 on success, <0 for failure\r
 126    */\r
 127   virtual Int_t NextCycle() { return NextEvent(); }\r
 128 \r
 129   /** Get event ID */\r
 130   ULong_t GetEventID() { return fEventID[fCurrentBufferIdx]; }\r
 131 \r
 132   /* ---------------------------------------------------------------------------------\r
 133    *                           Buffer Handling - public\r
 134    * ---------------------------------------------------------------------------------\r
 135    */\r
 136 \r
 137   /** Get pointer to last requested BlockList \r
 138    *  @return     ptr to buffer, NULL if buffer boundary reached                \r
 139    */\r
 140   TList* GetBlockList() { return GetBlockListEventBuffer(fCurrentBufferIdx); }\r
 141 \r
 142   /** Get pointer to last asynchrounous BlockList \r
 143    *  @return     ptr to buffer, NULL if none present\r
 144    */\r
 145   TList* GetAsyncBlockList() { \r
 146     cout << "Returning asyncblocklist size : " <<\r
 147       fAsyncBlockList->GetSize() << endl;\r
 148     return fAsyncBlockList; \r
 149   }\r
 150 \r
 151   /** Navigate backwards in event buffer \r
 152    *  @return      index in buffer, -1 if boundary reached                \r
 153    */\r
 154   Int_t  NavigateEventBufferBack();\r
 155 \r
 156   /** Navigate forwards in event buffer \r
 157    *  @return      index in buffer, -1 if boundary reached                \r
 158    */\r
 159   Int_t  NavigateEventBufferFwd();\r
 160 \r
 161   /* ---------------------------------------------------------------------------------\r
 162    *                          Trigger Handling - public\r
 163    * ---------------------------------------------------------------------------------\r
 164    */\r
 165 \r
 166   /** Set and get the string used to select triggers \r
 167    *  @param triggerString    Trigger selection string\r
 168    */\r
 169   void SetTriggerString ( TString triggerString ) { fTriggerString = triggerString; }\r
 170 \r
 171   /** Get TriggerString */\r
 172   TString GetTriggerString () { return fTriggerString; }\r
 173 \r
 174   ///////////////////////////////////////////////////////////////////////////////////\r
 175 \r
 176 protected:\r
 177 \r
 178   /** Dynamic loader manager for the HOMER library */\r
 179   AliHLTHOMERLibManager* fLibManager;             //! transient\r
 180 \r
 181   /** Indicates, if a sources have changes, \r
 182    *  so that one has to reconnect. */\r
 183   Bool_t    fStateHasChanged;                     //  see above\r
 184 \r
 185   ///////////////////////////////////////////////////////////////////////////////////\r
 186 \r
 187 private:\r
 188 \r
 189   /** copy constructor prohibited */\r
 190   AliHLTHOMERManager(const AliHLTHOMERManager&);\r
 191 \r
 192   /** assignment operator prohibited */\r
 193   AliHLTHOMERManager& operator=(const AliHLTHOMERManager&);\r
 194 \r
 195   /*\r
 196    * ---------------------------------------------------------------------------------\r
 197    *                            Connection Handling - private\r
 198    * ---------------------------------------------------------------------------------\r
 199    */\r
 200 \r
 201   /** Create a readout list for Hostname and ports \r
 202    *  @param socurceHostnames   Array of selected hostnames\r
 203    *  @param socurcePorts       Array of selected ports\r
 204    *  @param socurceCount       Number of selected hostname:port\r
 205    *  @param detector           detector to be selected\r
 206    */\r
 207   void CreateReadoutList( const char** sourceHostnames, UShort_t* sourcePorts, \r
 208                           UInt_t &sourceCount, TString detector );\r
 209 \r
 210   /** Checks if already connected to HOMER sources */\r
 211   Bool_t IsConnected() { return fConnected; }  \r
 212   \r
 213   /* ---------------------------------------------------------------------------------\r
 214    *                           Buffer Handling - private\r
 215    * ---------------------------------------------------------------------------------\r
 216    */\r
 217 \r
 218   /** Create and add Block List to Buffer */\r
 219   void AddBlockListToBuffer();\r
 220 \r
 221   /** Add bocks to asynchronous BlockList */\r
 222   void AddToAsyncBlockList();\r
 223 \r
 224   /** Get pointer to block list in event buffer \r
 225    *  @return     ptr to buffer, NULL if not present\r
 226    */\r
 227   TList* GetBlockListEventBuffer( Int_t idx );\r
 228     \r
 229   /*\r
 230    * ---------------------------------------------------------------------------------\r
 231    *                            Block Handling - private\r
 232    * ---------------------------------------------------------------------------------\r
 233    */\r
 234 \r
 235   /** Get Number of blocks in current event */\r
 236   ULong_t GetNBlks() { return fNBlks; }\r
 237 \r
 238   // ----------------------------------------------------\r
 239 \r
 240   /** Handle Blocks and fill them in event buffer or asyncronous BlockList\r
 241    *  @return 0 on success, <0 for failure\r
 242    */\r
 243   Int_t HandleBlocks();\r
 244 \r
 245   /** Check is block are from syncronous source\r
 246    *  @return kTRUE, if asyncronous kFALSE\r
 247    */\r
 248   Bool_t IsSyncBlocks();\r
 249 \r
 250   // ----------------------------------------------------\r
 251 \r
 252   /** Get pointer to block ndx in current event \r
 253    *  @param ndx        Block index\r
 254    *  @return           returns pointer to blk, NULL if no block present\r
 255    */\r
 256   void* GetBlk( Int_t ndx );\r
 257 \r
 258   /** Get pointer to current block in current event */\r
 259   void* GetBlk() { return GetBlk(fCurrentBlk); }\r
 260 \r
 261   /** Get first block in current event */\r
 262   void* GetFirstBlk() { fCurrentBlk=0; return GetBlk(0); }\r
 263 \r
 264   /** Get next block in current event */\r
 265   void* GetNextBlk() { return GetBlk(++fCurrentBlk); }\r
 266 \r
 267   // ----------------------------------------------------\r
 268 \r
 269   /** Get size of block ndx \r
 270    *  @param ndx        Block index\r
 271    *  @return           returns size blk, 0 otherwise\r
 272    */\r
 273   ULong_t GetBlkSize( Int_t ndx );\r
 274 \r
 275   /** Get size of current block */ \r
 276   ULong_t GetBlkSize() { return GetBlkSize( fCurrentBlk ); }\r
 277 \r
 278   // ---------------------------------------------------- \r
 279 \r
 280   /** Get origin of block ndx \r
 281    *  @param ndx        Block index\r
 282    *  @return           origin of block\r
 283    */\r
 284   TString GetBlkOrigin( Int_t ndx );\r
 285 \r
 286   /** Get origin of current block */\r
 287   TString GetBlkOrigin(){ return GetBlkOrigin( fCurrentBlk ); }\r
 288 \r
 289   // ----------------------------------------------------\r
 290 \r
 291   /** Get type of block ndx \r
 292    *  @param ndx        Block index\r
 293    *  @return           type of block\r
 294    */\r
 295   TString GetBlkType( Int_t ndx ); \r
 296 \r
 297   /** Get type of current block */\r
 298   TString GetBlkType() { return GetBlkType( fCurrentBlk ); } \r
 299   \r
 300   // ----------------------------------------------------\r
 301   \r
 302   /** Get specification of block ndx \r
 303    *  @param ndx        Block index\r
 304    *  @return           specification of block\r
 305    */\r
 306   ULong_t GetBlkSpecification( Int_t ndx );\r
 307 \r
 308   /** Get specification of current block */\r
 309   ULong_t GetBlkSpecification() { return GetBlkSpecification( fCurrentBlk ); } \r
 310 \r
 311   // ----------------------------------------------------\r
 312 \r
 313   /** Checks if current Block should was requested \r
 314    *  @return           returns kTRUE, if block should was requested\r
 315    */\r
 316   Bool_t CheckIfRequested( AliHLTHOMERBlockDesc* block );\r
 317 \r
 318   /* ---------------------------------------------------------------------------------\r
 319    *                          Trigger Handling - private\r
 320    * ---------------------------------------------------------------------------------\r
 321    */\r
 322   \r
 323   /** Loops over the data block from all the readers in the readerlist until\r
 324    *    a triggerdecsision has been found\r
 325    *    Locates the triggerdecision required by fTriggerString and checks if it triggered \r
 326    *  @return           returns kTRUE, if event was triggered, kFALSE otherwise\r
 327    */\r
 328   Bool_t CheckTriggerDecision();\r
 329 \r
 330   /*\r
 331    * ---------------------------------------------------------------------------------\r
 332    *                            Members - private\r
 333    * ---------------------------------------------------------------------------------\r
 334    */\r
 335 \r
 336   /** Proxy Handler to get the list of sources */\r
 337   AliHLTHOMERProxyHandler *fProxyHandler;               //! transient \r
 338 \r
 339   // == connection ==\r
 340 \r
 341   /** Pointer to current HOMER reader */\r
 342   AliHLTHOMERReader       *fCurrentReader;              //! transient \r
 343 \r
 344   /** List to pointer of HOMER readers */\r
 345   TList                   *fReaderList;                 //! transient\r
 346 \r
 347   // == sources ==\r
 348 \r
 349   /** List to HOMER sources */\r
 350   TList                   *fSourceList;                 //! transient\r
 351 \r
 352   // == events ==\r
 353 \r
 354   /** Number of blockes in current event */\r
 355   ULong_t                  fNBlks;                      //  see above\r
 356 \r
 357   /** EventID of current event */\r
 358   ULong64_t                fEventID[BUFFERSIZE];        //  see above\r
 359 \r
 360   /** Current block in current event */\r
 361   ULong_t                  fCurrentBlk;                 //  see above\r
 362 \r
 363   // == Asynchronous BlockList ==\r
 364 \r
 365   /** List containing asychronous blocks */\r
 366   TList                   *fAsyncBlockList;             //  see above\r
 367 \r
 368   // == event buffer ==\r
 369 \r
 370   /** Event Buffer */\r
 371   TClonesArray            *fEventBuffer;                //  see above\r
 372 \r
 373   /** Buffer index to last received event */\r
 374   Int_t                    fBufferTopIdx;               //  see above\r
 375 \r
 376   /** Buffer index to last received event */\r
 377   Int_t                    fBufferLowIdx;               //  see above\r
 378 \r
 379   /** Buffer index to current event */\r
 380   Int_t                    fCurrentBufferIdx;           //  see above\r
 381 \r
 382   /** Navigate index through event buffer */\r
 383   Int_t                    fNavigateBufferIdx;          //  see above\r
 384   \r
 385   // == states ==\r
 386   \r
 387   /** Shows connection status */\r
 388   Bool_t                   fConnected;                  //  see above\r
 389 \r
 390   // == trigger selection ==\r
 391 \r
 392   /** String indicating which trigger should be used to select events */\r
 393   TString                  fTriggerString;              //  see above\r
 394 \r
 395   /** Number Events not triggered, before next triggered event is found */\r
 396   Int_t                    fNEventsNotTriggered;        //  see above\r
 397 \r
 398   /** Retry reading next event */\r
 399   Bool_t                   fRetryNextEvent;             //  see above\r
 400 \r
 401   ClassDef(AliHLTHOMERManager, 1); // Manage connections to HLT data-sources.\r
 402 };\r
 403 \r
 404 #endif\r