HLT/trigger/AliHLTGlobalTriggerComponent.cxx

   1 // $Id$
   2 /**************************************************************************
   3  * This file is property of and copyright by the ALICE HLT Project        *
   4  * ALICE Experiment at CERN, All rights reserved.                         *
   5  *                                                                        *
   6  * Primary Authors: Artur Szostak <artursz@iafrica.com>                   *
   7  *                  for The ALICE HLT Project.                            *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 /// @file   AliHLTGlobalTriggerComponent.cxx
  19 /// @author Artur Szostak <artursz@iafrica.com>
  20 /// @date   26 Nov 2008
  21 /// @brief  Implementation of the AliHLTGlobalTriggerComponent component class.
  22 ///
  23 /// The AliHLTGlobalTriggerComponent class applies the global HLT trigger to all
  24 /// trigger information produced by components deriving from AliHLTTrigger.
  25
  26 #include "AliHLTGlobalTriggerComponent.h"
  27 #include "AliHLTGlobalTriggerDecision.h"
  28 #include "AliHLTGlobalTrigger.h"
  29 #include "AliHLTGlobalTriggerConfig.h"
  30 #include "AliHLTTriggerMenu.h"
  31 #include "AliHLTCTPData.h"
  32 #include "AliCDBManager.h"
  33 #include "AliCDBStorage.h"
  34 #include "AliCDBEntry.h"
  35 #include "AliRawDataHeader.h"
  36 #include "TUUID.h"
  37 #include "TROOT.h"
  38 #include "TSystem.h"
  39 #include "TRegexp.h"
  40 #include "TClonesArray.h"
  41 #include "TObjString.h"
  42 #include "TString.h"
  43 #include "TInterpreter.h"
  44 #include "TDatime.h"
  45 #include "TClass.h"
  46 #include "TNamed.h"
  47 #include <fstream>
  48 #include <cerrno>
  49 #include <cassert>
  50 #include <vector>
  51 #include <algorithm>
  52
  53 ClassImp(AliHLTGlobalTriggerComponent)
  54
  55 const char* AliHLTGlobalTriggerComponent::fgkTriggerMenuCDBPath = "HLT/ConfigHLT/HLTGlobalTrigger";
  56
  57
  58 namespace
  59 {
  60   /**
  61    * This method is used as a comparison functor with the STL sort routines.
  62    */
  63   bool AliHLTDescendingNumbers(UInt_t a, UInt_t b)
  64   {
  65     return a > b;
  66   }
  67 } // end of namespace
  68
  69
  70 AliHLTGlobalTriggerComponent::AliHLTGlobalTriggerComponent() :
  71         AliHLTTrigger(),
  72         fTrigger(NULL),
  73         fDebugMode(false),
  74         fRuntimeCompile(true),
  75         fDeleteCodeFile(false),
  76         fMakeSoftwareTriggers(true),
  77         fCodeFileName(),
  78         fClassName(),
  79         fCTPDecisions(NULL),
  80         fBufferSizeConst(2*(sizeof(AliHLTGlobalTriggerDecision) + sizeof(AliHLTReadoutList))),
  81         fBufferSizeMultiplier(1.),
  82         fIncludePaths(TObjString::Class()),
  83         fIncludeFiles(TObjString::Class()),
  84         fLibStateAtLoad(),
  85         fBits(0),
  86         fDataEventsOnly(true),
  87         fMonitorPeriod(-1),
  88         fUniqueID(0),
  89         fSoftwareTrigger(true, "SOFTWARE"),
  90         fTotalEventCounter(0)
  91 {
  92   // Default constructor.
  93
  94   ClearInfoForNewEvent(false);
  95 }
  96
  97
  98 AliHLTGlobalTriggerComponent::~AliHLTGlobalTriggerComponent()
  99 {
 100   // Default destructor.
 101
 102   if (fTrigger != NULL) delete fTrigger;
 103
 104   if (fCTPDecisions) {
 105     fCTPDecisions->Delete();
 106     delete fCTPDecisions;
 107   }
 108 }
 109
 110
 111 void AliHLTGlobalTriggerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& list) const
 112 {
 113   // Returns the kAliHLTDataTypeGlobalTrigger type as output.
 114   list.push_back(kAliHLTDataTypeGlobalTrigger);
 115 }
 116
 117
 118 void AliHLTGlobalTriggerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
 119 {
 120   // Returns the output data size estimate.
 121
 122   constBase = fBufferSizeConst;
 123   inputMultiplier = fBufferSizeMultiplier;
 124 }
 125
 126
 127 Int_t AliHLTGlobalTriggerComponent::DoInit(int argc, const char** argv)
 128 {
 129   // Initialises the global trigger component.
 130
 131   fDebugMode = false;
 132   fClassName = "";
 133   fCodeFileName = "";
 134   fDeleteCodeFile = false;
 135   fMakeSoftwareTriggers = true;
 136   const char* configFileName = NULL;
 137   const char* codeFileName = NULL;
 138   fIncludePaths.Clear();
 139   fIncludeFiles.Clear();
 140   SetBit(kIncludeInput);
 141   fDataEventsOnly = true;
 142
 143   for (int i = 0; i < argc; i++)
 144   {
 145     if (strcmp(argv[i], "-config") == 0)
 146     {
 147       if (configFileName != NULL)
 148       {
 149         HLTWarning("Trigger configuration macro was already specified."
 150                    " Will replace previous value given by -config."
 151         );
 152       }
 153       if (argc <= i+1)
 154       {
 155         HLTError("The trigger configuration macro filename was not specified." );
 156         return -EINVAL;
 157       }
 158       configFileName = argv[i+1];
 159       i++;
 160       continue;
 161     }
 162
 163     if (strcmp(argv[i], "-includepath") == 0)
 164     {
 165       if (argc <= i+1)
 166       {
 167         HLTError("The include path was not specified." );
 168         return -EINVAL;
 169       }
 170       try
 171       {
 172         new (fIncludePaths[fIncludePaths.GetEntriesFast()]) TObjString(argv[i+1]);
 173       }
 174       catch (const std::bad_alloc&)
 175       {
 176         HLTError("Could not allocate more memory for the fIncludePaths array.");
 177         return -ENOMEM;
 178       }
 179       i++;
 180       continue;
 181     }
 182
 183     if (strcmp(argv[i], "-include") == 0)
 184     {
 185       if (argc <= i+1)
 186       {
 187         HLTError("The include file name was not specified." );
 188         return -EINVAL;
 189       }
 190       try
 191       {
 192         new (fIncludeFiles[fIncludeFiles.GetEntriesFast()]) TObjString(argv[i+1]);
 193       }
 194       catch (const std::bad_alloc&)
 195       {
 196         HLTError("Could not allocate more memory for the fIncludeFiles array.");
 197         return -ENOMEM;
 198       }
 199       i++;
 200       continue;
 201     }
 202
 203     if (strcmp(argv[i], "-debug") == 0)
 204     {
 205       if (fDebugMode == true)
 206       {
 207         HLTWarning("The debug flag was already specified. Ignoring this instance.");
 208       }
 209       fDebugMode = true;
 210       continue;
 211     }
 212
 213     if (strcmp(argv[i], "-cint") == 0)
 214     {
 215       fRuntimeCompile = false;
 216       continue;
 217     }
 218
 219     if (strcmp(argv[i], "-usecode") == 0)
 220     {
 221       if (codeFileName != NULL)
 222       {
 223         HLTWarning("Custom trigger code file was already specified."
 224                    " Will replace previous value given by -usecode."
 225         );
 226       }
 227       if (argc <= i+1)
 228       {
 229         HLTError("The custom trigger code filename was not specified." );
 230         return -EINVAL;
 231       }
 232       codeFileName = argv[i+1];
 233       if (argc <= i+2)
 234       {
 235         HLTError("The custom trigger class name was not specified." );
 236         return -EINVAL;
 237       }
 238       fClassName = argv[i+2];
 239       i += 2;
 240       continue;
 241     }
 242
 243     if (strcmp(argv[i], "-skipctp") == 0)
 244     {
 245       HLTInfo("Skipping CTP counters in trigger decision");
 246       SetBit(kSkipCTP);
 247       continue;
 248     }
 249
 250     if (strcmp(argv[i], "-forward-input") == 0)
 251     {
 252       HLTInfo("Forwarding input objects and trigger decisions");
 253       SetBit(kForwardInput);
 254       SetBit(kIncludeShort);
 255       SetBit(kIncludeInput, false);
 256       continue;
 257     }
 258
 259     if (strstr(argv[i], "-include-input") == argv[i])
 260     {
 261       SetBit(kForwardInput,false);
 262       TString param=argv[i];
 263       param.ReplaceAll("-include-input", "");
 264       if (param.CompareTo("=none")==0)
 265       {
 266         HLTInfo("skipping objects and trigger decisions");
 267         SetBit(kIncludeShort, false);
 268         SetBit(kIncludeInput, false);
 269       }
 270       else if (param.CompareTo("=short")==0)
 271       {
 272         HLTInfo("including short info on objects and trigger decisions");
 273         SetBit(kIncludeShort);
 274         SetBit(kIncludeInput, false);
 275       }
 276       else if (param.CompareTo("=both")==0)
 277       {
 278         HLTInfo("including input objects, trigger decisions and short info");
 279         SetBit(kIncludeShort);
 280         SetBit(kIncludeInput);
 281       }
 282       else if (param.CompareTo("=objects")==0 || param.IsNull())
 283       {
 284         HLTInfo("including input objects and trigger decisions");
 285         SetBit(kIncludeShort, false);
 286         SetBit(kIncludeInput);
 287       }
 288       else
 289       {
 290         HLTError("unknown parameter '%s' for argument '-include-input'", param.Data());
 291       }
 292       continue;
 293     }
 294
 295     if (strcmp(argv[i], "-process-all-events") == 0)
 296     {
 297       fDataEventsOnly = false;
 298       continue;
 299     }
 300
 301     if (strstr(argv[i], "-monitoring") == argv[i])
 302     {
 303       TString param=argv[i];
 304       param.ReplaceAll("-monitoring", "");
 305       if (param.IsNull())
 306       {
 307         // -monitoring
 308         // enable monitoring trigger for all events
 309         fMonitorPeriod=0;
 310       } else {
 311         // -monitoring=n
 312         // enable monitoring trigger once every n seconds
 313         param.ReplaceAll("=", "");
 314         if (param.IsDigit()) {
 315           fMonitorPeriod=param.Atoi();
 316         } else {
 317           HLTError("expecting number as parameter for argument '-monitoring=', got %s, skipping monitoring trigger", param.Data());
 318         }
 319       }
 320       continue;
 321     }
 322
 323     if (strcmp(argv[i], "-dont-make-software-triggers") == 0)
 324     {
 325       fMakeSoftwareTriggers = false;
 326       continue;
 327     }
 328
 329     HLTError("Unknown option '%s'.", argv[i]);
 330     return -EINVAL;
 331   } // for loop
 332
 333   const AliHLTTriggerMenu* menu = NULL;
 334   if (configFileName != NULL)
 335   {
 336     TString cmd = ".x ";
 337     cmd += configFileName;
 338     gROOT->ProcessLine(cmd);
 339     menu = AliHLTGlobalTriggerConfig::Menu();
 340   }
 341
 342   // Try load the trigger menu from the CDB if it is not loaded yet with the
 343   // -config option
 344   int result = -ENOENT;
 345   if (menu == NULL)
 346   {
 347     result = LoadTriggerMenu(fgkTriggerMenuCDBPath, menu);
 348   }
 349   if (menu == NULL)
 350   {
 351     HLTError("No trigger menu configuration found or specified.");
 352     return result;
 353   }
 354
 355   if (codeFileName == NULL)
 356   {
 357     result = GenerateTrigger(menu, fClassName, fCodeFileName, fIncludePaths, fIncludeFiles);
 358     if (result == 0) fDeleteCodeFile = true;
 359   }
 360   else
 361   {
 362     result = LoadTriggerClass(codeFileName, fIncludePaths);
 363     if (result == 0) fCodeFileName = codeFileName;
 364   }
 365   if (result != 0) return result;
 366
 367   try
 368   {
 369     fTrigger = AliHLTGlobalTrigger::CreateNew(fClassName.Data());
 370   }
 371   catch (const std::bad_alloc&)
 372   {
 373     HLTError("Could not allocate memory for the AliHLTGlobalTrigger instance.");
 374     return -ENOMEM;
 375   }
 376   if (fTrigger == NULL)
 377   {
 378     HLTError("Could not create a new instance of '%s'.", fClassName.Data());
 379     return -EIO;
 380   }
 381
 382   fTrigger->FillFromMenu(*menu);
 383   if (fTrigger->CallFailed()) return -EPROTO;
 384
 385   // setup the CTP accounting in AliHLTComponent
 386   SetupCTPData();
 387
 388   // Set the default values from the trigger menu.
 389   SetDescription(menu->DefaultDescription());
 390   SetTriggerDomain(menu->DefaultTriggerDomain());
 391
 392   fTotalEventCounter = 0;
 393   return 0;
 394 }
 395
 396
 397 Int_t AliHLTGlobalTriggerComponent::DoDeinit()
 398 {
 399   // Cleans up the global trigger component.
 400
 401   if (fTrigger != NULL)
 402   {
 403     delete fTrigger;
 404     fTrigger = NULL;
 405   }
 406
 407   if (fCTPDecisions) {
 408     fCTPDecisions->Delete();
 409     delete fCTPDecisions;
 410   }
 411   fCTPDecisions=NULL;
 412
 413   Int_t result = UnloadTriggerClass(fCodeFileName);
 414   if (result != 0) return result;
 415
 416   if (fDeleteCodeFile and !fCodeFileName.IsNull() && gSystem->AccessPathName(fCodeFileName)==0 && !fDebugMode) {
 417     fCodeFileName.ReplaceAll(".cxx", "*");
 418     TString command="rm "; command+=fCodeFileName;
 419     gSystem->Exec(command);
 420   }
 421   fCodeFileName="";
 422   fDeleteCodeFile=false;
 423
 424   return 0;
 425 }
 426
 427
 428 AliHLTComponent* AliHLTGlobalTriggerComponent::Spawn()
 429 {
 430   // Creates a new object instance.
 431   AliHLTComponent* comp = NULL;
 432   try
 433   {
 434     comp = new AliHLTGlobalTriggerComponent;
 435   }
 436   catch (const std::bad_alloc&)
 437   {
 438     HLTError("Could not allocate memory for a new instance of AliHLTGlobalTriggerComponent.");
 439     return NULL;
 440   }
 441   return comp;
 442 }
 443
 444
 445 int AliHLTGlobalTriggerComponent::DoTrigger()
 446 {
 447   // This method will apply the global trigger decision.
 448
 449   if (fTrigger == NULL)
 450   {
 451     HLTFatal("Global trigger implementation object is NULL!");
 452     return -EIO;
 453   }
 454
 455   AliHLTUInt32_t eventType=0;
 456   if (!IsDataEvent(&eventType)) {
 457     if (eventType==gkAliEventTypeEndOfRun) PrintStatistics(fTrigger, kHLTLogImportant, 0);
 458     if (fDataEventsOnly)
 459     {
 460       IgnoreEvent();  // dont generate any trigger decision.
 461       return 0;
 462     }
 463   }
 464
 465   // Copy the trigger counters in case we need to set them back to their original
 466   // value because the PushBack method fails with ENOSPC.
 467   TArrayL64 originalCounters = fTrigger->GetCounters();
 468   if (fTrigger->CallFailed()) return -EPROTO;
 469
 470   fTrigger->NewEvent();
 471   if (fTrigger->CallFailed()) return -EPROTO;
 472
 473   // Fill in the input data.
 474   const TObject* obj = GetFirstInputObject();
 475   while (obj != NULL)
 476   {
 477     fTrigger->Add(obj, GetDataType(), GetSpecification());
 478     if (fTrigger->CallFailed()) return -EPROTO;
 479     obj = GetNextInputObject();
 480   }
 481
 482   // add trigger decisions for every CTP class
 483   const AliHLTCTPData* pCTPData=CTPData();
 484   if (pCTPData) {
 485     AddCTPDecisions(fTrigger, pCTPData, GetTriggerData());
 486   }
 487
 488   bool softwareTriggerIsValid = FillSoftwareTrigger();
 489   if (softwareTriggerIsValid)
 490   {
 491     fTrigger->Add(&fSoftwareTrigger, kAliHLTDataTypeTriggerDecision, kAliHLTVoidDataSpec);
 492   }
 493
 494   // Calculate the global trigger result and trigger domain, then create and push
 495   // back the new global trigger decision object.
 496   TString description;
 497   AliHLTTriggerDomain triggerDomain;
 498   bool triggerResult = fTrigger->CalculateTriggerDecision(triggerDomain, description);
 499   if (fTrigger->CallFailed()) return -EPROTO;
 500   AliHLTGlobalTriggerDecision decision(
 501       triggerResult,
 502       // The following will cause the decision to be generated with default values
 503       // (set in fTriggerDomain and fDescription) if the trigger result is false.
 504       (triggerResult == true) ? triggerDomain : GetTriggerDomain(),
 505       (triggerResult == true) ? description.Data() : GetDescription()
 506     );
 507
 508   decision.SetUniqueID(fUniqueID);
 509   decision.SetCounters(fTrigger->GetCounters(), fTotalEventCounter+1);
 510   if (fTrigger->CallFailed()) return -EPROTO;
 511
 512   TClonesArray shortInfo(TNamed::Class(), GetNumberOfInputBlocks());
 513
 514   // Add the input objects used to make the global decision.
 515   obj = GetFirstInputObject();
 516   while (obj != NULL)
 517   {
 518     const AliHLTTriggerDecision* intrig = dynamic_cast<const AliHLTTriggerDecision*>(obj);
 519
 520     if (TestBit(kForwardInput)) Forward(obj);
 521
 522     if (TestBit(kIncludeInput))
 523     {
 524       if (intrig != NULL)
 525       {
 526          decision.AddTriggerInput(*intrig);
 527       }
 528       else
 529       {
 530         // The const_cast should be safe in this case because the list of inputObjects
 531         // will be added to the global decision with AddInputObjectRef, which only
 532         // modifies the kCanDelete bit and nothing else.
 533         // This is necessary since GetFirstInputObject only returns const objects.
 534         decision.AddInputObjectRef( const_cast<TObject*>(obj) );
 535       }
 536     }
 537
 538     if (TestBit(kIncludeShort))
 539     {
 540       int entries = shortInfo.GetEntriesFast();
 541       try
 542       {
 543         new (shortInfo[entries]) TNamed(obj->GetName(), obj->GetTitle());
 544       }
 545       catch (const std::bad_alloc&)
 546       {
 547         HLTError("Could not allocate more memory for the short list of input objects.");
 548         return -ENOMEM;
 549       }
 550       if (intrig != NULL)
 551       {
 552         shortInfo[entries]->SetBit(BIT(16)); // indicate that this is a trigger decision
 553         shortInfo[entries]->SetBit(BIT(15), intrig->Result());
 554       }
 555     }
 556
 557     obj = GetNextInputObject();
 558   }
 559   if (TestBit(kIncludeShort)) decision.AddInputObjectRef(&shortInfo);
 560
 561   // The const_cast should be safe in this case because AddInputObjectRef just
 562   // modifies the kCanDelete bit and nothing else.
 563   if (!TestBit(kSkipCTP) && CTPData()) decision.AddInputObjectRef(const_cast<AliHLTCTPData*>(CTPData()));
 564
 565   if (softwareTriggerIsValid and TestBit(kIncludeInput)) decision.AddTriggerInput(fSoftwareTrigger);
 566
 567   static UInt_t lastTime=0;
 568   TDatime time;
 569   if (time.Get()-lastTime>60) {
 570     lastTime=time.Get();
 571     PrintStatistics(fTrigger, kHLTLogImportant);
 572   }
 573
 574   // add readout filter to event done data
 575   CreateEventDoneReadoutFilter(decision.TriggerDomain(), 3);
 576
 577   // add monitoring filter to event done data if enabled by setting
 578   // a monitoring period >=0: -1 means off, 0 means for every event
 579   // configured by argument '-monitoring[=n]'
 580   if (fMonitorPeriod>=0) {
 581     static UInt_t lastMonitorEvent=0;
 582
 583     AliHLTTriggerDomain monitoringFilter(decision.TriggerDomain());
 584     if (decision.Result() &&
 585         int(time.Get()-lastMonitorEvent)>fMonitorPeriod) {
 586       lastMonitorEvent=time.Get();
 587       // add monitoring event command for triggered events
 588       CreateEventDoneReadoutFilter(decision.TriggerDomain(), 5);
 589     } else {
 590       // empty filter list if events are not triggered
 591       // or within the monitoring interval
 592       monitoringFilter.Clear();
 593     }
 594     // add monitoring filter list
 595     CreateEventDoneReadoutFilter(monitoringFilter, 4);
 596   }
 597
 598   if (TriggerEvent(&decision, kAliHLTDataTypeGlobalTrigger) == -ENOSPC)
 599   {
 600     // Increase the estimated buffer space required if the PushBack methods in TriggerEvent
 601     // returned the "no buffer space" error code. Also remember to set the trigger counters
 602     // back to what they were, otherwise triggers will be double counted when we try to reprocess
 603     // this event with larger buffers.
 604     fBufferSizeConst += 1024*1024;
 605     fBufferSizeMultiplier *= 2.;
 606     fTrigger->SetCounters(originalCounters);
 607     if (fTrigger->CallFailed()) return -EPROTO;
 608     return -ENOSPC;
 609   }
 610
 611   ++fTotalEventCounter;
 612   return 0;
 613 }
 614
 615
 616 int AliHLTGlobalTriggerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
 617 {
 618   // Reconfigure the component by loading the trigger menu and recreating the
 619   // trigger logic class.
 620
 621   const char* path = fgkTriggerMenuCDBPath;
 622   const char* id = "(unknown)";
 623   if (cdbEntry != NULL) path = cdbEntry;
 624   if (chainId != NULL and chainId[0] != '\0') id = chainId;
 625   HLTInfo("Reconfiguring from '%s' for chain component '%s'.", path, id);
 626
 627   const AliHLTTriggerMenu* menu = NULL;
 628   int result = LoadTriggerMenu(path, menu);
 629   if (result != 0) return result;
 630
 631   TString className;
 632   TString codeFileName;
 633   result = GenerateTrigger(menu, className, codeFileName, fIncludePaths, fIncludeFiles);
 634   if (result != 0) return result;
 635
 636   AliHLTGlobalTrigger* trigger = NULL;
 637   try
 638   {
 639     trigger = AliHLTGlobalTrigger::CreateNew(className.Data());
 640   }
 641   catch (const std::bad_alloc&)
 642   {
 643     HLTError("Could not allocate memory for the AliHLTGlobalTrigger instance.");
 644     return -ENOMEM;
 645   }
 646   if (trigger == NULL)
 647   {
 648     HLTError("Could not create a new instance of '%s'.", className.Data());
 649     // Make sure to cleanup after the new code file.
 650     UnloadTriggerClass(codeFileName);
 651     if (not codeFileName.IsNull() and gSystem->AccessPathName(codeFileName)==0 and not fDebugMode)
 652     {
 653       codeFileName.ReplaceAll(".cxx", "*");
 654       TString command="rm "; command+=codeFileName;
 655       gSystem->Exec(command);
 656     }
 657     return -EIO;
 658   }
 659
 660   if (fTrigger != NULL)
 661   {
 662     delete fTrigger;
 663     fTrigger = NULL;
 664   }
 665
 666   fTrigger = trigger;
 667   fTrigger->FillFromMenu(*menu);
 668   if (fTrigger->CallFailed()) return -EPROTO;
 669
 670   // Set the default values from the trigger menu.
 671   SetDescription(menu->DefaultDescription());
 672   SetTriggerDomain(menu->DefaultTriggerDomain());
 673
 674   // Cleanup the old class code.
 675   UnloadTriggerClass(fCodeFileName);
 676   if (fDeleteCodeFile and not fCodeFileName.IsNull() and gSystem->AccessPathName(fCodeFileName)==0 and not fDebugMode)
 677   {
 678     fCodeFileName.ReplaceAll(".cxx", "*");
 679     TString command="rm "; command+=fCodeFileName;
 680     gSystem->Exec(command);
 681   }
 682   fCodeFileName = codeFileName;
 683   fDeleteCodeFile = true;  // Since we generated a new class.
 684
 685   return 0;
 686 }
 687
 688
 689 int AliHLTGlobalTriggerComponent::LoadTriggerMenu(const char* cdbPath, const AliHLTTriggerMenu*& menu)
 690 {
 691   // Loads the trigger menu object from the CDB path.
 692
 693   HLTDebug("Trying to load trigger menu from '%s'.", cdbPath);
 694   if (AliCDBManager::Instance() == NULL)
 695   {
 696     HLTError("CDB manager object not found.");
 697     return -EIO;
 698   }
 699   AliCDBStorage* store = AliCDBManager::Instance()->GetDefaultStorage();
 700   if (store == NULL)
 701   {
 702     HLTError("Could not get the the default storage for the CDB.");
 703     return -EIO;
 704   }
 705   Int_t version = store->GetLatestVersion(cdbPath, GetRunNo());
 706   Int_t subVersion = store->GetLatestSubVersion(cdbPath, GetRunNo(), version);
 707   AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, GetRunNo(), version, subVersion);
 708   if (entry == NULL)
 709   {
 710     HLTError("Could not get the CDB entry for \"%s\".", cdbPath);
 711     return -EIO;
 712   }
 713   TObject* obj = entry->GetObject();
 714   if (obj == NULL)
 715   {
 716     HLTError("Configuration object for \"%s\" is missing.", cdbPath);
 717     return -ENOENT;
 718   }
 719   if (obj->IsA() != AliHLTTriggerMenu::Class())
 720   {
 721     HLTError("Wrong type for configuration object in \"%s\". Found a %s but we expect a AliHLTTriggerMenu.",
 722              cdbPath, obj->ClassName()
 723     );
 724     return -EPROTO;
 725   }
 726   menu = static_cast<AliHLTTriggerMenu*>(obj);
 727   return 0;
 728 }
 729
 730
 731 void AliHLTGlobalTriggerComponent::GenerateFileName(TString& name, TString& filename)
 732 {
 733   // Creates a unique file name for the generated code.
 734
 735   TUUID guid = GenerateGUID();
 736   union
 737   {
 738     UChar_t buf[16];
 739     UInt_t bufAsInt[4];
 740   };
 741   guid.GetUUID(buf);
 742   fUniqueID = bufAsInt[0];
 743   TString guidstr = guid.AsString();
 744   // Replace '-' with '_' in string.
 745   for (int i = 0; i < guidstr.Length(); ++i)
 746   {
 747     if (guidstr[i] == '-') guidstr[i] = '_';
 748   }
 749   name = "AliHLTGlobalTriggerImpl_";
 750   name += guidstr;
 751   filename = name + ".cxx";
 752
 753   // For good measure, check that the file names are not used. If they are then regenerate.
 754   fstream file(filename.Data(), ios_base::in);
 755   if (file.good())
 756   {
 757     file.close();
 758     GenerateFileName(name, filename);
 759   }
 760 }
 761
 762
 763 int AliHLTGlobalTriggerComponent::GenerateTrigger(
 764     const AliHLTTriggerMenu* menu, TString& name, TString& filename,
 765     const TClonesArray& includePaths, const TClonesArray& includeFiles
 766   )
 767 {
 768   // Generates the global trigger class that will implement the specified trigger menu.
 769   // See header for more details.
 770
 771   GenerateFileName(name, filename);
 772   HLTDebug("Generating custom HLT trigger class named %s, in file %s, using trigger menu %p.",
 773     name.Data(), filename.Data(), ((void*)menu)
 774   );
 775
 776   // Open a text file to write the code and generate the new class.
 777   fstream code(filename.Data(), ios_base::out | ios_base::trunc);
 778   if (not code.good())
 779   {
 780     HLTError("Could not open file '%s' for writing.", filename.Data());
 781     return -EIO;
 782   }
 783
 784   TClonesArray symbols(AliHLTTriggerMenuSymbol::Class());
 785   int result = BuildSymbolList(menu, symbols);
 786   if (result != 0) return result;
 787
 788   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
 789   code << "#include <cstring>" << endl;
 790   code << "#include \"TClass.h\"" << endl;
 791   code << "#include \"TString.h\"" << endl;
 792   code << "#include \"TClonesArray.h\"" << endl;
 793   code << "#include \"AliHLTLogging.h\"" << endl;
 794   code << "#include \"AliHLTGlobalTrigger.h\"" << endl;
 795   code << "#include \"AliHLTGlobalTriggerDecision.h\"" << endl;
 796   code << "#include \"AliHLTDomainEntry.h\"" << endl;
 797   code << "#include \"AliHLTTriggerDomain.h\"" << endl;
 798   code << "#include \"AliHLTReadoutList.h\"" << endl;
 799   code << "#include \"AliHLTTriggerMenu.h\"" << endl;
 800   code << "#include \"AliHLTTriggerMenuItem.h\"" << endl;
 801   code << "#include \"AliHLTTriggerMenuSymbol.h\"" << endl;
 802
 803   // Add any include files that were specified on the command line.
 804   for (Int_t i = 0; i < includeFiles.GetEntriesFast(); i++)
 805   {
 806     TString file = static_cast<TObjString*>(includeFiles.UncheckedAt(i))->String();
 807     code << "#include \"" << file.Data() << "\"" << endl;
 808   }
 809
 810   if (fDebugMode)
 811   {
 812     code << "#else" << endl;
 813     code << "const char* gFunctionName = \"???\";" << endl;
 814     code << "#define HLTDebug(msg) if (CheckFilter(kHLTLogDebug) && CheckGroup(Class_Name())) SendMessage(kHLTLogDebug, Class_Name(), ::gFunctionName, __FILE__, __LINE__, msg)" << endl;
 815   }
 816   code << "#endif" << endl;
 817
 818   code << "class " << name << " :" << endl;
 819   // Add appropriate #ifdef sections since we need to prevent inheritance from
 820   // AliHLTGlobalTrigger. CINT does not seem to support multiple inheritance nor
 821   // multiple levels of inheritance. Neither of the following schemes worked:
 822   //
 823   // 1)  class AliHLTGlobalTrigger : public AliHLTLogging {};
 824   //     class AliHLTGlobalTriggerImpl_xyz : public AliHLTGlobalTrigger {};
 825   //
 826   // 2)  class AliHLTGlobalTrigger {};
 827   //     class AliHLTGlobalTriggerImpl_xyz : public AliHLTGlobalTrigger, public AliHLTLogging {};
 828   //
 829   // Thus, we are forced to just inherit from AliHLTLogging when running in the CINT
 830   // interpreter. But we anyway have to call the global trigger implementation class
 831   // through the AliHLTGlobalTriggerWrapper so this is not such a problem.
 832   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
 833   code << "  public AliHLTGlobalTrigger," << endl;
 834   code << "#endif" << endl;
 835   code << "  public AliHLTLogging" << endl;
 836   code << "{" << endl;
 837   code << "public:" << endl;
 838
 839   // Generate constructor method.
 840   code << "  " << name << "() :" << endl;
 841   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
 842   code << "    AliHLTGlobalTrigger()," << endl;
 843   code << "#endif" << endl;
 844   code << "    AliHLTLogging()";
 845   // Write the symbols in the trigger menu in the initialisation list.
 846   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
 847   {
 848     code << "," << endl;
 849     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
 850     code << "    " << symbol->Name() << "()," << endl;
 851     if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0)
 852     {
 853       code << "    " << symbol->Name() << "TriggerDomain()," << endl;
 854     }
 855     code << "    " << symbol->Name() << "DomainEntry(kAliHLTAnyDataType)";
 856   }
 857   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
 858   {
 859     code << "," << endl << "    fMenuItemDescription" << i << "()";
 860   }
 861   code << endl << "  {" << endl;
 862   if (fDebugMode)
 863   {
 864     code << "#ifdef __CINT__" << endl;
 865     code << "    gFunctionName = \"" << name.Data() <<"\";" << endl;
 866     code << "#endif" << endl;
 867     code << "    SetLocalLoggingLevel(kHLTLogAll);" << endl;
 868     code << "    HLTDebug(Form(\"Creating new instance at %p.\", this));" << endl;
 869   }
 870   code << "  }" << endl;
 871
 872   code << "  virtual ~" << name << "() {" << endl;
 873   if (fDebugMode)
 874   {
 875     code << "#ifdef __CINT__" << endl;
 876     code << "    gFunctionName = \"~" << name.Data() << "\";" << endl;
 877     code << "#endif" << endl;
 878     code << "    HLTDebug(Form(\"Deleting instance at %p.\", this));" << endl;
 879   }
 880   code << "  }" << endl;
 881
 882   // Generate the FillFromMenu method.
 883   code << "  virtual void FillFromMenu(const AliHLTTriggerMenu& menu) {" << endl;
 884   if (fDebugMode)
 885   {
 886     code << "#ifdef __CINT__" << endl;
 887     code << "    gFunctionName = \"FillFromMenu\";" << endl;
 888     code << "#endif" << endl;
 889     code << "    HLTDebug(Form(\"Filling description entries from trigger menu for global trigger %p.\", this));" << endl;
 890   }
 891   code << "    fCounter.Set(menu.NumberOfItems());" << endl;
 892   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
 893   {
 894     code << "    fMenuItemDescription" << i << " = (menu.Item(" << i
 895          << ") != NULL) ? menu.Item(" << i << ")->Description() : \"\";" << endl;
 896   }
 897   if (fDebugMode)
 898   {
 899     code << "    HLTDebug(Form(\"Finished filling description entries from trigger menu.\"));" << endl;
 900     code << "    HLTDebug(Form(\"Filling domain entries from trigger menu symbols for global trigger %p.\", this));" << endl;
 901   }
 902   code << "    for (Int_t i = 0; i < menu.SymbolArray().GetEntriesFast(); i++) {" << endl;
 903   // 30 Oct 2009 - CINT sometimes evaluates the dynamic_cast incorrectly.
 904   // Have to use the TClass system for extra protection.
 905   code << "      if (menu.SymbolArray().UncheckedAt(i) == NULL) continue;" << endl;
 906   code << "      if (menu.SymbolArray().UncheckedAt(i)->IsA() != AliHLTTriggerMenuSymbol::Class()) continue;" << endl;
 907   code << "      const AliHLTTriggerMenuSymbol* symbol = dynamic_cast<const"
 908            " AliHLTTriggerMenuSymbol*>(menu.SymbolArray().UncheckedAt(i));" << endl;
 909   code << "      if (symbol == NULL) continue;" << endl;
 910   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
 911   {
 912     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
 913     code << "      if (strcmp(symbol->RealName(), \"" << symbol->RealName() << "\") == 0) {" << endl;
 914     if (fDebugMode)
 915     {
 916       code << "        HLTDebug(Form(\"Assinging domain entry value corresponding with symbol '%s' to '%s'.\","
 917               " symbol->RealName(), symbol->BlockType().AsString().Data()));" << endl;
 918     }
 919     code << "        " << symbol->Name() << "DomainEntry = symbol->BlockType();" << endl;
 920     code << "        continue;" << endl;
 921     code << "      }" << endl;
 922   }
 923   code << "    }" << endl;
 924   // The following is an optimisation where symbols without any assignment operators
 925   // are treated as constant and only initialised in FillFromMenu rather than reseting
 926   // them in the NewEvent method.
 927   // Note: we putting this initialisation into the constructor can lead to seg faults
 928   // under CINT interpretation. Thus we must put it into the FillFromMenu method instead.
 929   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
 930   {
 931     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
 932     if (TString(symbol->AssignExpression()) != "") continue;
 933     if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0) continue;
 934     // CINT has problems with the implicit equals operator for complex types, so if
 935     // the type has an equals operater we need to write the operator call explicitly.
 936     TClass* clas = TClass::GetClass(symbol->Type());
 937     if (clas != NULL and clas->GetMethodAny("operator=") != NULL)
 938     {
 939       code << "    " << symbol->Name() << ".operator = (" << symbol->DefaultValue() << ");" << endl;
 940     }
 941     else
 942     {
 943       code << "    " << symbol->Name() << " = " << symbol->DefaultValue() << ";" << endl;
 944     }
 945   }
 946   if (fDebugMode)
 947   {
 948     code << "    HLTDebug(Form(\"Finished filling domain entries from trigger menu symbols.\"));" << endl;
 949   }
 950   code << "  }" << endl;
 951
 952   // Generate the NewEvent method.
 953   code << "  virtual void NewEvent() {" << endl;
 954   if (fDebugMode)
 955   {
 956     code << "#ifdef __CINT__" << endl;
 957     code << "    gFunctionName = \"NewEvent\";" << endl;
 958     code << "#endif" << endl;
 959     code << "    HLTDebug(Form(\"New event for global trigger object %p, initialising variables to default values.\", this));" << endl;
 960   }
 961   // Write code to initialise the symbols in the trigger menu to their default values.
 962   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
 963   {
 964     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
 965     // The following is an optimisation. If the symbol does not have an assignment expression
 966     // then it is effectively a constant symbol and can be initialised earlier and only once.
 967     // In this case we initialise it in the FillFromMenu method instead.
 968     if (TString(symbol->AssignExpression()) == "") continue;
 969     // CINT has problems with the implicit equals operator for complex types, so if
 970     // the type has an equals operater we need to write the operator call explicitly.
 971     TClass* clas = TClass::GetClass(symbol->Type());
 972     if (clas != NULL and clas->GetMethodAny("operator=") != NULL)
 973     {
 974       code << "    " << symbol->Name() << ".operator = (" << symbol->DefaultValue() << ");" << endl;
 975     }
 976     else
 977     {
 978       code << "    " << symbol->Name() << " = " << symbol->DefaultValue() << ";" << endl;
 979     }
 980     if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0)
 981     {
 982       code << "    " << symbol->Name() << "TriggerDomain.Clear();" << endl;
 983     }
 984   }
 985   if (fDebugMode)
 986   {
 987     code << "    HLTDebug(Form(\"Finished initialising variables.\"));" << endl;
 988   }
 989   code << "  }" << endl;
 990
 991   // Generate the Add method.
 992   bool haveAssignments = false;
 993   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
 994   {
 995     // First check if we have any symbols with assignment expressions.
 996     // This is needed to get rid of the on the fly compilation warning about '_object_' not being used.
 997     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
 998     TString expr = symbol->AssignExpression();
 999     if (expr == "") continue; // Skip entries that have no assignment expression.
1000     haveAssignments = true;
1001     break;
1002   }
1003   if (haveAssignments or fDebugMode)
1004   {
1005     code << "  virtual void Add(const TObject* _object_, const AliHLTComponentDataType& _type_, AliHLTUInt32_t _spec_) {" << endl;
1006   }
1007   else
1008   {
1009     code << "  virtual void Add(const TObject* /*_object_*/, const AliHLTComponentDataType& _type_, AliHLTUInt32_t _spec_) {" << endl;
1010   }
1011   if (fDebugMode)
1012   {
1013     code << "#ifdef __CINT__" << endl;
1014     code << "    gFunctionName = \"Add\";" << endl;
1015     code << "#endif" << endl;
1016   }
1017   code << "    AliHLTDomainEntry _type_spec_(_type_, _spec_);" << endl;
1018   if (fDebugMode)
1019   {
1020     code << "    HLTDebug(Form(\"Adding TObject %p, with class name '%s' from data block"
1021             " '%s', to global trigger object %p\", _object_, _object_->ClassName(),"
1022             " _type_spec_.AsString().Data(), this));" << endl;
1023     code << "    _object_->Print();" << endl;
1024     code << "    bool _object_assigned_ = false;" << endl;
1025   }
1026   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
1027   {
1028     // Write code to check if the block type, specification and class name is correct.
1029     // Then write code to assign the variable from the input object.
1030     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
1031     TString expr = symbol->AssignExpression();
1032     if (expr == "") continue; // Skip entries that have no assignment expression.
1033     bool isTrigDecision = strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0;
1034     if (fDebugMode)
1035     {
1036       if (isTrigDecision)
1037       {
1038         code << "    HLTDebug(Form(\"Trying to match input object to class '"
1039              << symbol->ObjectClass() << "', trigger name '" << symbol->RealName()
1040              << "' and block type '%s'\", " << symbol->Name()
1041              << "DomainEntry.AsString().Data()));" << endl;
1042       }
1043       else
1044       {
1045         code << "    HLTDebug(Form(\"Trying to match input object to class '"
1046              << symbol->ObjectClass() << "' and block type '%s'\", "
1047              << symbol->Name() << "DomainEntry.AsString().Data()));" << endl;
1048       }
1049     }
1050     // 30 Oct 2009 - CINT sometimes evaluates the dynamic_cast incorrectly.
1051     // Have to use the TClass system for extra protection.
1052     code << "    const " << symbol->ObjectClass() << "* " << symbol->Name() << "_object_ = NULL;" << endl;
1053     code << "    if (_object_->InheritsFrom(" << symbol->ObjectClass() << "::Class())) " << symbol->Name()
1054          << "_object_ = dynamic_cast<const " << symbol->ObjectClass()
1055          << "*>(_object_);" << endl;
1056     code << "    if (" << symbol->Name() << "_object_ != NULL && ";
1057     if (isTrigDecision)
1058     {
1059       code << "strcmp(" << symbol->Name() << "_object_->Name(), \""
1060            << symbol->RealName() << "\") == 0 && ";
1061     }
1062     code << symbol->Name() << "DomainEntry == _type_spec_) {" << endl;
1063     TString fullname = symbol->Name();
1064     fullname += "_object_";
1065     expr.ReplaceAll("this", fullname);
1066     code << "      this->" << symbol->Name() << " = " << expr.Data() << ";" << endl;
1067     if (isTrigDecision)
1068     {
1069       code << "      this->" << symbol->Name() << "TriggerDomain = "
1070            << fullname.Data() << "->TriggerDomain();" << endl;
1071     }
1072     if (fDebugMode)
1073     {
1074       code << "      HLTDebug(Form(\"Added TObject %p with class name '%s' to variable "
1075            << symbol->Name() << "\", _object_, _object_->ClassName()));" << endl;
1076       code << "      _object_assigned_ = true;" << endl;
1077     }
1078     code << "    }" << endl;
1079   }
1080   if (fDebugMode)
1081   {
1082     code << "    if (! _object_assigned_) {" << endl;
1083     code << "      HLTDebug(Form(\"Did not assign TObject %p"
1084             " with class name '%s' to any variable.\", _object_, _object_->ClassName()));"
1085          << endl;
1086     code << "    }" << endl;
1087   }
1088   code << "  }" << endl;
1089
1090   // Generate the CalculateTriggerDecision method.
1091   // This requires code to be generated that checks which items in the trigger menu
1092   // have their conditions asserted and then the trigger domain is generated from
1093   // those fired items.
1094   // The processing will start from the highest priority trigger group and stop
1095   // after at least one trigger from the current priority group being processed
1096   // is positive. For each priority group all the trigger menu items are checked.
1097   // Their combined trigger condition expression must be true for the trigger priority
1098   // group to be triggered positive. The full condition expression is formed by
1099   // concatenating the individual condition expressions. If no trailing operators are
1100   // used in the individual expressions then the default condition operator is placed
1101   // between two concatenated condition expressions.
1102   // If a trigger priority group has at least one trigger fired then the trigger domain
1103   // is calculated such that it will give the same result as the concatenated trigger
1104   // domain merging expressions for all the individual trigger menu items with
1105   // positive results. Again, if no trailing operators are used in the individual
1106   // merging expressions then the default domain operator is placed between two
1107   // expression fragments.
1108   code << "  virtual bool CalculateTriggerDecision(AliHLTTriggerDomain& _domain_, TString& _description_) {" << endl;
1109   if (fDebugMode)
1110   {
1111     code << "#ifdef __CINT__" << endl;
1112     code << "    gFunctionName = \"CalculateTriggerDecision\";" << endl;
1113     code << "#endif" << endl;
1114     code << "    HLTDebug(Form(\"Calculating global HLT trigger result with trigger object at %p.\", this));" << endl;
1115   }
1116
1117   // Build a list of priorities used in the trigger menu.
1118   std::vector<UInt_t> priorities;
1119   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
1120   {
1121     const AliHLTTriggerMenuItem* item = menu->Item(i);
1122     bool priorityNotInList = std::find(priorities.begin(), priorities.end(), item->Priority()) == priorities.end();
1123     if (priorityNotInList) priorities.push_back(item->Priority());
1124   }
1125   std::sort(priorities.begin(), priorities.end(), AliHLTDescendingNumbers);
1126   // From the priority list, build the priority groups in the correct order,
1127   // i.e. highest priority first.
1128   // The priority group is a list of vectors of integers. The integers are the
1129   // index numbers into the trigger menu item list for the items which form part
1130   // of the priority group.
1131   std::vector<std::vector<Int_t> > priorityGroup;
1132   priorityGroup.insert(priorityGroup.begin(), priorities.size(), std::vector<Int_t>());
1133   for (size_t n = 0; n < priorities.size(); n++)
1134   {
1135     UInt_t priority = priorities[n];
1136     for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
1137     {
1138       const AliHLTTriggerMenuItem* item = menu->Item(i);
1139       if (item->Priority() == priority) priorityGroup[n].push_back(i);
1140     }
1141   }
1142
1143   for (size_t n = 0; n < priorityGroup.size(); n++)
1144   {
1145     if (fDebugMode)
1146     {
1147       code << "    HLTDebug(Form(\"Processing trigger priority group " << priorities[n] << "\"));" << endl;
1148     }
1149     code << "    ";
1150     if (n == 0) code << "UInt_t ";
1151     code << "_previous_match_ = 0xFFFFFFFF;" << endl;
1152     code << "    ";
1153     if (n == 0) code << "bool ";
1154     code << "_trigger_matched_ = false;" << endl;
1155     code << "    ";
1156     if (n == 0) code << "bool ";
1157     code << "_group_result_ = false;" << endl;
1158     std::vector<TString> conditionOperator;
1159     conditionOperator.insert(conditionOperator.begin(), priorityGroup[n].size(), TString(""));
1160     std::vector<TString> domainOperator;
1161     domainOperator.insert(domainOperator.begin(), priorityGroup[n].size(), TString(""));
1162     for (size_t m = 0; m < priorityGroup[n].size(); m++)
1163     {
1164       UInt_t i = priorityGroup[n][m];
1165       const AliHLTTriggerMenuItem* item = menu->Item(i);
1166       TString triggerCondition = item->TriggerCondition();
1167       TString mergeExpr = item->MergeExpression();
1168       // Replace the symbols found in the trigger condition and merging expressions
1169       // with appropriate compilable versions.
1170       for (Int_t j = 0; j < symbols.GetEntriesFast(); j++)
1171       {
1172         AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(j) );
1173         bool symbolNamesDifferent = strcmp(symbol->RealName(), symbol->Name()) != 0;
1174         if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0)
1175         {
1176           TString newname = symbol->Name();
1177           newname += "TriggerDomain";
1178           mergeExpr.ReplaceAll(symbol->RealName(), newname);
1179         }
1180         else
1181         {
1182           if (symbolNamesDifferent) mergeExpr.ReplaceAll(symbol->RealName(), symbol->Name());
1183         }
1184         if (symbolNamesDifferent) triggerCondition.ReplaceAll(symbol->RealName(), symbol->Name());
1185       }
1186       // We allow the trigger conditions and merging expressions to have trailing operators.
1187       // Thus, we need to extract the operators and cleanup the expressions so that they will
1188       // compile. This means that we silently ignore the trailing operator if not needed.
1189       if (ExtractedOperator(triggerCondition, conditionOperator[m]))
1190       {
1191         // If the trailing operator is the same as the default operator then reset
1192         // the value in the operator list so that the default is used in the generated
1193         // code. This creates more compact code.
1194         if (conditionOperator[m] == menu->DefaultConditionOperator()) conditionOperator[m] = "";
1195       }
1196       if (ExtractedOperator(mergeExpr, domainOperator[m]))
1197       {
1198         if (domainOperator[m] == menu->DefaultDomainOperator()) domainOperator[m] = "";
1199       }
1200       if (fDebugMode)
1201       {
1202         code << "    HLTDebug(Form(\"Trying trigger condition " << i
1203              << " (Description = '%s').\", fMenuItemDescription" << i << ".Data()));"
1204              << endl;
1205       }
1206       code << "    ";
1207       if (n == 0 and m == 0) code << "bool ";
1208       code << "_item_result_ = false;" << endl;
1209       code << "    if (" << triggerCondition << ") {" << endl;
1210       code << "      ++fCounter[" << i << "];" << endl;
1211       const char* indentation = "";
1212       if (item->PreScalar() != 0)
1213       {
1214         indentation = "  ";
1215         code << "      if ((fCounter[" << i << "] % " << item->PreScalar() << ") == 1) {" << endl;
1216       }
1217       code << indentation << "      _item_result_ = true;" << endl;
1218       if (fDebugMode)
1219       {
1220         code << indentation << "      HLTDebug(Form(\"Matched trigger condition " << i
1221              << " (Description = '%s').\", fMenuItemDescription" << i << ".Data()));" << endl;
1222       }
1223       if (item->PreScalar() != 0)
1224       {
1225         code << "      }" << endl;
1226       }
1227       code << "    }" << endl;
1228       if (m == 0)
1229       {
1230         // Since this is the first item of the trigger group,
1231         // the generated trigger logic can be simplified a little.
1232         code << "    _group_result_ = _item_result_;" << endl;
1233         code << "    if (_item_result_) {" << endl;
1234         code << "      _domain_ = " << mergeExpr.Data() << ";" << endl;
1235         code << "      _description_ = fMenuItemDescription" << i << ";" << endl;
1236         code << "      _previous_match_ = " << i << ";" << endl;
1237         code << "      _trigger_matched_ = true;" << endl;
1238         code << "    }" << endl;
1239       }
1240       else
1241       {
1242         if (conditionOperator[m-1] == "")
1243         {
1244           code << "    _group_result_ = _group_result_ "
1245                << menu->DefaultConditionOperator() << " _item_result_;" << endl;
1246         }
1247         else
1248         {
1249           code << "    _group_result_ = _group_result_ "
1250                << conditionOperator[m-1] << " _item_result_;" << endl;
1251         }
1252         code << "    if (_item_result_) {" << endl;
1253         code << "      if (_trigger_matched_) {" << endl;
1254         bool switchWillBeEmpty = true;
1255         for (size_t k = 0; k < m; k++)
1256         {
1257           if (domainOperator[k] == "") continue;
1258           switchWillBeEmpty = false;
1259         }
1260         if (switchWillBeEmpty)
1261         {
1262           code << "        _domain_ = _domain_ " << menu->DefaultDomainOperator() << " "
1263                << mergeExpr.Data() << ";" << endl;
1264         }
1265         else
1266         {
1267           code << "        switch(_previous_match_) {" << endl;
1268           for (size_t k = 0; k < m; k++)
1269           {
1270             if (domainOperator[k] == "") continue;
1271             code << "        case " << k << ": _domain_ = _domain_ "
1272                  << domainOperator[k] << " " << mergeExpr.Data() << "; break;" << endl;
1273           }
1274           code << "        default: _domain_ = _domain_ "
1275                << menu->DefaultDomainOperator() << " " << mergeExpr.Data() << ";" << endl;
1276           code << "        }" << endl;
1277         }
1278         code << "        _description_ += \",\";" << endl;
1279         code << "        _description_ += fMenuItemDescription" << i << ";" << endl;
1280         code << "      } else {" << endl;
1281         code << "        _domain_ = " << mergeExpr.Data() << ";" << endl;
1282         code << "        _description_ = fMenuItemDescription" << i << ";" << endl;
1283         code << "      }" << endl;
1284         code << "      _previous_match_ = " << i << ";" << endl;
1285         code << "      _trigger_matched_ = true;" << endl;
1286         code << "    }" << endl;
1287       }
1288     }
1289     code << "    if (_group_result_) {" << endl;
1290     if (fDebugMode)
1291     {
1292       if (n < priorities.size() - 1)
1293       {
1294         code << "      HLTDebug(Form(\"Matched triggers in trigger priority group " << priorities[n]
1295              << ". Stopping processing here because all other trigger groups have lower priority.\"));" << endl;
1296       }
1297       else
1298       {
1299         code << "      HLTDebug(Form(\"Matched triggers in trigger priority group " << priorities[n] << ".\"));" << endl;
1300       }
1301     }
1302     code << "      return true;" << endl;
1303     code << "    }" << endl;
1304   }
1305   code << "    _domain_.Clear();" << endl;
1306   code << "    _description_ = \"\";" << endl;
1307   code << "    return false;" << endl;
1308   code << "  }" << endl;
1309
1310   // Generate getter and setter methods for the counters.
1311   code << "  const TArrayL64& GetCounters() const { return fCounter; }" << endl;
1312   code << "  void SetCounters(const TArrayL64& counters) { fCounter = counters; }" << endl;
1313
1314   code << "private:" << endl;
1315   // Add the symbols in the trigger menu to the list of private variables.
1316   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
1317   {
1318     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
1319     code << "  " << symbol->Type() << " " << symbol->Name() << ";" << endl;
1320     if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0)
1321     {
1322       code << "  AliHLTTriggerDomain " << symbol->Name() << "TriggerDomain;" << endl;
1323     }
1324     code << "  AliHLTDomainEntry " << symbol->Name() << "DomainEntry;" << endl;
1325   }
1326   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
1327   {
1328     code << "  TString fMenuItemDescription" << i << ";" << endl;
1329   }
1330   code << "  TArrayL64 fCounter;" << endl;
1331   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
1332   code << "  ClassDef(" << name.Data() << ", 0)" << endl;
1333   code << "#else" << endl;
1334   code << "  virtual const char* Class_Name() const { return \"" << name.Data() << "\"; }" << endl;
1335   code << "#endif" << endl;
1336   code << "};" << endl;
1337   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
1338   code << "ClassImp(" << name.Data() << ")" << endl;
1339   code << "#endif" << endl;
1340
1341   code.close();
1342
1343   // Now we need to compile and load the new class.
1344   result = LoadTriggerClass(filename, includePaths);
1345   return result;
1346 }
1347
1348
1349 int AliHLTGlobalTriggerComponent::LoadTriggerClass(
1350     const char* filename, const TClonesArray& includePaths
1351   )
1352 {
1353   // Loads the code for a custom global trigger class implementation on the fly.
1354
1355   HLTDebug("Loading HLT trigger class from file '%s'.", filename);
1356
1357   TString compiler = gSystem->GetBuildCompilerVersion();
1358   if (fRuntimeCompile && (compiler.Contains("gcc") or compiler.Contains("icc")))
1359   {
1360     TString includePath;
1361 #if defined(PKGINCLUDEDIR)
1362     // this is especially for the HLT build system where the package is installed
1363     // in a specific directory including proper treatment of include files
1364     includePath.Form("-I%s", PKGINCLUDEDIR);
1365 #else
1366     // the default AliRoot behavior, all include files can be found in the
1367     // $ALICE_ROOT subfolders
1368     includePath = "-I${ALICE_ROOT}/include -I${ALICE_ROOT}/HLT/BASE -I${ALICE_ROOT}/HLT/trigger";
1369 #endif
1370     // Add any include paths that were specified on the command line.
1371     for (Int_t i = 0; i < includePaths.GetEntriesFast(); i++)
1372     {
1373       TString path = static_cast<TObjString*>(includePaths.UncheckedAt(i))->String();
1374       includePath += " -I";
1375       includePath += path;
1376     }
1377     HLTDebug("using include settings: %s", includePath.Data());
1378     gSystem->SetIncludePath(includePath);
1379     gSystem->SetFlagsOpt("-O3 -DNDEBUG");
1380     gSystem->SetFlagsDebug("-g3 -DDEBUG -D__DEBUG");
1381
1382     int result = kTRUE;
1383     if (fDebugMode)
1384     {
1385       result = gSystem->CompileMacro(filename, "g");
1386     }
1387     else
1388     {
1389       result = gSystem->CompileMacro(filename, "O");
1390     }
1391     if (result != kTRUE)
1392     {
1393       HLTFatal("Could not compile and load global trigger menu implementation.");
1394       return -ENOENT;
1395     }
1396   }
1397   else
1398   {
1399     // Store the library state to be checked later in UnloadTriggerClass.
1400     fLibStateAtLoad = gSystem->GetLibraries();
1401
1402     // If we do not support the compiler then try interpret the class instead.
1403     TString cmd = ".L ";
1404     cmd += filename;
1405     Int_t errorcode = TInterpreter::kNoError;
1406     gROOT->ProcessLine(cmd, &errorcode);
1407     if (errorcode != TInterpreter::kNoError)
1408     {
1409       HLTFatal("Could not load interpreted global trigger menu implementation"
1410                " (Interpreter error code = %d).",
1411                errorcode
1412       );
1413       return -ENOENT;
1414     }
1415   }
1416
1417   return 0;
1418 }
1419
1420
1421 int AliHLTGlobalTriggerComponent::UnloadTriggerClass(const char* filename)
1422 {
1423   // Unloads the code previously loaded by LoadTriggerClass.
1424
1425   HLTDebug("Unloading HLT trigger class in file '%s'.", filename);
1426
1427   TString compiler = gSystem->GetBuildCompilerVersion();
1428   if (fRuntimeCompile && (compiler.Contains("gcc") or compiler.Contains("icc")))
1429   {
1430     // Generate the library name.
1431     TString libname = filename;
1432     Ssiz_t dotpos = libname.Last('.');
1433     if (0 <= dotpos and dotpos < libname.Length()) libname[dotpos] = '_';
1434     libname += ".";
1435     libname += gSystem->GetSoExt();
1436
1437     // This is a workaround for a problem with unloading shared libraries in ROOT.
1438     // If the trigger logic library is loaded before the libAliHLTHOMER.so library
1439     // or any other library is loaded afterwards, then during the gInterpreter->UnloadFile
1440     // call all the subsequent libraries get unloded. This means that any objects created
1441     // from classes implemented in the libAliHLTHOMER.so library will generate segfaults
1442     // since the executable code has been unloaded.
1443     // We need to check if there are any more libraries loaded after the class we
1444     // are unloading and in that case don't unload the class.
1445     TString libstring = gSystem->GetLibraries();
1446     TString token, lastlib;
1447     Ssiz_t from = 0;
1448     Int_t numOfLibs = 0, posOfLib = -1;
1449     while (libstring.Tokenize(token, from, " "))
1450     {
1451       ++numOfLibs;
1452       lastlib = token;
1453       if (token.Contains(libname)) posOfLib = numOfLibs;
1454     }
1455     if (numOfLibs != posOfLib)
1456     {
1457       HLTWarning(Form("ROOT limitation! Cannot properly cleanup and unload the shared"
1458           " library '%s' since another library '%s' was loaded afterwards. Trying to"
1459           " unload this library will remove the others and lead to serious memory faults.",
1460           libname.Data(), lastlib.Data()
1461       ));
1462       return 0;
1463     }
1464
1465     char* path = NULL;
1466     int result = 0;
1467     if ((path = gSystem->DynamicPathName(libname)) != NULL)
1468     {
1469       result = gInterpreter->UnloadFile(path);
1470       delete [] path;
1471     }
1472     if (result != TInterpreter::kNoError) return -ENOENT;
1473   }
1474   else
1475   {
1476     // This is again a workaround for the problem with unloading files in ROOT.
1477     // If the trigger logic class is loaded before the libAliHLTHOMER.so library
1478     // or any other library is loaded afterwards, then during the gInterpreter->UnloadFile
1479     // call all the subsequent libraries get unloded.
1480     // We need to check if the list of loaded libraries has changed since the last
1481     // call to LoadTriggerClass. If it has then don't unload the class.
1482     if (fLibStateAtLoad != gSystem->GetLibraries())
1483     {
1484       TString libstring = gSystem->GetLibraries();
1485       TString token;
1486       Ssiz_t from = 0;
1487       while (libstring.Tokenize(token, from, " "))
1488       {
1489         if (not fLibStateAtLoad.Contains(token)) break;
1490       }
1491       HLTWarning(Form("ROOT limitation! Cannot properly cleanup and unload the file"
1492           " '%s' since another library '%s' was loaded afterwards. Trying to unload"
1493           " this file will remove the other library and lead to serious memory faults.",
1494           filename, token.Data()
1495       ));
1496       return 0;
1497     }
1498
1499     // If we did not compile the trigger logic then remove the interpreted class.
1500     TString cmd = ".U ";
1501     cmd += filename;
1502     Int_t errorcode = TInterpreter::kNoError;
1503     gROOT->ProcessLine(cmd, &errorcode);
1504     if (errorcode != TInterpreter::kNoError)
1505     {
1506       HLTFatal("Could not unload interpreted global trigger menu implementation"
1507                " (Interpreter error code = %d).",
1508                errorcode
1509       );
1510       return -ENOENT;
1511     }
1512   }
1513
1514   return 0;
1515 }
1516
1517
1518 int AliHLTGlobalTriggerComponent::FindSymbol(const char* name, const TClonesArray& list)
1519 {
1520   // Searches for the named symbol in the given list.
1521   // See header for more details.
1522
1523   for (int i = 0; i < list.GetEntriesFast(); i++)
1524   {
1525     const AliHLTTriggerMenuSymbol* symbol = dynamic_cast<const AliHLTTriggerMenuSymbol*>( list.UncheckedAt(i) );
1526     if (symbol == NULL) continue;
1527     if (strcmp(symbol->Name(), name) == 0) return i;
1528   }
1529   return -1;
1530 }
1531
1532
1533 namespace
1534 {
1535   /**
1536    * Helper routine to compare two trigger menu symbols to see if b is a subset of a.
1537    * \returns true if b is a subset of a or they are unrelated.
1538    */
1539   bool AliHLTCheckForContainment(const AliHLTTriggerMenuSymbol* a, const AliHLTTriggerMenuSymbol* b)
1540   {
1541     TString bstr = b->Name();
1542     return bstr.Contains(a->Name());
1543   }
1544
1545 } // end of namespace
1546
1547
1548 int AliHLTGlobalTriggerComponent::BuildSymbolList(const AliHLTTriggerMenu* menu, TClonesArray& list)
1549 {
1550   // Builds the list of symbols to use in the custom global trigger menu
1551   // implementation class.
1552   // See header for more details.
1553
1554   // Note: when we build the symbol list we must use the symbol name as returned
1555   // by the Name() method and not the RealName() method when using FindSymbol.
1556   // This is so that we avoid problems with the generated code not compiling
1557   // because names like "abc-xyz" and "abc_xyz" are synonymous.
1558   // Name() returns the converted C++ symbol name as used in the generated code.
1559
1560   for (UInt_t i = 0; i < menu->NumberOfSymbols(); i++)
1561   {
1562     const AliHLTTriggerMenuSymbol* symbol = menu->Symbol(i);
1563     if (FindSymbol(symbol->Name(), list) != -1)
1564     {
1565       HLTError("Multiple symbols with the name '%s' defined in the trigger menu.", symbol->Name());
1566       return -EIO;
1567     }
1568     try
1569     {
1570       new (list[list.GetEntriesFast()]) AliHLTTriggerMenuSymbol(*symbol);
1571     }
1572     catch (const std::bad_alloc&)
1573     {
1574       HLTError("Could not allocate more memory for the symbols list when adding a trigger menu symbol.");
1575       return -ENOMEM;
1576     }
1577   }
1578   Int_t initialEntryCount = list.GetEntriesFast();
1579
1580   // Note: the \\. must not be the first element in the character class, otherwise
1581   // it is interpreted as an "any character" dot symbol.
1582   TRegexp exp("[_a-zA-Z][-\\._a-zA-Z0-9]*");
1583   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
1584   {
1585     const AliHLTTriggerMenuItem* item = menu->Item(i);
1586     TString str = item->TriggerCondition();
1587     Ssiz_t start = 0;
1588     do
1589     {
1590       Ssiz_t length = 0;
1591       Ssiz_t pos = exp.Index(str, &length, start);
1592       if (pos == kNPOS) break;
1593       start = pos+length;
1594
1595       // Check if there is a numerical character before the found
1596       // regular expression. If so, then the symbol is not a valid one
1597       // and should be skipped.
1598       if (pos > 0)
1599       {
1600         bool notValid = false;
1601         switch (str[pos-1])
1602         {
1603         case '0': case '1': case '2': case '3': case '4':
1604         case '5': case '6': case '7': case '8': case '9':
1605           notValid = true;
1606           break;
1607         default:
1608           notValid = false;
1609           break;
1610         }
1611         if (notValid) continue;
1612       }
1613       TString s = str(pos, length);
1614
1615       if (s == "and" or s == "and_eq" or s == "bitand" or s == "bitor" or
1616           s == "compl" or s == "not" or s == "not_eq" or s == "or" or
1617           s == "or_eq" or s == "xor" or s == "xor_eq" or s == "true" or
1618           s == "false"
1619          )
1620       {
1621         // Ignore iso646.h and other keywords.
1622         continue;
1623       }
1624
1625       // We need to handle the special case where the symbol contains a dot.
1626       // In C++ this is a dereferencing operator. So we need to check if the
1627       // current symbol we are handling starts with the same string as any of
1628       // the existing symbols defined manually in the symbols table.
1629       // If we do find such a case then revert to treating the dot as an operator
1630       // rather than part of the symbol name. i.e. skip adding the automatic symbol.
1631       bool dereferencedSymbol = false;
1632       for (int j = 0; j < initialEntryCount; j++)
1633       {
1634         const AliHLTTriggerMenuSymbol* symbol = dynamic_cast<const AliHLTTriggerMenuSymbol*>( list.UncheckedAt(j) );
1635         if (symbol == NULL) continue;
1636         TString symstr = symbol->Name();
1637         symstr += ".";
1638         if (s.BeginsWith(symstr))
1639         {
1640           dereferencedSymbol = true;
1641           break;
1642         }
1643       }
1644       if (dereferencedSymbol) continue;
1645
1646       // Need to create the symbols first and check if its name is in the list
1647       // before actually adding it to the symbols list.
1648       AliHLTTriggerMenuSymbol newSymbol;
1649       newSymbol.Name(s.Data());
1650       newSymbol.Type("bool");
1651       newSymbol.ObjectClass("AliHLTTriggerDecision");
1652       newSymbol.AssignExpression("this->Result()");
1653       newSymbol.DefaultValue("false");
1654       if (FindSymbol(newSymbol.Name(), list) == -1)
1655       {
1656         try
1657         {
1658           new (list[list.GetEntriesFast()]) AliHLTTriggerMenuSymbol(newSymbol);
1659         }
1660         catch (const std::bad_alloc&)
1661         {
1662           HLTError("Could not allocate more memory for the symbols list when adding a trigger name symbol.");
1663           return -ENOMEM;
1664         }
1665       }
1666     }
1667     while (start < str.Length());
1668   }
1669
1670   // This last part is necessary to make sure that symbols are replaced in the
1671   // trigger condition and domain merging expressions in a greedy manner.
1672   // I.e. we need to make sure that if one symbol's string representation is
1673   // contained inside another (string subset) that the longer symbol name is
1674   // always first in the symbols list.
1675   // This will work because the symbol table is traversed from first to last
1676   // element and TString::ReplaceAll is used to replace the substrings inside
1677   // the AliHLTGlobalTriggerComponent::GenerateTrigger method.
1678   std::vector<AliHLTTriggerMenuSymbol*> orderedList;
1679   for (Int_t i = 0; i < list.GetEntriesFast(); i++)
1680   {
1681     orderedList.push_back( static_cast<AliHLTTriggerMenuSymbol*>(list.UncheckedAt(i)) );
1682   }
1683   std::sort(orderedList.begin(), orderedList.end(), AliHLTCheckForContainment);
1684   //std::sort(orderedList.begin(), orderedList.end());
1685   // Now swap values around according to the orderedList.
1686   for (Int_t i = 0; i < list.GetEntriesFast(); i++)
1687   {
1688     AliHLTTriggerMenuSymbol* target = static_cast<AliHLTTriggerMenuSymbol*>(list.UncheckedAt(i));
1689     AliHLTTriggerMenuSymbol tmp = *target;
1690     *target = *orderedList[i];
1691     *orderedList[i] = tmp;
1692   }
1693
1694   return 0;
1695 }
1696
1697
1698 bool AliHLTGlobalTriggerComponent::ExtractedOperator(TString& expr, TString& op)
1699 {
1700   // Extracts the trailing operator from the expression.
1701
1702   Ssiz_t i = 0;
1703   // First skip the trailing whitespace.
1704   bool whitespace = true;
1705   for (i = expr.Length()-1; i >= 0 and whitespace; i--)
1706   {
1707     switch (expr[i])
1708     {
1709     case ' ': case '\t': case '\r': case '\n':
1710       whitespace = true;
1711       break;
1712     default:
1713       whitespace = false;
1714     }
1715   }
1716   if (i < 0 or whitespace) return false;
1717
1718   // Now find the first whitespace character before the trailing symbol.
1719   bool nonwhitespace = true;
1720   for (; i >= 0 and nonwhitespace; i--)
1721   {
1722     switch (expr[i])
1723     {
1724     case ' ': case '\t': case '\r': case '\n':
1725       nonwhitespace = false;
1726       break;
1727     default:
1728       nonwhitespace = true;
1729     }
1730   }
1731   if (i < 0 or nonwhitespace) return false;
1732
1733   // Extract the last symbols and check if it is a valid operator.
1734   TString s = expr;
1735   s.Remove(0, i+2);
1736   if (s == "and" or s == "and_eq" or s == "bitand" or s == "bitor" or
1737       s == "compl" or s == "not" or s == "not_eq" or s == "or" or
1738       s == "or_eq" or s == "xor" or s == "xor_eq" or s == "&&" or
1739       s == "&=" or s == "&" or s == "|" or s == "~" or s == "!" or
1740       s == "!=" or s == "||" or s == "|=" or s == "^" or s == "^=" or
1741       s == "==" or s == "+" or s == "-" or s == "*" or s == "/" or
1742       s == "%" or s == ">" or s == "<" or s == ">=" or s == "<="
1743      )
1744   {
1745     expr.Remove(i+1);
1746     op = s;
1747     return true;
1748   }
1749
1750   return false;
1751 }
1752
1753
1754 bool AliHLTGlobalTriggerComponent::FillSoftwareTrigger()
1755 {
1756   // Fills the fSoftwareTrigger structure.
1757   const AliRawDataHeader* cdh;
1758   if (ExtractTriggerData(*GetTriggerData(), NULL, NULL, &cdh, NULL) != 0) return false;
1759   UChar_t l1msg = cdh->GetL1TriggerMessage();
1760   if ((l1msg & 0x1) == 0x0) return false;  // skip physics events.
1761   // From here on everything must be a software trigger.
1762   if (((l1msg >> 2) & 0xF) == 0xE)
1763   {
1764     fSoftwareTrigger.Name("START_OF_DATA");
1765     fSoftwareTrigger.Description("Generated internal start of data trigger.");
1766   }
1767   else if (((l1msg >> 2) & 0xF) == 0xF)
1768   {
1769     fSoftwareTrigger.Name("END_OF_DATA");
1770     fSoftwareTrigger.Description("Generated internal end of data trigger.");
1771   }
1772   else if (((l1msg >> 6) & 0x1) == 0x1)
1773   {
1774     fSoftwareTrigger.Name("CALIBRATION");
1775     fSoftwareTrigger.Description("Generated internal calibration trigger.");
1776   }
1777   else
1778   {
1779     fSoftwareTrigger.Name("SOFTWARE");
1780     fSoftwareTrigger.Description("Generated internal software trigger.");
1781   }
1782   UInt_t detectors = cdh->GetSubDetectors();
1783   fSoftwareTrigger.ReadoutList( AliHLTReadoutList(Int_t(detectors)) );
1784   return true;
1785 }
1786
1787
1788 int AliHLTGlobalTriggerComponent::PrintStatistics(const AliHLTGlobalTrigger* pTrigger, AliHLTComponentLogSeverity level, int offset) const
1789 {
1790   // print some statistics
1791   int totalEvents=GetEventCount()+offset;
1792   const TArrayL64& counters = pTrigger->GetCounters();
1793   if (pTrigger->CallFailed()) return -EPROTO;
1794   for (int i = 0; i < counters.GetSize(); i++) {
1795     ULong64_t count = counters[i];
1796     float ratio=0;
1797     if (totalEvents>0) ratio=100*(float)count/totalEvents;
1798     HLTLog(level, "Item %d: total events: %d - counted events: %llu (%.1f%%)", i, totalEvents, count, ratio);
1799   }
1800   return 0;
1801 }
1802
1803 int AliHLTGlobalTriggerComponent::AddCTPDecisions(AliHLTGlobalTrigger* pTrigger, const AliHLTCTPData* pCTPData, const AliHLTComponentTriggerData* trigData)
1804 {
1805   // add trigger decisions for the valid CTP classes
1806   if (!pCTPData || !pTrigger) return 0;
1807
1808   AliHLTUInt64_t triggerMask=pCTPData->Mask();
1809   AliHLTUInt64_t bit0=0x1;
1810   if (!fCTPDecisions) {
1811     try
1812     {
1813       fCTPDecisions=new TClonesArray(AliHLTTriggerDecision::Class(), gkNCTPTriggerClasses);
1814     }
1815     catch (const std::bad_alloc&)
1816     {
1817       HLTError("Could not allocate memory for the CTP decisions array.");
1818       return -ENOMEM;
1819     }
1820     if (!fCTPDecisions) return -ENOMEM;
1821
1822     try
1823     {
1824       fCTPDecisions->ExpandCreate(gkNCTPTriggerClasses);
1825     }
1826     catch (const std::bad_alloc&)
1827     {
1828       HLTError("Could not allocate more memory for the CTP decisions array.");
1829       return -ENOMEM;
1830     }
1831     for (int i=0; i<gkNCTPTriggerClasses; i++) {
1832       const char* name=pCTPData->Name(i);
1833       if (triggerMask&(bit0<<i) && name) {
1834         AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(fCTPDecisions->At(i));
1835         assert(pDecision);
1836         if (!pDecision) {
1837           delete fCTPDecisions;
1838           fCTPDecisions=NULL;
1839           return -ENOENT;
1840         }
1841         pDecision->Name(name);
1842       }
1843     }
1844   }
1845
1846   for (int i=0; i<gkNCTPTriggerClasses; i++) {
1847     const char* name=pCTPData->Name(i);
1848     if ((triggerMask&(bit0<<i))==0 || name==NULL) continue;
1849     AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(fCTPDecisions->At(i));
1850     HLTDebug("updating CTP trigger decision %d %s (%p casted %p)", i, name, fCTPDecisions->At(i), pDecision);
1851     if (!pDecision) return -ENOENT;
1852
1853     bool result=false;
1854     // 13 March 2010 - Optimisation:
1855     // Dont use the EvaluateCTPTriggerClass method, which uses slow TFormula objects.
1856     AliHLTUInt64_t triggers = 0;
1857     if (trigData) triggers = pCTPData->ActiveTriggers(*trigData);
1858     else triggers = pCTPData->Triggers();
1859     result = (triggers&((AliHLTUInt64_t)0x1<<i)) ? true : false;
1860     //if (trigData) result=pCTPData->EvaluateCTPTriggerClass(name, *trigData);
1861     //else result=pCTPData->EvaluateCTPTriggerClass(name);
1862     pDecision->Result(result);
1863     pDecision->TriggerDomain().Clear();
1864     if (trigData) pDecision->TriggerDomain().Add(pCTPData->ReadoutList(*trigData));
1865     else pDecision->TriggerDomain().Add(pCTPData->ReadoutList());
1866
1867     pTrigger->Add(fCTPDecisions->At(i), kAliHLTDataTypeTriggerDecision, kAliHLTVoidDataSpec);
1868     if (pTrigger->CallFailed()) return -EPROTO;
1869   }
1870
1871   return 0;
1872 }