HLT/BASE/AliHLTHOMERManager.cxx

   1 //-*- Mode: C++ -*-\r
   2 // $Id: AliHLTHOMERManager.cxx  $\r
   3 //**************************************************************************\r
   4 //* This file is property of and copyright by the ALICE HLT Project        * \r
   5 //* ALICE Experiment at CERN, All rights reserved.                         *\r
   6 //*                                                                        *\r
   7 //* Primary Authors: Jochen Thaeder <thaeder@kip.uni-heidelberg.de>        *\r
   8 //*                  for The ALICE HLT Project.                            *\r
   9 //*                                                                        *\r
  10 //* Permission to use, copy, modify and distribute this software and its   *\r
  11 //* documentation strictly for non-commercial purposes is hereby granted   *\r
  12 //* without fee, provided that the above copyright notice appears in all   *\r
  13 //* copies and that both the copyright notice and this permission notice   *\r
  14 //* appear in the supporting documentation. The authors make no claims     *\r
  15 //* about the suitability of this software for any purpose. It is          *\r
  16 //* provided "as is" without express or implied warranty.                  *\r
  17 //**************************************************************************\r
  18 \r
  19 /** @file   AliHLTHOMERManager.cxx\r
  20     @author Jochen Thaeder\r
  21     @date\r
  22     @brief  Manger for HOMER in aliroot\r
  23 */\r
  24 \r
  25 // see header file for class documentation\r
  26 // or\r
  27 // refer to README to build package\r
  28 // or\r
  29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt\r
  30 \r
  31 #if __GNUC__>= 3\r
  32    using namespace std;\r
  33 #endif\r
  34 \r
  35 #define EVE_DEBUG 0\r
  36 \r
  37 #include "AliHLTHOMERManager.h"\r
  38 // -- -- -- -- -- -- -- \r
  39 #include "AliHLTHOMERLibManager.h"\r
  40 #include "AliHLTHOMERSourceDesc.h"\r
  41 #include "AliHLTHOMERBlockDesc.h"\r
  42 // -- -- -- -- -- -- -- \r
  43 #include "AliHLTGlobalTriggerDecision.h"\r
  44 #include "AliHLTTriggerDecision.h"\r
  45 //---------------------------\r
  46 \r
  47 ClassImp(AliHLTHOMERManager)\r
  48 \r
  49 /*\r
  50  * ---------------------------------------------------------------------------------\r
  51  *                            Constructor / Destructor\r
  52  * ---------------------------------------------------------------------------------\r
  53  */\r
  54 \r
  55 //##################################################################################\r
  56   AliHLTHOMERManager::AliHLTHOMERManager() :\r
  57   fLibManager(new AliHLTHOMERLibManager),\r
  58   fStateHasChanged(kTRUE),\r
  59   fProxyHandler(NULL),\r
  60   fCurrentReader(NULL),\r
  61   fReaderList(NULL),\r
  62   fSourceList(NULL),\r
  63   fNBlks(0),\r
  64   fEventID(),\r
  65   fCurrentBlk(0),\r
  66   fAsyncBlockList(NULL),\r
  67   fEventBuffer(NULL),\r
  68   fBufferTopIdx(-1),\r
  69   fBufferLowIdx(-1),\r
  70   fCurrentBufferIdx(-1),\r
  71   fNavigateBufferIdx(-1),\r
  72   fConnected(kFALSE), \r
  73   fTriggerString("ALL"), \r
  74   fNEventsNotTriggered(0),\r
  75   fRetryNextEvent(kFALSE) {\r
  76   // see header file for class documentation\r
  77   // or\r
  78   // refer to README to build package\r
  79   // or\r
  80   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt\r
  81 \r
  82 }\r
  83 \r
  84 //##################################################################################\r
  85 AliHLTHOMERManager::~AliHLTHOMERManager() {\r
  86   // see header file for class documentation\r
  87 \r
  88   if ( fLibManager ) {\r
  89 \r
  90     if ( fReaderList ) {\r
  91       TIter next(fReaderList);\r
  92       TObject * object = NULL;\r
  93       while ( ( object = next()) )\r
  94         fLibManager->DeleteReader(static_cast<AliHLTHOMERReader*>(object) );\r
  95       \r
  96       fReaderList->Clear();\r
  97       delete fReaderList;\r
  98     }\r
  99     fReaderList = NULL;   \r
 100     \r
 101     delete fLibManager;\r
 102   } \r
 103   fLibManager = NULL;\r
 104 \r
 105   if ( fProxyHandler != NULL )\r
 106     delete fProxyHandler;\r
 107   fProxyHandler = NULL;\r
 108 \r
 109   if ( fSourceList != NULL )\r
 110     delete fSourceList;\r
 111   fSourceList = NULL;\r
 112 \r
 113   if ( fEventBuffer ) {\r
 114     fEventBuffer->Clear();\r
 115     delete fEventBuffer;\r
 116   }\r
 117   fEventBuffer = NULL;\r
 118 \r
 119   if ( fAsyncBlockList ) {\r
 120     fAsyncBlockList->Clear();\r
 121     delete fAsyncBlockList;\r
 122   }\r
 123   fAsyncBlockList = NULL;\r
 124 }\r
 125 \r
 126 //##################################################################################\r
 127 Int_t AliHLTHOMERManager::Initialize() {\r
 128   // see header file for class documentation\r
 129 \r
 130   Int_t iResult = 0;\r
 131 \r
 132   // -- Initialize ProxyHandler\r
 133   if ( !fProxyHandler )\r
 134     fProxyHandler = new AliHLTHOMERProxyHandler();\r
 135   \r
 136   if ( fProxyHandler ) {\r
 137     iResult = fProxyHandler->Initialize();\r
 138     if (iResult)\r
 139       HLTError(Form("Initialize of ProxyHandler failed."));\r
 140   }\r
 141   else {\r
 142     iResult = -1;\r
 143     HLTError(Form("Creating of ProxyHandler failed."));\r
 144   }\r
 145  \r
 146   // -- Initialize ReaderList\r
 147   //    List ist not owner, as reader have to be created/deleted by the LibManager\r
 148   if( !fReaderList )\r
 149     fReaderList = new TList();\r
 150   \r
 151   // -- Initialize asynchronous BlockList\r
 152   if( !fAsyncBlockList ) {\r
 153     fAsyncBlockList = new TList();\r
 154     fAsyncBlockList->SetOwner(kFALSE);\r
 155   }\r
 156 \r
 157   // -- Initialize Event Buffer and EventID array\r
 158   if ( !fEventBuffer ) {\r
 159     fEventBuffer = new TClonesArray( "TList", BUFFERSIZE );\r
 160   }\r
 161 \r
 162   for ( Int_t idx = 0; idx < BUFFERSIZE; ++idx ) {\r
 163     new ((*fEventBuffer)[idx]) TList( );\r
 164     (reinterpret_cast<TList*>((*fEventBuffer)[idx]))->SetOwner(kTRUE);\r
 165     \r
 166     fEventID[idx] = 0;\r
 167   }\r
 168 \r
 169   return iResult;\r
 170 }\r
 171 \r
 172 /*\r
 173  * ---------------------------------------------------------------------------------\r
 174  *                                 Source Handling\r
 175  * ---------------------------------------------------------------------------------\r
 176  */\r
 177 \r
 178 //##################################################################################\r
 179 Int_t AliHLTHOMERManager::CreateSourcesList() {\r
 180   // see header file for class documentation\r
 181 \r
 182   Int_t iResult = 0;\r
 183   \r
 184   if ( fSourceList != NULL )\r
 185     delete fSourceList;\r
 186   fSourceList = NULL;\r
 187 \r
 188   fSourceList = new TList();\r
 189   fSourceList->SetOwner( kTRUE );\r
 190 \r
 191   iResult = fProxyHandler->FillSourceList( fSourceList );\r
 192   if ( iResult < 0 ) {\r
 193     HLTWarning(Form("There have been errors, while creating the sources list."));\r
 194   }\r
 195   else if ( iResult > 0 ) {\r
 196     HLTWarning(Form("No active services found."));\r
 197   }\r
 198   else if ( fSourceList->IsEmpty() ) {\r
 199     HLTWarning(Form("No active services in the list."));\r
 200     iResult = 2;\r
 201   }\r
 202   else {\r
 203      HLTInfo(Form("New sources list created."));\r
 204 \r
 205     // -- New SourceList has been created \r
 206     // --> All Sources are new --> State has changed\r
 207     fStateHasChanged = kTRUE;\r
 208   }\r
 209 \r
 210   return iResult;\r
 211 }\r
 212 \r
 213 //##################################################################################\r
 214 void AliHLTHOMERManager::SetSourceState( AliHLTHOMERSourceDesc * source, Bool_t state ) {\r
 215   // see header file for class documentation\r
 216 \r
 217   if ( source->IsSelected() != state ) {\r
 218     source->SetState( state );\r
 219     fStateHasChanged = kTRUE;\r
 220   }\r
 221 \r
 222   return;\r
 223 }\r
 224 \r
 225 /*\r
 226  * ---------------------------------------------------------------------------------\r
 227  *                         Connection Handling - public\r
 228  * ---------------------------------------------------------------------------------\r
 229  */\r
 230 \r
 231 //##################################################################################\r
 232 Int_t AliHLTHOMERManager::ConnectHOMER( TString detector ){\r
 233   // see header file for class documentation\r
 234 \r
 235   Int_t iResult = 0;\r
 236 \r
 237   // -- Check if LibManager is present\r
 238   if ( ! fLibManager ) {\r
 239     HLTError(Form("No LibManager present."));\r
 240     return -1;\r
 241   }\r
 242   \r
 243   // -- Check if already connected and state has not changed\r
 244   if ( fStateHasChanged == kFALSE && IsConnected() ) {\r
 245     HLTInfo(Form("No need for reconnection."));\r
 246     return 0;\r
 247   }\r
 248   \r
 249   // -- If already connected, disconnect before connect\r
 250   //    or if ReaderList already filled\r
 251   if ( IsConnected() || fReaderList->GetSize() != 0 )\r
 252     DisconnectHOMER();\r
 253   \r
 254   // -- Create the Readoutlist\r
 255   UShort_t* sourcePorts = new UShort_t [fSourceList->GetEntries()];\r
 256   const Char_t ** sourceHostnames = new const Char_t* [fSourceList->GetEntries()];\r
 257   UInt_t sourceCount = 0;\r
 258 \r
 259   CreateReadoutList( sourceHostnames, sourcePorts, sourceCount, detector );\r
 260   if ( sourceCount == 0 ) {\r
 261     HLTError(Form("No sources selected, aborting."));\r
 262     return -2;\r
 263   }\r
 264 \r
 265   // ***\r
 266   // *** Connect to data sources\r
 267   // ***\r
 268   \r
 269   for (UInt_t idx = 0; idx < sourceCount; idx++) {\r
 270     \r
 271     HLTInfo(Form("Adding source %d as %s : %d", idx, sourceHostnames[idx], sourcePorts[idx]));\r
 272     \r
 273     fReaderList->Add(dynamic_cast<TObject*>(fLibManager->OpenReader(sourceHostnames[idx], sourcePorts[idx])));\r
 274     AliHLTHOMERReader *reader = static_cast<AliHLTHOMERReader*>(fReaderList->Last());\r
 275     if ( !reader ) {\r
 276       HLTError(Form("Adding reader failed, aborting"));\r
 277       return -3;\r
 278     }\r
 279 \r
 280     if ( (iResult = reader->GetConnectionStatus()) )  {\r
 281 \r
 282       // -- Connection to source failed\r
 283       \r
 284       HLTError(Form("Error establishing connection to TCP source %s:%hu: %s (%d)",\r
 285                     sourceHostnames[idx], sourcePorts[idx], strerror(iResult), iResult));\r
 286 \r
 287       if( !(TString(sourceHostnames[idx]).CompareTo("localhost")) ) {\r
 288         HLTInfo("The failed connection is on localhost. is SSH tunnel up????? ");\r
 289         HLTInfo(Form("Do: 'ssh -L %d:alihlt-vobox0.cern.ch:%d cernUser@lxplus.cern.ch -fN'",\r
 290                      sourcePorts[idx], sourcePorts[idx]));\r
 291       }\r
 292       \r
 293       // -- Remove reader\r
 294       fReaderList->RemoveLast();\r
 295 \r
 296       if ( reader )\r
 297         fLibManager->DeleteReader( reader );\r
 298       reader = NULL;\r
 299       \r
 300       HLTInfo(Form("Removed source %d,  %s : %d from sourceList", idx, sourceHostnames[idx], sourcePorts[idx]));\r
 301       \r
 302     } \r
 303     else {\r
 304       // -- Connection succeded\r
 305       fConnected = kTRUE;\r
 306 \r
 307       HLTInfo(Form("Connection established to source %s on port %d", sourceHostnames[idx], sourcePorts[idx]));\r
 308     }\r
 309     \r
 310   } // for (Int_t idx = 0; idx < sourceCount; idx++) {\r
 311   \r
 312   delete[] sourceHostnames;\r
 313   delete[] sourcePorts;\r
 314 \r
 315   return iResult;\r
 316 \r
 317 }\r
 318 \r
 319 //##################################################################################\r
 320 void AliHLTHOMERManager::DisconnectHOMER(){\r
 321   // see header file for class documentation\r
 322 \r
 323   if ( ! IsConnected() )\r
 324     return;\r
 325 \r
 326   if ( fReaderList && fLibManager ) {\r
 327     TIter next(fReaderList);\r
 328     TObject * object = NULL;\r
 329     while ( ( object = next()) ) \r
 330       fLibManager->DeleteReader(static_cast<AliHLTHOMERReader*>(object) );\r
 331       \r
 332     fReaderList->Clear();\r
 333     delete fReaderList;\r
 334     fReaderList = NULL;\r
 335   }\r
 336   \r
 337   fStateHasChanged = kTRUE;\r
 338   fConnected = kFALSE;\r
 339 \r
 340   HLTInfo(Form("Connection closed."));\r
 341 \r
 342   return;\r
 343 }\r
 344 \r
 345 //##################################################################################\r
 346 Int_t AliHLTHOMERManager::ReconnectHOMER( TString detector="" ){\r
 347   // see header file for class documentation\r
 348   \r
 349   Int_t iResult = 0;\r
 350 \r
 351   if ( IsConnected() )\r
 352     DisconnectHOMER();\r
 353 \r
 354   iResult = ConnectHOMER(detector);\r
 355   if ( iResult ) {\r
 356     HLTError(Form("Error reconnecting."));\r
 357   }\r
 358 \r
 359   return iResult;\r
 360 }\r
 361 \r
 362 /*\r
 363  * ---------------------------------------------------------------------------------\r
 364  *                            Event Handling - public\r
 365  * ---------------------------------------------------------------------------------\r
 366  */\r
 367 \r
 368 //##################################################################################\r
 369 Int_t AliHLTHOMERManager::NextEvent(){\r
 370  \r
 371   // see header file for class documentation\r
 372   \r
 373 \r
 374   Int_t iResult = 0;\r
 375   Int_t iRetryCount = 0;\r
 376   \r
 377   if ( !IsConnected() || fStateHasChanged ) \r
 378     ConnectHOMER();\r
 379   \r
 380   if ( !IsConnected() ) {\r
 381     HLTWarning(Form( "Not connected yet." ));\r
 382     return -1;\r
 383   }\r
 384 \r
 385   // -- Reset asyncronous BlockList\r
 386   fAsyncBlockList->Clear();\r
 387 \r
 388   // ***\r
 389   // *** Loop over all readers and get new event data\r
 390   // ***\r
 391   \r
 392   TIter next(fReaderList);\r
 393   TObject * object = NULL;\r
 394   \r
 395   while( (object = next()) ) {\r
 396     \r
 397     fCurrentReader = static_cast<AliHLTHOMERReader*>(object);\r
 398     \r
 399     // -- Read next event data and error handling for HOMER (error codes and empty blocks)\r
 400     while ( 1 ) {\r
 401       \r
 402       iResult = fCurrentReader->ReadNextEvent( 40000000 /*timeout in us*/);\r
 403       \r
 404       if ( iResult == 111 || iResult == 32 || iResult == 6 ) {\r
 405         HLTError(Form("No connection to source %d: %s (%d)", \r
 406                       fCurrentReader->GetErrorConnectionNdx(), strerror(iResult), iResult));\r
 407         break;\r
 408       } \r
 409       else if ( iResult == 110 ) {\r
 410         HLTError(Form("Timeout occured, reading event from source %d: %s (%d)", \r
 411                       fCurrentReader->GetErrorConnectionNdx(), strerror(iResult), iResult));\r
 412         break;\r
 413       } \r
 414       else if ( iResult == 56 ) {\r
 415         ++iRetryCount;\r
 416       \r
 417         if ( iRetryCount >= 20 ) {\r
 418           HLTError(Form("Retry Failed: Error reading event from source %d: %s (%d), returning", \r
 419                         fCurrentReader->GetErrorConnectionNdx(), strerror(iResult), iResult));\r
 420           break;\r
 421         } \r
 422         else {\r
 423           HLTError(Form("Retry: Error reading event from source %d: %s (%d), making another attempt (no %d out of 20)", \r
 424                         fCurrentReader->GetErrorConnectionNdx(), strerror(iResult), iResult, iRetryCount));\r
 425           //break;\r
 426           continue;\r
 427         }\r
 428       }\r
 429       else if ( iResult ) {\r
 430         HLTError(Form("General Error reading event from source %d: %s (%d), giving up", \r
 431                       fCurrentReader->GetErrorConnectionNdx(), strerror(iResult), iResult));\r
 432         fConnected = kFALSE;\r
 433         break;\r
 434       } \r
 435       else {\r
 436         break;\r
 437       }\r
 438 \r
 439     } // while( 1 ) {\r
 440     \r
 441     \r
 442     // -- Check if event could be read\r
 443     if ( iResult )\r
 444       continue;\r
 445 \r
 446     // -- Handle Blocks from current reader\r
 447     iResult = HandleBlocks();\r
 448     if ( iResult ) {\r
 449       HLTError(Form("Handling of blocks failed."));\r
 450     }\r
 451 \r
 452   } // while( (object = next()) ) {\r
 453 \r
 454   // -- Check if NextEvent should be recalled, \r
 455   //    to catch the next event with a trigger\r
 456   if ( fRetryNextEvent ) {\r
 457     usleep(1000000);\r
 458     fRetryNextEvent = kFALSE;\r
 459     \r
 460     HLTInfo(Form("Checked trigger of %d events, without triggering", fNEventsNotTriggered));\r
 461     return NextEvent();\r
 462   }\r
 463   else\r
 464     return 0;  \r
 465 }\r
 466 \r
 467 /* ---------------------------------------------------------------------------------\r
 468  *                           Buffer Handling - public\r
 469  * ---------------------------------------------------------------------------------\r
 470  */\r
 471 \r
 472 //##################################################################################\r
 473 Int_t AliHLTHOMERManager::NavigateEventBufferBack() { \r
 474   // see header file for class documentation\r
 475 \r
 476   // -- reached the end of the buffer\r
 477   if ( fNavigateBufferIdx == fBufferLowIdx )\r
 478     return -1;\r
 479 \r
 480   Int_t newIdx = fNavigateBufferIdx - 1;\r
 481   if ( newIdx == -1 )\r
 482     newIdx = BUFFERSIZE-1;\r
 483 \r
 484   fCurrentBufferIdx = fNavigateBufferIdx = newIdx;\r
 485 \r
 486   return newIdx;\r
 487 }\r
 488 \r
 489 //##################################################################################\r
 490 Int_t AliHLTHOMERManager::NavigateEventBufferFwd() {\r
 491   // see header file for class documentation\r
 492 \r
 493   // -- reached the top of the buffer\r
 494   if ( fNavigateBufferIdx == fBufferTopIdx )\r
 495     return -1;\r
 496 \r
 497   Int_t newIdx = fNavigateBufferIdx + 1;\r
 498   if ( newIdx == BUFFERSIZE )\r
 499     newIdx = 0;\r
 500   \r
 501   fCurrentBufferIdx = fNavigateBufferIdx = newIdx;\r
 502 \r
 503   return newIdx;\r
 504 }\r
 505 \r
 506  ///////////////////////////////////////////////////////////////////////////////////\r
 507 \r
 508 /*\r
 509  * ---------------------------------------------------------------------------------\r
 510  *                            Connection Handling - private\r
 511  * ---------------------------------------------------------------------------------\r
 512  */\r
 513 \r
 514 //##################################################################################\r
 515 void AliHLTHOMERManager::CreateReadoutList( const char** sourceHostnames, UShort_t *sourcePorts, \r
 516                                             UInt_t &sourceCount, TString detector ){\r
 517   // see header file for class documentation\r
 518 \r
 519   AliHLTHOMERSourceDesc * source= NULL;\r
 520 \r
 521   // -- Read all sources and check if they should be read out\r
 522   TIter next( fSourceList );\r
 523   while ( ( source = dynamic_cast<AliHLTHOMERSourceDesc*>(next()) ) ) {\r
 524 \r
 525     // -- If detector NO detector name given\r
 526     if ( ! detector.CompareTo("ALL") ) {\r
 527       // -- Continue if source is not selected\r
 528       if ( ! source->IsSelected() )\r
 529         continue;\r
 530     }\r
 531     // -- DetectorName given\r
 532     else {\r
 533       // -- Continue if detector name doesn't match\r
 534       if ( detector.CompareTo(source->GetDetector()) )\r
 535         continue;\r
 536       else\r
 537         source->Select();\r
 538     }\r
 539     \r
 540     Bool_t exists = kFALSE;\r
 541     \r
 542     // -- Loop over existing entries and check if entry is already in readout list\r
 543     for ( UInt_t ii = 0; ii < sourceCount; ii++ ){\r
 544       if ( !strcmp( sourceHostnames[ii], source->GetHostname().Data() ) \r
 545            && sourcePorts[ii] == source->GetPort() ) {\r
 546         exists = kTRUE;\r
 547         break;\r
 548       }\r
 549     }\r
 550 \r
 551     // -- Add new entires to readout list\r
 552     if ( ! exists ) {\r
 553       sourcePorts[sourceCount] = source->GetPort();\r
 554       sourceHostnames[sourceCount] = source->GetHostname().Data();\r
 555       sourceCount++;\r
 556     }\r
 557 \r
 558   } // while ( ( source = (AliHLTHOMERSourceDesc*)next() ) ) {\r
 559 \r
 560   fStateHasChanged = kFALSE;\r
 561 \r
 562   return;\r
 563 }\r
 564 \r
 565 /*\r
 566  * ---------------------------------------------------------------------------------\r
 567  *                          Buffer Handling - private\r
 568  * ---------------------------------------------------------------------------------\r
 569  */\r
 570 \r
 571 //##################################################################################\r
 572 void AliHLTHOMERManager::AddBlockListToBuffer() {\r
 573   // see header file for class documentation\r
 574 \r
 575   // -- Check if event is already in buffer\r
 576   ULong_t eventID = static_cast<ULong64_t>(fCurrentReader->GetEventID());  \r
 577   \r
 578   if ( fEventID[fBufferTopIdx] == eventID ) {\r
 579     HLTInfo(Form("Event 0x%016LX (%Lu) already in buffer.", eventID, eventID));\r
 580     return;\r
 581   }\r
 582 \r
 583   // -- Check if event should be selected on basis of trigger string\r
 584   if( fTriggerString.CompareTo("ALL") ){\r
 585     if ( !CheckTriggerDecision() ) {\r
 586       HLTInfo(Form("Event 0x%016LX (%Lu) is not triggered by %s.", \r
 587                    eventID, eventID, fTriggerString.Data()));\r
 588       return;\r
 589     }\r
 590   }\r
 591   else {\r
 592     HLTInfo("No trigger selection.");\r
 593   }\r
 594 \r
 595   // -- Set Top mark \r
 596   ++fBufferTopIdx;\r
 597   if ( fBufferTopIdx == BUFFERSIZE )\r
 598     fBufferTopIdx = 0;\r
 599 \r
 600   // -- Change the low mark if necessary\r
 601   if ( fBufferLowIdx == -1 )\r
 602     fBufferLowIdx = 0;\r
 603   else if ( fBufferTopIdx == fBufferLowIdx ) {\r
 604     ++fBufferLowIdx;\r
 605     if ( fBufferLowIdx == BUFFERSIZE )\r
 606       fBufferLowIdx = 0;\r
 607   }\r
 608 \r
 609   fNavigateBufferIdx = fCurrentBufferIdx = fBufferTopIdx;    \r
 610 \r
 611   // -- Fill EventID\r
 612   fEventID[fBufferTopIdx] = eventID;\r
 613 \r
 614   // -- Clear Buffer slot\r
 615   (reinterpret_cast<TList*>((*fEventBuffer)[fBufferTopIdx]))->Clear();\r
 616 \r
 617 \r
 618   GetFirstBlk();\r
 619 \r
 620   // -- Fill block list\r
 621   do {\r
 622 \r
 623     // -- Create new block\r
 624     AliHLTHOMERBlockDesc * block = new AliHLTHOMERBlockDesc();\r
 625     block->SetBlock( GetBlk(), GetBlkSize(), GetBlkOrigin(),\r
 626                      GetBlkType(), GetBlkSpecification() );\r
 627     \r
 628     // -- Check sources list if block is requested\r
 629     if ( CheckIfRequested( block ) ) {\r
 630       (reinterpret_cast<TList*>((*fEventBuffer)[fBufferTopIdx]))->Add( block );\r
 631     }\r
 632     else {\r
 633       // XXX HACK Jochen\r
 634       (reinterpret_cast<TList*>((*fEventBuffer)[fBufferTopIdx]))->Add( block );\r
 635       // delete block;\r
 636       // block = NULL;\r
 637     }\r
 638  \r
 639   } while( GetNextBlk() );\r
 640 \r
 641   return;\r
 642 }\r
 643 \r
 644 //##################################################################################\r
 645 void AliHLTHOMERManager::AddToAsyncBlockList() {\r
 646   // see header file for class documentation\r
 647 \r
 648   HLTInfo("Adding blocks to the asynchroneous block list");\r
 649 \r
 650 \r
 651   GetFirstBlk();\r
 652 \r
 653   // -- Fill block list\r
 654   do {\r
 655     \r
 656 \r
 657     // -- Create new block\r
 658     AliHLTHOMERBlockDesc * block = new AliHLTHOMERBlockDesc();\r
 659     block->SetBlock( GetBlk(), GetBlkSize(), GetBlkOrigin(),\r
 660                      GetBlkType(), GetBlkSpecification() );\r
 661     \r
 662     // -- Check sources list if block is requested\r
 663     if ( CheckIfRequested( block ) ) \r
 664       fAsyncBlockList->Add( block );\r
 665     else {\r
 666       // XXX HACK Jochen\r
 667       fAsyncBlockList->Add( block );\r
 668       // delete block;\r
 669       // block = NULL;\r
 670     }\r
 671  \r
 672   } while( GetNextBlk() );\r
 673 \r
 674   return;\r
 675 }\r
 676 //##################################################################################\r
 677 TList* AliHLTHOMERManager::GetBlockListEventBuffer( Int_t idx ) {\r
 678   // see header file for class documentation\r
 679 \r
 680   if ( idx == -1 )\r
 681     return NULL;\r
 682 \r
 683   return reinterpret_cast<TList*>((*fEventBuffer)[idx]);\r
 684 \r
 685 }\r
 686 \r
 687 /*\r
 688  * ---------------------------------------------------------------------------------\r
 689  *                          Block Handling - private\r
 690  * ---------------------------------------------------------------------------------\r
 691  */\r
 692 \r
 693 //##################################################################################\r
 694 Int_t AliHLTHOMERManager::HandleBlocks() {\r
 695   // see header file for class documentation\r
 696   \r
 697   Int_t iResult = 0;\r
 698 \r
 699   // -- Get blockCnt and eventID\r
 700   fNBlks = static_cast<ULong_t>(fCurrentReader->GetBlockCnt());\r
 701   ULong_t eventID = static_cast<ULong64_t>(fCurrentReader->GetEventID());  \r
 702   fCurrentBlk = 0;\r
 703 \r
 704   // -- Check if blocks present\r
 705   if ( fNBlks ==  0 ) {\r
 706     HLTWarning(Form("Event 0x%016LX (%Lu) with no blocks", eventID, eventID));\r
 707     return -1;\r
 708   }\r
 709 \r
 710   HLTInfo(Form("Event 0x%016LX (%Lu) with %lu blocks", eventID, eventID, fNBlks));\r
 711 \r
 712 #if 1// EVE_DEBUG\r
 713   // Loop for Debug only\r
 714   for ( ULong_t ii = 0; ii < fNBlks; ii++ ) {\r
 715     Char_t tmp1[9], tmp2[5];\r
 716     memset( tmp1, 0, 9 );\r
 717     memset( tmp2, 0, 5 );\r
 718     void *tmp11 = tmp1;\r
 719     ULong64_t* tmp12 = static_cast<ULong64_t*>(tmp11);\r
 720     *tmp12 = fCurrentReader->GetBlockDataType(ii);\r
 721     void *tmp21 = tmp2;\r
 722     ULong_t* tmp22 = static_cast<ULong_t*>(tmp21);\r
 723     *tmp22 = fCurrentReader->GetBlockDataOrigin(ii);\r
 724     HLTInfo(Form( "Block %lu length: %lu - type: %s - origin: %s - spec 0x%08X",\r
 725                   ii, fCurrentReader->GetBlockDataLength(ii), tmp1, tmp2, fCurrentReader->GetBlockDataSpec(ii) ));\r
 726   } // end for ( ULong_t ii = 0; ii < fNBlks; ii++ ) {\r
 727 #endif\r
 728     \r
 729   // -- Check if blocks are from syncronous source\r
 730 \r
 731   if ( IsSyncBlocks() )\r
 732     AddBlockListToBuffer();\r
 733   else\r
 734     AddToAsyncBlockList();\r
 735     \r
 736   return iResult;\r
 737 }\r
 738 \r
 739 //##################################################################################\r
 740 Bool_t AliHLTHOMERManager::IsSyncBlocks() {\r
 741   // see header file for class documentation\r
 742   \r
 743   Bool_t bResult = kFALSE;\r
 744 \r
 745   GetFirstBlk();\r
 746   \r
 747   do {\r
 748   \r
 749           \r
 750     //    if ( !GetBlkType().CompareTo("ALIESDV0") ||\r
 751    \r
 752     if ( !GetBlkType().CompareTo("ALIESDV0")  ||\r
 753          !GetBlkType().CompareTo("CLUSTERS")  ) {\r
 754       \r
 755       bResult = kTRUE;\r
 756       break;\r
 757     \r
 758     }\r
 759     \r
 760     if ( !GetBlkType().CompareTo("ROOTTOBJ") ) {\r
 761       AliHLTHOMERBlockDesc blockDesc;\r
 762       \r
 763       blockDesc.SetBlock( GetBlk(), GetBlkSize(), GetBlkOrigin(),\r
 764                           GetBlkType(), GetBlkSpecification() );\r
 765       if ( !blockDesc.GetClassName().CompareTo("AliHLTGlobalTriggerDecision") ) {\r
 766 \r
 767         bResult = kTRUE;\r
 768         break;\r
 769       }\r
 770     }\r
 771 \r
 772   } while( GetNextBlk() );\r
 773 \r
 774 \r
 775   return bResult;\r
 776 }\r
 777 \r
 778 //##################################################################################\r
 779 void* AliHLTHOMERManager::GetBlk( Int_t ndx ) {\r
 780   // see header file for class documentation\r
 781   // Get pointer to current block in current event\r
 782    \r
 783   if ( !fCurrentReader || !IsConnected() ) {\r
 784     HLTError(Form("Not connected yet."));\r
 785     return NULL;\r
 786   }\r
 787   if ( ndx < static_cast<Int_t>(fNBlks) )\r
 788     return  const_cast<void*> (fCurrentReader->GetBlockData(ndx));\r
 789   else\r
 790     return NULL;\r
 791 }\r
 792 \r
 793 //##################################################################################\r
 794 ULong_t AliHLTHOMERManager::GetBlkSize( Int_t ndx ) {\r
 795   // see header file for class documentation\r
 796    \r
 797   if ( !fCurrentReader || !IsConnected() ) {\r
 798     HLTError(Form("Not connected yet."));\r
 799     return 0;\r
 800   }\r
 801   \r
 802   if ( ndx < static_cast<Int_t>(fNBlks) )\r
 803     return static_cast<ULong_t> (fCurrentReader->GetBlockDataLength(ndx));\r
 804   else\r
 805     return 0;\r
 806 }\r
 807 \r
 808 //##################################################################################\r
 809 TString AliHLTHOMERManager::GetBlkOrigin( Int_t ndx ) {\r
 810   // see header file for class documentation\r
 811 \r
 812   TString origin = "";\r
 813 \r
 814   // -- Check for Connection\r
 815   if ( !fCurrentReader || ! IsConnected() ) {\r
 816     HLTError(Form("Not connected yet."));\r
 817     return origin;\r
 818   }\r
 819 \r
 820   // -- Check block index\r
 821   if ( ndx >= static_cast<Int_t>(fNBlks) ) {\r
 822     HLTError(Form("Block index %d out of range.", ndx ));\r
 823     return origin;\r
 824   }\r
 825 \r
 826   // -- Get origin\r
 827   union{\r
 828     UInt_t data;\r
 829     Char_t array[4];\r
 830   } reverseOrigin;\r
 831 \r
 832   reverseOrigin.data = static_cast<UInt_t>(fCurrentReader->GetBlockDataOrigin(ndx));\r
 833 \r
 834   // -- Reverse the order\r
 835   for (Int_t ii = 3; ii >= 0; ii-- )\r
 836     if ( reverseOrigin.array[ii] != ' ')\r
 837       origin.Append( reverseOrigin.array[ii] );\r
 838 \r
 839   origin.Remove( TString::kTrailing, ' ' );\r
 840 \r
 841   return origin;\r
 842 }\r
 843 \r
 844 //##################################################################################\r
 845 TString AliHLTHOMERManager::GetBlkType( Int_t ndx ) {\r
 846   // see header file for class documentation\r
 847 \r
 848   TString type = "";\r
 849 \r
 850   // -- Check for Connection\r
 851   if ( !fCurrentReader || ! IsConnected() ) {\r
 852     HLTError(Form("Not connected yet."));\r
 853     return type;\r
 854   }\r
 855 \r
 856   // -- Check block index\r
 857   if ( ndx >= static_cast<Int_t>(fNBlks) ) {\r
 858     HLTError(Form("Block index %d out of range.", ndx ));\r
 859     return type;\r
 860   }\r
 861 \r
 862   // -- Get type\r
 863   union{\r
 864     ULong64_t data;\r
 865     Char_t array[8];\r
 866   } reverseType;\r
 867 \r
 868   reverseType.data = static_cast<ULong64_t> (fCurrentReader->GetBlockDataType(ndx));\r
 869 \r
 870   // -- Reverse the order\r
 871   for (Int_t ii = 7; ii >= 0; ii-- )\r
 872     if ( reverseType.array[ii] != ' ')\r
 873       type.Append( reverseType.array[ii] );\r
 874   \r
 875   type.Remove( TString::kTrailing, ' ' );\r
 876 \r
 877   return type;\r
 878 }\r
 879 \r
 880 //##################################################################################\r
 881 ULong_t AliHLTHOMERManager::GetBlkSpecification( Int_t ndx ) {\r
 882   // see header file for class documentation\r
 883 \r
 884   // -- Check for Connection\r
 885   if ( !fCurrentReader || ! IsConnected() ) {\r
 886     HLTError(Form("Not connected yet."));\r
 887     return 0;\r
 888   }\r
 889 \r
 890   // -- Check block index\r
 891   if ( ndx >= static_cast<Int_t>(fNBlks) ) {\r
 892     HLTError(Form("Block index %d out of range.", ndx ));\r
 893     return 0;\r
 894   }\r
 895 \r
 896   return static_cast<ULong_t>(fCurrentReader->GetBlockDataSpec(ndx));\r
 897 }\r
 898 \r
 899 //##################################################################################\r
 900 Bool_t AliHLTHOMERManager::CheckIfRequested( AliHLTHOMERBlockDesc * block ) {\r
 901   // see header file for class documentation\r
 902 \r
 903   Bool_t requested = kFALSE;\r
 904 \r
 905   AliHLTHOMERSourceDesc * source= NULL;\r
 906 \r
 907   // -- Read all sources and check if they should be read out\r
 908   TIter next( fSourceList );\r
 909   while ( ( source = dynamic_cast<AliHLTHOMERSourceDesc*>(next()) ) ) {\r
 910     \r
 911     // -- Check if source is selected\r
 912     if ( ! source->IsSelected() )\r
 913       continue;\r
 914     \r
 915     // -- Check if detector matches\r
 916     if ( source->GetSourceName().CompareTo( block->GetBlockName() ) )\r
 917       continue;\r
 918 \r
 919     requested = kTRUE;\r
 920     break;\r
 921 \r
 922   } // while ( ( source = dynamic_cast<AliHLTHOMERSourceDesc*>(next()) ) ) {\r
 923   \r
 924 #if EVE_DEBUG\r
 925   if ( requested ) {\r
 926     HLTInfo(Form("Block requested : %s", block->GetBlockName().Data())); \r
 927   }\r
 928   else {\r
 929     HLTInfo(Form("Block NOT requested : %s", block->GetBlockName().Data())); \r
 930   }\r
 931 #endif\r
 932 \r
 933   return requested;\r
 934 }\r
 935 \r
 936 /* ---------------------------------------------------------------------------------\r
 937  *                          Trigger Handling - private\r
 938  * ---------------------------------------------------------------------------------\r
 939  */\r
 940 \r
 941 //##################################################################################\r
 942 Bool_t AliHLTHOMERManager::CheckTriggerDecision() {\r
 943   // see header file for class documentation\r
 944 \r
 945   Bool_t triggered = kFALSE;\r
 946 \r
 947   if ( !fCurrentReader || !IsConnected() ) {\r
 948     HLTError(Form("Not connected yet."));\r
 949     return NULL;\r
 950   }\r
 951 \r
 952   AliHLTHOMERBlockDesc blockDesc;\r
 953 \r
 954   GetFirstBlk();\r
 955   \r
 956   // -- Fill block list\r
 957   Bool_t foundTriggerBlock = kFALSE;\r
 958   \r
 959   do {\r
 960     if ( (GetBlkType().CompareTo("ROOTTOBJ") == 0) ) {\r
 961       blockDesc.SetBlock( GetBlk(), GetBlkSize(), GetBlkOrigin(),\r
 962                           GetBlkType(), GetBlkSpecification() );\r
 963 \r
 964       if ( ! blockDesc.GetClassName().CompareTo("AliHLTGlobalTriggerDecision") ) {\r
 965 \r
 966         foundTriggerBlock = kTRUE;\r
 967         break;\r
 968       }\r
 969       \r
 970     }\r
 971   } while( GetNextBlk() );\r
 972   \r
 973   if ( !foundTriggerBlock ) {\r
 974     HLTError(Form("No trigger decision object found"));\r
 975     return kFALSE;\r
 976   }\r
 977 \r
 978   // -- Get the global decision object\r
 979   AliHLTGlobalTriggerDecision* globalDecision = \r
 980     static_cast<AliHLTGlobalTriggerDecision*>(blockDesc.GetTObject());\r
 981 \r
 982   if ( fTriggerString.CompareTo("HLTGlobalTrigger") == 0 ) {\r
 983     triggered = globalDecision->EventTriggered();\r
 984   } \r
 985   else {\r
 986     \r
 987     for (Int_t idx = 0; idx < globalDecision->NumberOfInputObjects(); idx++) {\r
 988        \r
 989       const AliHLTTriggerDecision* triggerDecision = \r
 990         reinterpret_cast<const AliHLTTriggerDecision*>(globalDecision->InputObject(idx));\r
 991     \r
 992       if ( !(fTriggerString.CompareTo(triggerDecision->Description())) ) {\r
 993         triggered = triggerDecision->EventTriggered();\r
 994         break;\r
 995       }\r
 996     } // for (Int_t idx = 0; idx < globalDecision->NumberOfInputObjects(); idx++) {\r
 997   }\r
 998 \r
 999 \r
1000 \r
1001   if ( triggered ) {\r
1002     fRetryNextEvent = kFALSE;\r
1003     fNEventsNotTriggered = 0;\r
1004   }\r
1005   else {\r
1006     fRetryNextEvent = kTRUE;\r
1007     ++fNEventsNotTriggered;\r
1008   }\r
1009 \r
1010   return triggered;\r
1011 }\r