[u/mrichter/AliRoot.git] / HLT / rec / AliHLTReconstructor.cxx

// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* Permission to use, copy, modify and distribute this software and its   *
//* documentation strictly for non-commercial purposes is hereby granted   *
//* without fee, provided that the above copyright notice appears in all   *
//* copies and that both the copyright notice and this permission notice   *
//* appear in the supporting documentation. The authors make no claims     *
//* about the suitability of this software for any purpose. It is          *
//* provided "as is" without express or implied warranty.                  *
//**************************************************************************

/** @file   AliHLTReconstructor.cxx
    @author Matthias Richter
    @date   
    @brief  Binding class for HLT reconstruction in AliRoot. */

#include <TSystem.h>
#include <TObjString.h>
#include "TFile.h"
#include "TTree.h"
#include "AliHLTReconstructor.h"
#include "AliLog.h"
#include "AliRawReader.h"
#include "AliESDEvent.h"
#include "AliHLTSystem.h"
#include "AliHLTOUTRawReader.h"
#include "AliHLTOUTDigitReader.h"
#include "AliHLTEsdManager.h"
#include "AliHLTPluginBase.h"

ClassImp(AliHLTReconstructor)

AliHLTReconstructor::AliHLTReconstructor()
  : 
  AliReconstructor(),
  fFctProcessHLTOUT(NULL),
  fpEsdManager(NULL),
  fpPluginBase(new AliHLTPluginBase)
{ 
  //constructor
}

AliHLTReconstructor::AliHLTReconstructor(const char* options)
  : 
  AliReconstructor(),
  fFctProcessHLTOUT(NULL),
  fpEsdManager(NULL),
  fpPluginBase(new AliHLTPluginBase)
{ 
  //constructor
  if (options) Init(options);
}

AliHLTReconstructor::~AliHLTReconstructor()
{ 
  //destructor

  if (fpPluginBase) {
  AliHLTSystem* pSystem=fpPluginBase->GetInstance();
  if (pSystem) {
    AliDebug(0, Form("terminate HLT system: status %#x", pSystem->GetStatusFlags()));
    if (pSystem->CheckStatus(AliHLTSystem::kStarted)) {
      // send specific 'event' to execute the stop sequence
      pSystem->Reconstruct(0, NULL, NULL);
    }
  }
  delete fpPluginBase;
  }
  fpPluginBase=NULL;

  if (fpEsdManager) AliHLTEsdManager::Delete(fpEsdManager);
  fpEsdManager=NULL;
}

void AliHLTReconstructor::Init(const char* options)
{
  // init the reconstructor
  SetOption(options);
  Init();
}

void AliHLTReconstructor::Init()
{
  // init the reconstructor
  if (!fpPluginBase) {
    AliError("internal memory error: can not get AliHLTSystem instance from plugin");
    return;
  }

  AliHLTSystem* pSystem=fpPluginBase->GetInstance();
  if (!pSystem) {
    AliError("can not create AliHLTSystem object");
    return;
  }
  if (pSystem->CheckStatus(AliHLTSystem::kError)) {
    AliError("HLT system in error state");
    return;
  }

  // the options scan has been moved to AliHLTSystem, the old code
  // here is kept to be able to run an older version of the HLT code
  // with newer AliRoot versions.
  TString libs("");
  TString option = GetOption();
  TObjArray* pTokens=option.Tokenize(" ");
  option="";
  if (pTokens) {
    int iEntries=pTokens->GetEntries();
    for (int i=0; i<iEntries; i++) {
      TString token=(((TObjString*)pTokens->At(i))->GetString());
      if (token.Contains("loglevel=")) {
	TString param=token.ReplaceAll("loglevel=", "");
	if (param.IsDigit()) {
	  pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
	} else if (param.BeginsWith("0x") &&
		   param.Replace(0,2,"",0).IsHex()) {
	  int severity=0;
	  sscanf(param.Data(),"%x", &severity);
	  pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
	} else {
	  AliWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
	}
      } else if (token.Contains("alilog=off")) {
	pSystem->SwitchAliLog(0);
      } else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
	libs+=token;
	libs+=" ";
      } else {
	if (option.Length()>0) option+=" ";
	option+=token;
      }
    }
    delete pTokens;
  }

  if (!libs.IsNull() &&
      (!pSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
      (pSystem->LoadComponentLibraries(libs.Data())<0)) {
    AliError("error while loading HLT libraries");
    return;
  }

  if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
    typedef int (*AliHLTSystemSetOptions)(AliHLTSystem* pInstance, const char* options);
    gSystem->Load("libHLTinterface.so");
    AliHLTSystemSetOptions pFunc=(AliHLTSystemSetOptions)(gSystem->DynFindSymbol("libHLTinterface.so", "AliHLTSystemSetOptions"));
    if (pFunc) {
      if ((pFunc)(pSystem, option.Data())<0) {
      AliError("error setting options for HLT system");
      return;	
      }
    } else if (option.Length()>0) {
      AliError(Form("version of HLT system does not support the options \'%s\'", option.Data()));
      return;
    }
    if ((pSystem->Configure())<0) {
      AliError("error during HLT system configuration");
      return;
    }
  }

  gSystem->Load("libHLTinterface.so");
  fFctProcessHLTOUT=(void (*)())gSystem->DynFindSymbol("libHLTinterface.so", "AliHLTSystemProcessHLTOUT");

  fpEsdManager=AliHLTEsdManager::New();
}

void AliHLTReconstructor::Reconstruct(AliRawReader* rawReader, TTree* /*clustersTree*/) const 
{
  // reconstruction of real data without writing of ESD
  // For each event, HLT reconstruction chains can be executed and
  // added to the existing HLTOUT data
  // The HLTOUT data is finally processed in FillESD
  if (!fpPluginBase) {
    AliError("internal memory error: can not get AliHLTSystem instance from plugin");
    return;
  }

  int iResult=0;
  AliHLTSystem* pSystem=fpPluginBase->GetInstance();

  if (pSystem) {
    if (pSystem->CheckStatus(AliHLTSystem::kError)) {
      AliError("HLT system in error state");
      return;
    }
    if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
      AliError("HLT system in wrong state");
      return;
    }
    if ((iResult=pSystem->Reconstruct(1, NULL, rawReader))>=0) {
    }
  }
}

void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /*clustersTree*/, 
				  AliESDEvent* esd) const
{
  // reconstruct real data and fill ESD
  if (!rawReader || !esd) {
    AliError("missing raw reader or esd object");
    return;
  }

  if (!fpPluginBase) {
    AliError("internal memory error: can not get AliHLTSystem instance from plugin");
    return;
  }

  AliHLTSystem* pSystem=fpPluginBase->GetInstance();

  if (pSystem) {
    if (pSystem->CheckStatus(AliHLTSystem::kError)) {
      AliError("HLT system in error state");
      return;
    }
    if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
      AliError("HLT system in wrong state");
      return;
    }
    pSystem->FillESD(-1, NULL, esd);

    AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(rawReader, esd->GetEventNumberInFile(), fpEsdManager);
    if (pHLTOUT) {
      ProcessHLTOUT(pHLTOUT, esd);
      delete pHLTOUT;
    } else {
      AliError("error creating HLTOUT handler");
    }
  }
}

void AliHLTReconstructor::Reconstruct(TTree* /*digitsTree*/, TTree* /*clustersTree*/) const
{
  // reconstruct simulated data

  // all reconstruction has been moved to FillESD
  //AliReconstructor::Reconstruct(digitsTree,clustersTree);
  AliInfo("running digit data reconstruction");
}

void AliHLTReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/, AliESDEvent* esd) const
{
  // reconstruct simulated data and fill ESD

  // later this is the place to extract the simulated HLT data
  // for now it's only an user failure condition as he tries to run HLT reconstruction
  // on simulated data 
  TString option = GetOption();
  if (!option.IsNull() && 
      (option.Contains("config=") || option.Contains("chains="))) {
    AliWarning(Form("HLT reconstruction can be run embedded into Alireconstruction from\n"
		    "raw data (real or simulated)). Reconstruction of of digit data takes\n"
		    "place in AliSimulation, appropriate input conversion is needed.\n"
		    "Consider running embedded into AliSimulation."
		    "        /***  run macro *****************************************/\n"
		    "        AliSimulation sim;\n"
		    "        sim.SetRunHLT(\"%s\");\n"
		    "        sim.SetRunGeneration(kFALSE);\n"
		    "        sim.SetMakeDigits(\"\");\n"
		    "        sim.SetMakeSDigits(\"\");\n"
		    "        sim.SetMakeDigitsFromHits(\"\");\n"
		    "        sim.Run();\n"
		    "        /*********************************************************/", option.Data()));
  }
  if (!fpPluginBase) {
    AliError("internal memory error: can not get AliHLTSystem instance from plugin");
    return;
  }

  AliHLTSystem* pSystem=fpPluginBase->GetInstance();
  if (pSystem) {
    if (pSystem->CheckStatus(AliHLTSystem::kError)) {
      AliError("HLT system in error state");
      return;
    }
    if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
      AliError("HLT system in wrong state");
      return;
    }

    AliHLTOUTDigitReader* pHLTOUT=new AliHLTOUTDigitReader(esd->GetEventNumberInFile(), fpEsdManager);
    if (pHLTOUT) {
      ProcessHLTOUT(pHLTOUT, esd);
      delete pHLTOUT;
    } else {
      AliError("error creating HLTOUT handler");
    }
  }
}

void AliHLTReconstructor::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd, bool bVerbose) const
{
  // treatment of simulated or real HLTOUT data
  if (!pHLTOUT) return;
  if (!fpPluginBase) {
    AliError("internal memory error: can not get AliHLTSystem instance from plugin");
    return;
  }

  AliHLTSystem* pSystem=fpPluginBase->GetInstance();
  if (!pSystem) {
    AliError("error getting HLT system instance");
    return;
  }

  if (pHLTOUT->Init()<0) {
    AliError("error : initialization of HLTOUT handler failed");
    return;
  }

  if (bVerbose)
    PrintHLTOUTContent(pHLTOUT);

  if (fFctProcessHLTOUT) {
    typedef int (*AliHLTSystemProcessHLTOUT)(AliHLTSystem* pInstance, AliHLTOUT* pHLTOUT, AliESDEvent* esd);
    AliHLTSystemProcessHLTOUT pFunc=(AliHLTSystemProcessHLTOUT)fFctProcessHLTOUT;
    if ((pFunc)(pSystem, pHLTOUT, esd)<0) {
      AliError("error processing HLTOUT");
    }
  }
  pHLTOUT->Reset();
}

void AliHLTReconstructor::ProcessHLTOUT(const char* digitFile, AliESDEvent* pEsd) const
{
  // debugging/helper function to examine simulated data
  if (!digitFile) return;

  // read the number of events
  TFile f(digitFile);
  if (f.IsZombie()) return;
  TTree* pTree=NULL;
  f.GetObject("rawhltout", pTree);
  if (!pTree) {
    AliWarning(Form("can not find tree rawhltout in file %s", digitFile));
    return ;
  }
  int nofEvents=pTree->GetEntries();
  f.Close();
  //delete pTree; OF COURSE NOT! its an object in the file
  pTree=NULL;

  for (int event=0; event<nofEvents; event++) {
    AliHLTOUTDigitReader* pHLTOUT=new AliHLTOUTDigitReader(event, fpEsdManager, digitFile);
    if (pHLTOUT) {
      AliInfo(Form("event %d", event));
      ProcessHLTOUT(pHLTOUT, pEsd, true);
      delete pHLTOUT;
    } else {
      AliError("error creating HLTOUT handler");
    }
  }
}

void AliHLTReconstructor::ProcessHLTOUT(AliRawReader* pRawReader, AliESDEvent* pEsd) const
{
  // debugging/helper function to examine simulated or real HLTOUT data
  if (!pRawReader) return;

  pRawReader->RewindEvents();
  for (int event=0; pRawReader->NextEvent(); event++) {
    AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(pRawReader, event, fpEsdManager);
    if (pHLTOUT) {
      AliInfo(Form("event %d", event));
      ProcessHLTOUT(pHLTOUT, pEsd, true);
      delete pHLTOUT;
    } else {
      AliError("error creating HLTOUT handler");
    }
  }
}

void AliHLTReconstructor::PrintHLTOUTContent(AliHLTOUT* pHLTOUT) const
{
  // print the block specifications of the HLTOUT data blocks
  if (!pHLTOUT) return;
  int iResult=0;

  for (iResult=pHLTOUT->SelectFirstDataBlock();
       iResult>=0;
       iResult=pHLTOUT->SelectNextDataBlock()) {
    AliHLTComponentDataType dt=kAliHLTVoidDataType;
    AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
    pHLTOUT->GetDataBlockDescription(dt, spec);
    const AliHLTUInt8_t* pBuffer=NULL;
    AliHLTUInt32_t size=0;
    if (pHLTOUT->GetDataBuffer(pBuffer, size)>=0) {
      pHLTOUT->ReleaseDataBuffer(pBuffer);
      pBuffer=NULL; // just a dummy
    }
    AliInfo(Form("   %s  0x%x: size %d", AliHLTComponent::DataType2Text(dt).c_str(), spec, size));
  }
}
Commit	Line	Data
	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	#include "AliHLTPluginBase.h"
	37
	38	ClassImp(AliHLTReconstructor)
	39
	40	AliHLTReconstructor::AliHLTReconstructor()
	41	:
	42	AliReconstructor(),
	43	fFctProcessHLTOUT(NULL),
	44	fpEsdManager(NULL),
	45	fpPluginBase(new AliHLTPluginBase)
	46	{
	47	//constructor
	48	}
	49
	50	AliHLTReconstructor::AliHLTReconstructor(const char* options)
	51	:
	52	AliReconstructor(),
	53	fFctProcessHLTOUT(NULL),
	54	fpEsdManager(NULL),
	55	fpPluginBase(new AliHLTPluginBase)
	56	{
	57	//constructor
	58	if (options) Init(options);
	59	}
	60
	61	AliHLTReconstructor::~AliHLTReconstructor()
	62	{
	63	//destructor
	64
	65	if (fpPluginBase) {
	66	AliHLTSystem* pSystem=fpPluginBase->GetInstance();
	67	if (pSystem) {
	68	AliDebug(0, Form("terminate HLT system: status %#x", pSystem->GetStatusFlags()));
	69	if (pSystem->CheckStatus(AliHLTSystem::kStarted)) {
	70	// send specific 'event' to execute the stop sequence
	71	pSystem->Reconstruct(0, NULL, NULL);
	72	}
	73	}
	74	delete fpPluginBase;
	75	}
	76	fpPluginBase=NULL;
	77
	78	if (fpEsdManager) AliHLTEsdManager::Delete(fpEsdManager);
	79	fpEsdManager=NULL;
	80	}
	81
	82	void AliHLTReconstructor::Init(const char* options)
	83	{
	84	// init the reconstructor
	85	SetOption(options);
	86	Init();
	87	}
	88
	89	void AliHLTReconstructor::Init()
	90	{
	91	// init the reconstructor
	92	if (!fpPluginBase) {
	93	AliError("internal memory error: can not get AliHLTSystem instance from plugin");
	94	return;
	95	}
	96
	97	AliHLTSystem* pSystem=fpPluginBase->GetInstance();
	98	if (!pSystem) {
	99	AliError("can not create AliHLTSystem object");
	100	return;
	101	}
	102	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
	103	AliError("HLT system in error state");
	104	return;
	105	}
	106
	107	// the options scan has been moved to AliHLTSystem, the old code
	108	// here is kept to be able to run an older version of the HLT code
	109	// with newer AliRoot versions.
	110	TString libs("");
	111	TString option = GetOption();
	112	TObjArray* pTokens=option.Tokenize(" ");
	113	option="";
	114	if (pTokens) {
	115	int iEntries=pTokens->GetEntries();
	116	for (int i=0; i<iEntries; i++) {
	117	TString token=(((TObjString*)pTokens->At(i))->GetString());
	118	if (token.Contains("loglevel=")) {
	119	TString param=token.ReplaceAll("loglevel=", "");
	120	if (param.IsDigit()) {
	121	pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
	122	} else if (param.BeginsWith("0x") &&
	123	param.Replace(0,2,"",0).IsHex()) {
	124	int severity=0;
	125	sscanf(param.Data(),"%x", &severity);
	126	pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
	127	} else {
	128	AliWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
	129	}
	130	} else if (token.Contains("alilog=off")) {
	131	pSystem->SwitchAliLog(0);
	132	} else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
	133	libs+=token;
	134	libs+=" ";
	135	} else {
	136	if (option.Length()>0) option+=" ";
	137	option+=token;
	138	}
	139	}
	140	delete pTokens;
	141	}
	142
	143	if (!libs.IsNull() &&
	144	(!pSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
	145	(pSystem->LoadComponentLibraries(libs.Data())<0)) {
	146	AliError("error while loading HLT libraries");
	147	return;
	148	}
	149
	150	if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
	151	typedef int (AliHLTSystemSetOptions)(AliHLTSystem pInstance, const char* options);
	152	gSystem->Load("libHLTinterface.so");
	153	AliHLTSystemSetOptions pFunc=(AliHLTSystemSetOptions)(gSystem->DynFindSymbol("libHLTinterface.so", "AliHLTSystemSetOptions"));
	154	if (pFunc) {
	155	if ((pFunc)(pSystem, option.Data())<0) {
	156	AliError("error setting options for HLT system");
	157	return;
	158	}
	159	} else if (option.Length()>0) {
	160	AliError(Form("version of HLT system does not support the options \'%s\'", option.Data()));
	161	return;
	162	}
	163	if ((pSystem->Configure())<0) {
	164	AliError("error during HLT system configuration");
	165	return;
	166	}
	167	}
	168
	169	gSystem->Load("libHLTinterface.so");
	170	fFctProcessHLTOUT=(void (*)())gSystem->DynFindSymbol("libHLTinterface.so", "AliHLTSystemProcessHLTOUT");
	171
	172	fpEsdManager=AliHLTEsdManager::New();
	173	}
	174
	175	void AliHLTReconstructor::Reconstruct(AliRawReader* rawReader, TTree* /clustersTree/) const
	176	{
	177	// reconstruction of real data without writing of ESD
	178	// For each event, HLT reconstruction chains can be executed and
	179	// added to the existing HLTOUT data
	180	// The HLTOUT data is finally processed in FillESD
	181	if (!fpPluginBase) {
	182	AliError("internal memory error: can not get AliHLTSystem instance from plugin");
	183	return;
	184	}
	185
	186	int iResult=0;
	187	AliHLTSystem* pSystem=fpPluginBase->GetInstance();
	188
	189	if (pSystem) {
	190	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
	191	AliError("HLT system in error state");
	192	return;
	193	}
	194	if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
	195	AliError("HLT system in wrong state");
	196	return;
	197	}
	198	if ((iResult=pSystem->Reconstruct(1, NULL, rawReader))>=0) {
	199	}
	200	}
	201	}
	202
	203	void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /clustersTree/,
	204	AliESDEvent* esd) const
	205	{
	206	// reconstruct real data and fill ESD
	207	if (!rawReader \|\| !esd) {
	208	AliError("missing raw reader or esd object");
	209	return;
	210	}
	211
	212	if (!fpPluginBase) {
	213	AliError("internal memory error: can not get AliHLTSystem instance from plugin");
	214	return;
	215	}
	216
	217	AliHLTSystem* pSystem=fpPluginBase->GetInstance();
	218
	219	if (pSystem) {
	220	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
	221	AliError("HLT system in error state");
	222	return;
	223	}
	224	if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
	225	AliError("HLT system in wrong state");
	226	return;
	227	}
	228	pSystem->FillESD(-1, NULL, esd);
	229
	230	AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(rawReader, esd->GetEventNumberInFile(), fpEsdManager);
	231	if (pHLTOUT) {
	232	ProcessHLTOUT(pHLTOUT, esd);
	233	delete pHLTOUT;
	234	} else {
	235	AliError("error creating HLTOUT handler");
	236	}
	237	}
	238	}
	239
	240	void AliHLTReconstructor::Reconstruct(TTree* /digitsTree/, TTree* /clustersTree/) const
	241	{
	242	// reconstruct simulated data
	243
	244	// all reconstruction has been moved to FillESD
	245	//AliReconstructor::Reconstruct(digitsTree,clustersTree);
	246	AliInfo("running digit data reconstruction");
	247	}
	248
	249	void AliHLTReconstructor::FillESD(TTree* /digitsTree/, TTree* /clustersTree/, AliESDEvent* esd) const
	250	{
	251	// reconstruct simulated data and fill ESD
	252
	253	// later this is the place to extract the simulated HLT data
	254	// for now it's only an user failure condition as he tries to run HLT reconstruction
	255	// on simulated data
	256	TString option = GetOption();
	257	if (!option.IsNull() &&
	258	(option.Contains("config=") \|\| option.Contains("chains="))) {
	259	AliWarning(Form("HLT reconstruction can be run embedded into Alireconstruction from\n"
	260	"raw data (real or simulated)). Reconstruction of of digit data takes\n"
	261	"place in AliSimulation, appropriate input conversion is needed.\n"
	262	"Consider running embedded into AliSimulation."
	263	" /* run macro ***************************************/\n"
	264	" AliSimulation sim;\n"
	265	" sim.SetRunHLT(\"%s\");\n"
	266	" sim.SetRunGeneration(kFALSE);\n"
	267	" sim.SetMakeDigits(\"\");\n"
	268	" sim.SetMakeSDigits(\"\");\n"
	269	" sim.SetMakeDigitsFromHits(\"\");\n"
	270	" sim.Run();\n"
	271	" /*********************************************************/", option.Data()));
	272	}
	273	if (!fpPluginBase) {
	274	AliError("internal memory error: can not get AliHLTSystem instance from plugin");
	275	return;
	276	}
	277
	278	AliHLTSystem* pSystem=fpPluginBase->GetInstance();
	279	if (pSystem) {
	280	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
	281	AliError("HLT system in error state");
	282	return;
	283	}
	284	if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
	285	AliError("HLT system in wrong state");
	286	return;
	287	}
	288
	289	AliHLTOUTDigitReader* pHLTOUT=new AliHLTOUTDigitReader(esd->GetEventNumberInFile(), fpEsdManager);
	290	if (pHLTOUT) {
	291	ProcessHLTOUT(pHLTOUT, esd);
	292	delete pHLTOUT;
	293	} else {
	294	AliError("error creating HLTOUT handler");
	295	}
	296	}
	297	}
	298
	299	void AliHLTReconstructor::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd, bool bVerbose) const
	300	{
	301	// treatment of simulated or real HLTOUT data
	302	if (!pHLTOUT) return;
	303	if (!fpPluginBase) {
	304	AliError("internal memory error: can not get AliHLTSystem instance from plugin");
	305	return;
	306	}
	307
	308	AliHLTSystem* pSystem=fpPluginBase->GetInstance();
	309	if (!pSystem) {
	310	AliError("error getting HLT system instance");
	311	return;
	312	}
	313
	314	if (pHLTOUT->Init()<0) {
	315	AliError("error : initialization of HLTOUT handler failed");
	316	return;
	317	}
	318
	319	if (bVerbose)
	320	PrintHLTOUTContent(pHLTOUT);
	321
	322	if (fFctProcessHLTOUT) {
	323	typedef int (AliHLTSystemProcessHLTOUT)(AliHLTSystem pInstance, AliHLTOUT* pHLTOUT, AliESDEvent* esd);
	324	AliHLTSystemProcessHLTOUT pFunc=(AliHLTSystemProcessHLTOUT)fFctProcessHLTOUT;
	325	if ((pFunc)(pSystem, pHLTOUT, esd)<0) {
	326	AliError("error processing HLTOUT");
	327	}
	328	}
	329	pHLTOUT->Reset();
	330	}
	331
	332	void AliHLTReconstructor::ProcessHLTOUT(const char* digitFile, AliESDEvent* pEsd) const
	333	{
	334	// debugging/helper function to examine simulated data
	335	if (!digitFile) return;
	336
	337	// read the number of events
	338	TFile f(digitFile);
	339	if (f.IsZombie()) return;
	340	TTree* pTree=NULL;
	341	f.GetObject("rawhltout", pTree);
	342	if (!pTree) {
	343	AliWarning(Form("can not find tree rawhltout in file %s", digitFile));
	344	return ;
	345	}
	346	int nofEvents=pTree->GetEntries();
	347	f.Close();
	348	//delete pTree; OF COURSE NOT! its an object in the file
	349	pTree=NULL;
	350
	351	for (int event=0; event<nofEvents; event++) {
	352	AliHLTOUTDigitReader* pHLTOUT=new AliHLTOUTDigitReader(event, fpEsdManager, digitFile);
	353	if (pHLTOUT) {
	354	AliInfo(Form("event %d", event));
	355	ProcessHLTOUT(pHLTOUT, pEsd, true);
	356	delete pHLTOUT;
	357	} else {
	358	AliError("error creating HLTOUT handler");
	359	}
	360	}
	361	}
	362
	363	void AliHLTReconstructor::ProcessHLTOUT(AliRawReader* pRawReader, AliESDEvent* pEsd) const
	364	{
	365	// debugging/helper function to examine simulated or real HLTOUT data
	366	if (!pRawReader) return;
	367
	368	pRawReader->RewindEvents();
	369	for (int event=0; pRawReader->NextEvent(); event++) {
	370	AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(pRawReader, event, fpEsdManager);
	371	if (pHLTOUT) {
	372	AliInfo(Form("event %d", event));
	373	ProcessHLTOUT(pHLTOUT, pEsd, true);
	374	delete pHLTOUT;
	375	} else {
	376	AliError("error creating HLTOUT handler");
	377	}
	378	}
	379	}
	380
	381	void AliHLTReconstructor::PrintHLTOUTContent(AliHLTOUT* pHLTOUT) const
	382	{
	383	// print the block specifications of the HLTOUT data blocks
	384	if (!pHLTOUT) return;
	385	int iResult=0;
	386
	387	for (iResult=pHLTOUT->SelectFirstDataBlock();
	388	iResult>=0;
	389	iResult=pHLTOUT->SelectNextDataBlock()) {
	390	AliHLTComponentDataType dt=kAliHLTVoidDataType;
	391	AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
	392	pHLTOUT->GetDataBlockDescription(dt, spec);
	393	const AliHLTUInt8_t* pBuffer=NULL;
	394	AliHLTUInt32_t size=0;
	395	if (pHLTOUT->GetDataBuffer(pBuffer, size)>=0) {
	396	pHLTOUT->ReleaseDataBuffer(pBuffer);
	397	pBuffer=NULL; // just a dummy
	398	}
	399	AliInfo(Form(" %s 0x%x: size %d", AliHLTComponent::DataType2Text(dt).c_str(), spec, size));
	400	}
	401	}