HLT/rec/AliHLTReconstructor.cxx

   1 // $Id$
   2
   3 //**************************************************************************
   4 //* This file is property of and copyright by the ALICE HLT Project        *
   5 //* ALICE Experiment at CERN, All rights reserved.                         *
   6 //*                                                                        *
   7 //* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
   8 //*                  for The ALICE HLT Project.                            *
   9 //*                                                                        *
  10 //* Permission to use, copy, modify and distribute this software and its   *
  11 //* documentation strictly for non-commercial purposes is hereby granted   *
  12 //* without fee, provided that the above copyright notice appears in all   *
  13 //* copies and that both the copyright notice and this permission notice   *
  14 //* appear in the supporting documentation. The authors make no claims     *
  15 //* about the suitability of this software for any purpose. It is          *
  16 //* provided "as is" without express or implied warranty.                  *
  17 //**************************************************************************
  18
  19 /** @file   AliHLTReconstructor.cxx
  20     @author Matthias Richter
  21     @date
  22     @brief  Binding class for HLT reconstruction in AliRoot. */
  23
  24 #include <TSystem.h>
  25 #include <TObjString.h>
  26 #include "TFile.h"
  27 #include "TTree.h"
  28 #include "AliHLTReconstructor.h"
  29 #include "AliLog.h"
  30 #include "AliRawReader.h"
  31 #include "AliESDEvent.h"
  32 #include "AliHLTSystem.h"
  33 #include "AliHLTOUTRawReader.h"
  34 #include "AliHLTOUTDigitReader.h"
  35 #include "AliHLTEsdManager.h"
  36
  37 ClassImp(AliHLTReconstructor)
  38
  39 AliHLTReconstructor::AliHLTReconstructor()
  40   :
  41   AliReconstructor(),
  42   AliHLTReconstructorBase(),
  43   fFctProcessHLTOUT(NULL),
  44   fpEsdManager(NULL)
  45 {
  46   //constructor
  47 }
  48
  49 AliHLTReconstructor::AliHLTReconstructor(const char* options)
  50   :
  51   AliReconstructor(),
  52   AliHLTReconstructorBase(),
  53   fFctProcessHLTOUT(NULL),
  54   fpEsdManager(NULL)
  55 {
  56   //constructor
  57   if (options) Init(options);
  58 }
  59
  60 AliHLTReconstructor::~AliHLTReconstructor()
  61 {
  62   //destructor
  63
  64   AliHLTSystem* pSystem=GetInstance();
  65   if (pSystem) {
  66     AliDebug(0, Form("delete HLT system: status %#x", pSystem->GetStatusFlags()));
  67     if (pSystem->CheckStatus(AliHLTSystem::kReady)) {
  68       // send specific 'event' to execute the stop sequence
  69       pSystem->Reconstruct(0, NULL, NULL);
  70     }
  71   }
  72
  73   if (fpEsdManager) delete fpEsdManager;
  74   fpEsdManager=NULL;
  75 }
  76
  77 void AliHLTReconstructor::Init(const char* options)
  78 {
  79   // init the reconstructor
  80   SetOption(options);
  81   Init();
  82 }
  83
  84 void AliHLTReconstructor::Init()
  85 {
  86   // init the reconstructor
  87   AliHLTSystem* pSystem=GetInstance();
  88   if (!pSystem) {
  89     AliError("can not create AliHLTSystem object");
  90     return;
  91   }
  92   if (pSystem->CheckStatus(AliHLTSystem::kError)) {
  93     AliError("HLT system in error state");
  94     return;
  95   }
  96
  97   // the options scan has been moved to AliHLTSystem, the old code
  98   // here is kept to be able to run an older version of the HLT code
  99   // with newer AliRoot versions.
 100   TString libs("");
 101   TString option = GetOption();
 102   TObjArray* pTokens=option.Tokenize(" ");
 103   option="";
 104   if (pTokens) {
 105     int iEntries=pTokens->GetEntries();
 106     for (int i=0; i<iEntries; i++) {
 107       TString token=(((TObjString*)pTokens->At(i))->GetString());
 108       if (token.Contains("loglevel=")) {
 109         TString param=token.ReplaceAll("loglevel=", "");
 110         if (param.IsDigit()) {
 111           pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
 112         } else if (param.BeginsWith("0x") &&
 113                    param.Replace(0,2,"",0).IsHex()) {
 114           int severity=0;
 115           sscanf(param.Data(),"%x", &severity);
 116           pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
 117         } else {
 118           AliWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
 119         }
 120       } else if (token.Contains("alilog=off")) {
 121         pSystem->SwitchAliLog(0);
 122       } else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
 123         libs+=token;
 124         libs+=" ";
 125       } else {
 126         if (option.Length()>0) option+=" ";
 127         option+=token;
 128       }
 129     }
 130     delete pTokens;
 131   }
 132
 133   if (!libs.IsNull() &&
 134       (!pSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
 135       (pSystem->LoadComponentLibraries(libs.Data())<0)) {
 136     AliError("error while loading HLT libraries");
 137     return;
 138   }
 139
 140   if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
 141     typedef int (*AliHLTSystemSetOptions)(AliHLTSystem* pInstance, const char* options);
 142     gSystem->Load("libHLTinterface.so");
 143     AliHLTSystemSetOptions pFunc=(AliHLTSystemSetOptions)(gSystem->DynFindSymbol("libHLTinterface.so", "AliHLTSystemSetOptions"));
 144     if (pFunc) {
 145       if ((pFunc)(pSystem, option.Data())<0) {
 146       AliError("error setting options for HLT system");
 147       return;
 148       }
 149     } else if (option.Length()>0) {
 150       AliError(Form("version of HLT system does not support the options \'%s\'", option.Data()));
 151       return;
 152     }
 153     if ((pSystem->Configure())<0) {
 154       AliError("error during HLT system configuration");
 155       return;
 156     }
 157   }
 158
 159   gSystem->Load("libHLTinterface.so");
 160   fFctProcessHLTOUT=gSystem->DynFindSymbol("libHLTinterface.so", "AliHLTSystemProcessHLTOUT");
 161
 162   fpEsdManager=new AliHLTEsdManager;
 163 }
 164
 165 void AliHLTReconstructor::Reconstruct(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/) const
 166 {
 167   // reconstruction of real data without writing of ESD
 168   // For each event, HLT reconstruction chains can be executed and
 169   // added to the existing HLTOUT data
 170   // The HLTOUT data is finally processed in FillESD
 171   AliHLTSystem* pSystem=GetInstance();
 172   AliInfo("running raw data reconstruction");
 173 }
 174
 175 void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /*clustersTree*/,
 176                                   AliESDEvent* esd) const
 177 {
 178   // reconstruct real data and fill ESD
 179   if (!rawReader || !esd) {
 180     AliError("missing raw reader or esd object");
 181     return;
 182   }
 183
 184   //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 185   // code needs to be moved back to Reconstruct as soon es HLT loader is implemented
 186   int iResult=0;
 187   AliHLTSystem* pSystem=GetInstance();
 188   if (pSystem) {
 189     if (pSystem->CheckStatus(AliHLTSystem::kError)) {
 190       AliError("HLT system in error state");
 191       return;
 192     }
 193     if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
 194       AliError("HLT system in wrong state");
 195       return;
 196     }
 197     if ((iResult=pSystem->Reconstruct(1, NULL, rawReader))>=0) {
 198     }
 199   }
 200   //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 201
 202   if (pSystem) {
 203     if (pSystem->CheckStatus(AliHLTSystem::kError)) {
 204       AliError("HLT system in error state");
 205       return;
 206     }
 207     if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
 208       AliError("HLT system in wrong state");
 209       return;
 210     }
 211     pSystem->FillESD(-1, NULL, esd);
 212
 213     AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(rawReader, esd->GetEventNumberInFile(), fpEsdManager);
 214     if (pHLTOUT) {
 215       ProcessHLTOUT(pHLTOUT, esd);
 216       delete pHLTOUT;
 217     } else {
 218       AliError("error creating HLTOUT handler");
 219     }
 220   }
 221 }
 222
 223 void AliHLTReconstructor::Reconstruct(TTree* /*digitsTree*/, TTree* /*clustersTree*/) const
 224 {
 225   // reconstruct simulated data
 226
 227   // all reconstruction has been moved to FillESD
 228   //AliReconstructor::Reconstruct(digitsTree,clustersTree);
 229   AliInfo("running digit data reconstruction");
 230 }
 231
 232 void AliHLTReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/, AliESDEvent* esd) const
 233 {
 234   // reconstruct simulated data and fill ESD
 235
 236   // later this is the place to extract the simulated HLT data
 237   // for now it's only an user failure condition as he tries to run HLT reconstruction
 238   // on simulated data
 239   TString option = GetOption();
 240   if (!option.IsNull() &&
 241       (option.Contains("config=") || option.Contains("chains="))) {
 242     AliWarning(Form("HLT reconstruction of simulated data takes place in AliSimulation\n"
 243                     "        /***  run macro *****************************************/\n"
 244                     "        AliSimulation sim;\n"
 245                     "        sim.SetRunHLT(\"%s\");\n"
 246                     "        sim.SetRunGeneration(kFALSE);\n"
 247                     "        sim.SetMakeDigits(\"\");\n"
 248                     "        sim.SetMakeSDigits(\"\");\n"
 249                     "        sim.SetMakeDigitsFromHits(\"\");\n"
 250                     "        sim.Run();\n"
 251                     "        /*********************************************************/", option.Data()));
 252   }
 253   AliHLTSystem* pSystem=GetInstance();
 254   if (pSystem) {
 255     if (pSystem->CheckStatus(AliHLTSystem::kError)) {
 256       AliError("HLT system in error state");
 257       return;
 258     }
 259     if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
 260       AliError("HLT system in wrong state");
 261       return;
 262     }
 263
 264     AliHLTOUTDigitReader* pHLTOUT=new AliHLTOUTDigitReader(esd->GetEventNumberInFile(), fpEsdManager);
 265     if (pHLTOUT) {
 266       ProcessHLTOUT(pHLTOUT, esd);
 267       delete pHLTOUT;
 268     } else {
 269       AliError("error creating HLTOUT handler");
 270     }
 271   }
 272 }
 273
 274 void AliHLTReconstructor::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd) const
 275 {
 276   // treatment of simulated or real HLTOUT data
 277   if (!pHLTOUT) return;
 278   AliHLTSystem* pSystem=GetInstance();
 279   if (!pSystem) {
 280     AliError("error getting HLT system instance");
 281     return;
 282   }
 283
 284   if (pHLTOUT->Init()<0) {
 285     AliError("error : initialization of HLTOUT handler failed");
 286     return;
 287   }
 288
 289   if (fFctProcessHLTOUT) {
 290     typedef int (*AliHLTSystemProcessHLTOUT)(AliHLTSystem* pInstance, AliHLTOUT* pHLTOUT, AliESDEvent* esd);
 291     AliHLTSystemProcessHLTOUT pFunc=(AliHLTSystemProcessHLTOUT)fFctProcessHLTOUT;
 292     if ((pFunc)(pSystem, pHLTOUT, esd)<0) {
 293       AliError("error processing HLTOUT");
 294     }
 295   }
 296 }
 297
 298 void AliHLTReconstructor::ProcessHLTOUT(const char* digitFile, AliESDEvent* pEsd) const
 299 {
 300   // debugging/helper function to examine simulated data
 301   if (!digitFile) return;
 302
 303   // read the number of events
 304   TFile f(digitFile);
 305   if (f.IsZombie()) return;
 306   TTree* pTree=NULL;
 307   f.GetObject("rawhltout", pTree);
 308   if (!pTree) {
 309     AliWarning(Form("can not find tree rawhltout in file %s", digitFile));
 310     return ;
 311   }
 312   int nofEvents=pTree->GetEntries();
 313   f.Close();
 314   //delete pTree; OF COURSE NOT! its an object in the file
 315   pTree=NULL;
 316
 317   for (int event=0; event<nofEvents; event++) {
 318     AliHLTOUTDigitReader* pHLTOUT=new AliHLTOUTDigitReader(event, fpEsdManager, digitFile);
 319     if (pHLTOUT) {
 320       AliInfo(Form("event %d", event));
 321       ProcessHLTOUT(pHLTOUT, pEsd);
 322       PrintHLTOUTContent(pHLTOUT);
 323       delete pHLTOUT;
 324     } else {
 325       AliError("error creating HLTOUT handler");
 326     }
 327   }
 328 }
 329
 330 void AliHLTReconstructor::ProcessHLTOUT(AliRawReader* pRawReader, AliESDEvent* pEsd) const
 331 {
 332   // debugging/helper function to examine simulated or real HLTOUT data
 333   if (!pRawReader) return;
 334
 335   pRawReader->RewindEvents();
 336   for (int event=0; pRawReader->NextEvent(); event++) {
 337     AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(pRawReader, event, fpEsdManager);
 338     if (pHLTOUT) {
 339       AliInfo(Form("event %d", event));
 340       ProcessHLTOUT(pHLTOUT, pEsd);
 341       PrintHLTOUTContent(pHLTOUT);
 342       delete pHLTOUT;
 343     } else {
 344       AliError("error creating HLTOUT handler");
 345     }
 346   }
 347 }
 348
 349 void AliHLTReconstructor::PrintHLTOUTContent(AliHLTOUT* pHLTOUT) const
 350 {
 351   // print the block specifications of the HLTOUT data blocks
 352   if (!pHLTOUT) return;
 353   int iResult=0;
 354
 355   for (iResult=pHLTOUT->SelectFirstDataBlock();
 356        iResult>=0;
 357        iResult=pHLTOUT->SelectNextDataBlock()) {
 358     AliHLTComponentDataType dt=kAliHLTVoidDataType;
 359     AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
 360     pHLTOUT->GetDataBlockDescription(dt, spec);
 361     const AliHLTUInt8_t* pBuffer=NULL;
 362     AliHLTUInt32_t size=0;
 363     if (pHLTOUT->GetDataBuffer(pBuffer, size)>=0) {
 364       pHLTOUT->ReleaseDataBuffer(pBuffer);
 365       pBuffer=NULL; // just a dummy
 366     }
 367     AliInfo(Form("   %s  0x%x: size %d", AliHLTComponent::DataType2Text(dt).c_str(), spec, size));
 368   }
 369 }