HLT/sim/AliHLTSimulation.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   AliHLTSimulation.cxx
  20     @author Matthias Richter
  21     @date
  22     @brief  Binding class for HLT simulation in AliRoot. */
  23
  24 #include <cassert>
  25 #include <cerrno>
  26 #include "TObjArray.h"
  27 #include "TObjString.h"
  28 #include "AliHLTSimulation.h"
  29 #include "AliSimulation.h"
  30 #include "AliLog.h"
  31 #include "AliRun.h"
  32 #include "AliRunLoader.h"
  33 #include "AliHeader.h"
  34 #include "AliCDBManager.h"
  35 #include "AliCDBEntry.h"
  36 #include "AliCDBPath.h"
  37 #include "AliCDBId.h"
  38 #include "AliCDBMetaData.h"
  39 #include "AliCDBStorage.h"
  40 #include "AliGRPObject.h"
  41 #include "AliGRPManager.h"
  42 #include "AliHLTSystem.h"
  43 #include "AliHLTPluginBase.h"
  44 #include "AliRawReaderFile.h"
  45 #include "AliRawReaderDate.h"
  46 #include "AliRawReaderRoot.h"
  47 #include "AliESDEvent.h"
  48 #include "AliHLTOUTComponent.h"
  49 #include "AliTracker.h"
  50 #include "TGeoGlobalMagField.h"
  51 #include "TSystem.h"
  52 #include "TMath.h"
  53 #include "TGeoGlobalMagField.h"
  54
  55 #if ALIHLTSIMULATION_LIBRARY_VERSION != LIBHLTSIM_VERSION
  56 #error library version in header file and lib*.pkg do not match
  57 #endif
  58
  59 /** ROOT macro for the implementation of ROOT specific class methods */
  60 ClassImp(AliHLTSimulation);
  61
  62 AliHLTSimulation::AliHLTSimulation()
  63   :
  64   fOptions(),
  65   fpPluginBase(new AliHLTPluginBase),
  66   fpRawReader(NULL)
  67 {
  68   // see header file for class documentation
  69   // or
  70   // refer to README to build package
  71   // or
  72   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  73 }
  74
  75 AliHLTSimulation::~AliHLTSimulation()
  76 {
  77   // see header file for function documentation
  78   if (fpPluginBase) delete fpPluginBase;
  79   fpPluginBase=NULL;
  80
  81   if (fpRawReader) {
  82     delete fpRawReader;
  83   }
  84   fpRawReader=NULL;
  85 }
  86
  87 AliHLTSimulation* AliHLTSimulation::CreateInstance()
  88 {
  89   // see header file for function documentation
  90   return new AliHLTSimulation;
  91 }
  92
  93 int AliHLTSimulation::DeleteInstance(AliHLTSimulation* pSim)
  94 {
  95   // see header file for function documentation
  96   assert(pSim!=NULL);
  97   delete pSim;
  98   return 0;
  99 }
 100
 101 int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
 102 {
 103   // init the simulation
 104   fOptions=options;
 105   TString sysOp;
 106
 107   if(!fpPluginBase) {
 108     AliError("internal initialization failed");
 109     return -EINVAL;
 110   }
 111
 112   AliHLTSystem* pSystem=fpPluginBase->GetInstance();
 113   if (!pSystem) {
 114     AliError("can not get AliHLTSystem instance");
 115     return -ENOMEM;
 116   }
 117   if (pSystem->CheckStatus(AliHLTSystem::kError)) {
 118     AliError("HLT system in error state");
 119     return -EFAULT;
 120   }
 121
 122   // scan options for specific entries
 123   TObjArray* pTokens=fOptions.Tokenize(" ");
 124   if (pTokens) {
 125     int iEntries=pTokens->GetEntries();
 126     for (int i=0; i<iEntries; i++) {
 127       TString token=(((TObjString*)pTokens->At(i))->GetString());
 128       if (token.Contains("rawfile=")) {
 129         TString param=token.ReplaceAll("rawfile=", "");
 130         if (param.EndsWith("/")) {
 131           AliInfo(Form("creating AliRawReaderFile (%s)", param.Data()));
 132           fpRawReader = new AliRawReaderFile(param);
 133         } else if (param.EndsWith(".root")) {
 134           AliInfo(Form("creating AliRawReaderRoot (%s)", param.Data()));
 135           fpRawReader = new AliRawReaderRoot(param);
 136         } else if (!param.IsNull()) {
 137           AliInfo(Form("creating AliRawReaderDate (%s)", param.Data()));
 138           fpRawReader = new AliRawReaderDate(param);
 139         }
 140         if (fpRawReader) {
 141             fpRawReader->RewindEvents();
 142             int count=0;
 143             for ( ; fpRawReader->NextEvent(); count++) {/* empty body */};
 144             if (count!=pRunLoader->GetNumberOfEvents()) {
 145               AliError(Form("mismatch in event count: runloader %d, rawreader %d; ignoring rawreader",
 146                             pRunLoader->GetNumberOfEvents(), count));
 147               count=0;
 148             }
 149             if (count>0) {
 150               fpRawReader->RewindEvents();
 151               fpRawReader->NextEvent();
 152             } else {
 153               delete fpRawReader;
 154               fpRawReader=NULL;
 155             }
 156         }
 157       } else if (token.Contains("writerawfiles=")) {
 158         if (!token.ReplaceAll("writerawfiles=", "").Contains("HLT")) {
 159           AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
 160         }
 161       } else {
 162         if (sysOp.Length()>0) sysOp+=" ";
 163         sysOp+=token;
 164       }
 165     }
 166     delete pTokens;
 167   }
 168
 169   AliCDBManager* man = AliCDBManager::Instance();
 170   if (man && man->IsDefaultStorageSet())
 171   {
 172     int runNo=pRunLoader->GetHeader()->GetRun();
 173
 174     // init solenoid field
 175     // 2009-11-07 magnetic field handling fo HLT components has been switched to the
 176     // global AliMagF instance, the HLT/ConfigHLT/SolenoidBz entry is obsolete
 177     // The global instance is either established by the AliRoot environment or the
 178     // component external interface.
 179     if (TGeoGlobalMagField::Instance()->GetField()) {
 180       AliDebug(0, Form("magnetic field: %f", AliTracker::GetBz()));
 181     } else {
 182       // workaround for bug #51285
 183       AliGRPManager grpman;
 184       if (grpman.ReadGRPEntry() &&
 185           grpman.SetMagField()) {
 186         // nothing to do any more
 187       }
 188       AliError(Form("can not get the AliMagF instance, falling back to GRP entry (%f)", AliTracker::GetBz()));
 189     }
 190   } else if (man) {
 191     AliError("OCDB default storage not yet set, can not prepare OCDB entries");
 192   } else {
 193     AliError("unable to get instance of AliCDBMetaData, can not prepare OCDB entries");
 194   }
 195
 196   // scan options
 197   if (pSystem->ScanOptions(sysOp.Data())<0) {
 198     AliError("error setting options for HLT system");
 199     return -EINVAL;
 200   }
 201
 202   if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
 203     if ((pSystem->Configure(fpRawReader, pRunLoader))<0) {
 204       AliError("error during HLT system configuration");
 205       return -EFAULT;
 206     }
 207   }
 208
 209   return 0;
 210 }
 211
 212
 213 int AliHLTSimulation::Run(AliRunLoader* pRunLoader)
 214 {
 215   // HLT reconstruction for simulated data
 216   if(!fpPluginBase) {
 217     AliError("internal initialization failed");
 218     return -EINVAL;
 219   }
 220
 221   if(!pRunLoader) {
 222     AliError("Missing RunLoader! 0x0");
 223     return -EINVAL;
 224   }
 225
 226   int nEvents = pRunLoader->GetNumberOfEvents();
 227   int iResult=0;
 228
 229   AliHLTSystem* pSystem=fpPluginBase->GetInstance();
 230   if (!pSystem) {
 231     AliError("can not get AliHLTSystem instance");
 232     return -ENOMEM;
 233   }
 234
 235   if (pSystem->CheckStatus(AliHLTSystem::kError)) {
 236     AliError("HLT system in error state");
 237     return -EFAULT;
 238   }
 239
 240   // Note: the rawreader is already placed at the first event
 241   if ((iResult=pSystem->Reconstruct(1, pRunLoader, fpRawReader))>=0) {
 242     pSystem->FillESD(0, pRunLoader, NULL);
 243     for (int i=1; i<nEvents; i++) {
 244       if (fpRawReader && !fpRawReader->NextEvent()) {
 245         AliError("mismatch in event count, rawreader corrupted");
 246         break;
 247       }
 248       pSystem->Reconstruct(1, pRunLoader, fpRawReader);
 249       pSystem->FillESD(i, pRunLoader, NULL);
 250     }
 251     // send specific 'event' to execute the stop sequence
 252     pSystem->Reconstruct(0, NULL, NULL);
 253   }
 254   return iResult;
 255 }
 256
 257
 258 AliHLTSimulation* AliHLTSimulationCreateInstance()
 259 {
 260   // see header file for function documentation
 261   return AliHLTSimulation::CreateInstance();
 262 }
 263
 264 int AliHLTSimulationDeleteInstance(AliHLTSimulation* pSim)
 265 {
 266   // see header file for function documentation
 267   return AliHLTSimulation::DeleteInstance(pSim);
 268 }
 269
 270 int AliHLTSimulationInit(AliHLTSimulation* pSim, AliRunLoader* pRunLoader, const char* options)
 271 {
 272   assert(pSim!=NULL);
 273   if (pSim) {
 274     return pSim->Init(pRunLoader, options);
 275   }
 276   return -ENODEV;
 277 }
 278
 279 int AliHLTSimulationRun(AliHLTSimulation* pSim, AliRunLoader* pRunLoader)
 280 {
 281   assert(pSim!=NULL);
 282   if (pSim) {
 283     return pSim->Run(pRunLoader);
 284   }
 285   return -ENODEV;
 286 }
 287
 288 int AliHLTSimulationGetLibraryVersion()
 289 {
 290   // see header file for function documentation
 291   return LIBHLTSIM_VERSION;
 292 }
 293
 294 int AliHLTSimulationSetup(AliHLTSimulation* /*pHLTSim*/, AliSimulation* pSim, const char* specificObjects)
 295 {
 296   // see header file for function documentation
 297
 298   // this is an attempt to solve issue #48360
 299   // since there are many jobs running in parallel during the production,
 300   // all the jobs want to put entries into the OCDB. The solution is to
 301   // make them temporary, since they are only used to propagate information
 302   // from the simulation to the reconstruction.
 303
 304   if (!pSim) return -EINVAL;
 305   const char* entries[]={
 306     NULL
 307   };
 308
 309   TString specificStorage;
 310   specificStorage.Form("local://%s",gSystem->pwd());
 311   for (const char** pEntry=entries; *pEntry!=NULL; pEntry++) {
 312     const char* pObject=specificObjects?strstr(specificObjects, *pEntry):NULL;
 313     if (pObject) {
 314       // skip this entry if it is found in the list and either
 315       // last one or separated by a blank
 316       pObject+=strlen(*pEntry);
 317       if (*pObject==0 || *pObject==' ') continue;
 318     }
 319     pSim->SetSpecificStorage(*pEntry, specificStorage.Data());
 320   }
 321
 322   return 0;
 323 }
 324
 325 #ifndef HAVE_COMPILEINFO
 326 extern "C" void CompileInfo(const char*& date, const char*& time)
 327 {
 328   // the fall back compile info of the HLTsim library
 329   // this is not up-to-date if other files have been changed and recompiled
 330   date=__DATE__; time=__TIME__;
 331   return;
 332 }
 333 #endif