[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"

ClassImp(AliHLTReconstructor)

AliHLTReconstructor::AliHLTReconstructor()
  : 
  AliReconstructor(),
  AliHLTReconstructorBase(),
  fFctProcessHLTOUT(NULL),
  fpEsdManager(NULL)
{ 
  //constructor
}

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

AliHLTReconstructor::~AliHLTReconstructor()
{ 
  //destructor

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

  AliHLTSystem* pSystem=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()));
  }
  AliHLTSystem* pSystem=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;
  AliHLTSystem* pSystem=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
3e820254	1	// $Id$
3e820254	2
c5123824	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	//**************************************************************************
c534985b	18
3a7c0444	19	/** @file AliHLTReconstructor.cxx
c534985b	20	@author Matthias Richter
	21	@date
	22	@brief Binding class for HLT reconstruction in AliRoot. */
3e820254	23
	24	#include <TSystem.h>
	25	#include <TObjString.h>
032c5e5e	26	#include "TFile.h"
032c5e5e	27	#include "TTree.h"
3e820254	28	#include "AliHLTReconstructor.h"
3e820254	29	#include "AliLog.h"
032c5e5e	30	#include "AliRawReader.h"
c5123824	31	#include "AliESDEvent.h"
3e820254	32	#include "AliHLTSystem.h"
c5123824	33	#include "AliHLTOUTRawReader.h"
	34	#include "AliHLTOUTDigitReader.h"
	35	#include "AliHLTEsdManager.h"
3e820254	36
	37	ClassImp(AliHLTReconstructor)
	38
	39	AliHLTReconstructor::AliHLTReconstructor()
	40	:
	41	AliReconstructor(),
c5123824	42	AliHLTReconstructorBase(),
	43	fFctProcessHLTOUT(NULL),
	44	fpEsdManager(NULL)
3e820254	45	{
	46	//constructor
	47	}
	48
032c5e5e	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
3e820254	60	AliHLTReconstructor::~AliHLTReconstructor()
	61	{
	62	//destructor
dee38f1b	63
a3ef3c1d	64	AliHLTSystem* pSystem=GetInstance();
	65	if (pSystem) {
	66	AliDebug(0, Form("delete HLT system: status %#x", pSystem->GetStatusFlags()));
3dd8541e	67	if (pSystem->CheckStatus(AliHLTSystem::kStarted)) {
dee38f1b	68	// send specific 'event' to execute the stop sequence
a3ef3c1d	69	pSystem->Reconstruct(0, NULL, NULL);
dee38f1b	70	}
3e820254	71	}
c5123824	72
f1207f29	73	if (fpEsdManager) AliHLTEsdManager::Delete(fpEsdManager);
c5123824	74	fpEsdManager=NULL;
3e820254	75	}
3e820254	76
032c5e5e	77	void AliHLTReconstructor::Init(const char* options)
	78	{
	79	// init the reconstructor
	80	SetOption(options);
	81	Init();
	82	}
	83
3e820254	84	void AliHLTReconstructor::Init()
	85	{
	86	// init the reconstructor
a3ef3c1d	87	AliHLTSystem* pSystem=GetInstance();
a3ef3c1d	88	if (!pSystem) {
3e820254	89	AliError("can not create AliHLTSystem object");
	90	return;
	91	}
a3ef3c1d	92	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
3e820254	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()) {
a3ef3c1d	111	pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
3e820254	112	} else if (param.BeginsWith("0x") &&
	113	param.Replace(0,2,"",0).IsHex()) {
	114	int severity=0;
	115	sscanf(param.Data(),"%x", &severity);
a3ef3c1d	116	pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
3e820254	117	} else {
	118	AliWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
	119	}
	120	} else if (token.Contains("alilog=off")) {
a3ef3c1d	121	pSystem->SwitchAliLog(0);
3e820254	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	}
7f9ab840	132
3e820254	133	if (!libs.IsNull() &&
a3ef3c1d	134	(!pSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
a3ef3c1d	135	(pSystem->LoadComponentLibraries(libs.Data())<0)) {
3e820254	136	AliError("error while loading HLT libraries");
	137	return;
	138	}
	139
a3ef3c1d	140	if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
3e820254	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) {
a3ef3c1d	145	if ((pFunc)(pSystem, option.Data())<0) {
3e820254	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	}
a3ef3c1d	153	if ((pSystem->Configure())<0) {
3e820254	154	AliError("error during HLT system configuration");
	155	return;
	156	}
	157	}
c5123824	158
	159	gSystem->Load("libHLTinterface.so");
	160	fFctProcessHLTOUT=gSystem->DynFindSymbol("libHLTinterface.so", "AliHLTSystemProcessHLTOUT");
	161
f1207f29	162	fpEsdManager=AliHLTEsdManager::New();
3e820254	163	}
3e820254	164
06995b88	165	void AliHLTReconstructor::Reconstruct(AliRawReader* rawReader, TTree* /clustersTree/) const
3e820254	166	{
3e820254	167	// reconstruction of real data without writing of ESD
c5123824	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
3e820254	171	int iResult=0;
a3ef3c1d	172	AliHLTSystem* pSystem=GetInstance();
06995b88	173
a3ef3c1d	174	if (pSystem) {
a3ef3c1d	175	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
3e820254	176	AliError("HLT system in error state");
	177	return;
	178	}
a3ef3c1d	179	if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
3e820254	180	AliError("HLT system in wrong state");
	181	return;
	182	}
a3ef3c1d	183	if ((iResult=pSystem->Reconstruct(1, NULL, rawReader))>=0) {
c5123824	184	}
c5123824	185	}
06995b88	186	}
	187
	188	void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /clustersTree/,
	189	AliESDEvent* esd) const
	190	{
	191	// reconstruct real data and fill ESD
	192	if (!rawReader \|\| !esd) {
	193	AliError("missing raw reader or esd object");
	194	return;
	195	}
	196
	197	AliHLTSystem* pSystem=GetInstance();
c5123824	198
	199	if (pSystem) {
	200	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
	201	AliError("HLT system in error state");
	202	return;
	203	}
	204	if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
	205	AliError("HLT system in wrong state");
	206	return;
	207	}
	208	pSystem->FillESD(-1, NULL, esd);
	209
	210	AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(rawReader, esd->GetEventNumberInFile(), fpEsdManager);
	211	if (pHLTOUT) {
	212	ProcessHLTOUT(pHLTOUT, esd);
f94e8c27	213	delete pHLTOUT;
c5123824	214	} else {
c5123824	215	AliError("error creating HLTOUT handler");
3e820254	216	}
	217	}
	218	}
7f9ab840	219
29312178	220	void AliHLTReconstructor::Reconstruct(TTree* /digitsTree/, TTree* /clustersTree/) const
7f9ab840	221	{
	222	// reconstruct simulated data
	223
	224	// all reconstruction has been moved to FillESD
	225	//AliReconstructor::Reconstruct(digitsTree,clustersTree);
032c5e5e	226	AliInfo("running digit data reconstruction");
7f9ab840	227	}
7f9ab840	228
c5123824	229	void AliHLTReconstructor::FillESD(TTree* /digitsTree/, TTree* /clustersTree/, AliESDEvent* esd) const
7f9ab840	230	{
	231	// reconstruct simulated data and fill ESD
	232
	233	// later this is the place to extract the simulated HLT data
	234	// for now it's only an user failure condition as he tries to run HLT reconstruction
	235	// on simulated data
	236	TString option = GetOption();
c5123824	237	if (!option.IsNull() &&
c5123824	238	(option.Contains("config=") \|\| option.Contains("chains="))) {
f8e0e3d3	239	AliWarning(Form("HLT reconstruction can be run embedded into Alireconstruction from\n"
	240	"raw data (real or simulated)). Reconstruction of of digit data takes\n"
	241	"place in AliSimulation, appropriate input conversion is needed.\n"
	242	"Consider running embedded into AliSimulation."
7f9ab840	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	}
c5123824	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);
f94e8c27	267	delete pHLTOUT;
c5123824	268	} else {
	269	AliError("error creating HLTOUT handler");
	270	}
	271	}
	272	}
	273
b005ef92	274	void AliHLTReconstructor::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd, bool bVerbose) const
c5123824	275	{
f94e8c27	276	// treatment of simulated or real HLTOUT data
c5123824	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
b005ef92	289	if (bVerbose)
	290	PrintHLTOUTContent(pHLTOUT);
	291
c5123824	292	if (fFctProcessHLTOUT) {
	293	typedef int (AliHLTSystemProcessHLTOUT)(AliHLTSystem pInstance, AliHLTOUT* pHLTOUT, AliESDEvent* esd);
	294	AliHLTSystemProcessHLTOUT pFunc=(AliHLTSystemProcessHLTOUT)fFctProcessHLTOUT;
	295	if ((pFunc)(pSystem, pHLTOUT, esd)<0) {
	296	AliError("error processing HLTOUT");
	297	}
	298	}
b005ef92	299	pHLTOUT->Reset();
7f9ab840	300	}
032c5e5e	301
	302	void AliHLTReconstructor::ProcessHLTOUT(const char* digitFile, AliESDEvent* pEsd) const
	303	{
	304	// debugging/helper function to examine simulated data
	305	if (!digitFile) return;
	306
	307	// read the number of events
	308	TFile f(digitFile);
	309	if (f.IsZombie()) return;
	310	TTree* pTree=NULL;
	311	f.GetObject("rawhltout", pTree);
	312	if (!pTree) {
	313	AliWarning(Form("can not find tree rawhltout in file %s", digitFile));
	314	return ;
	315	}
	316	int nofEvents=pTree->GetEntries();
	317	f.Close();
	318	//delete pTree; OF COURSE NOT! its an object in the file
	319	pTree=NULL;
	320
	321	for (int event=0; event<nofEvents; event++) {
	322	AliHLTOUTDigitReader* pHLTOUT=new AliHLTOUTDigitReader(event, fpEsdManager, digitFile);
	323	if (pHLTOUT) {
	324	AliInfo(Form("event %d", event));
b005ef92	325	ProcessHLTOUT(pHLTOUT, pEsd, true);
032c5e5e	326	delete pHLTOUT;
	327	} else {
	328	AliError("error creating HLTOUT handler");
	329	}
	330	}
	331	}
	332
	333	void AliHLTReconstructor::ProcessHLTOUT(AliRawReader* pRawReader, AliESDEvent* pEsd) const
	334	{
	335	// debugging/helper function to examine simulated or real HLTOUT data
	336	if (!pRawReader) return;
	337
	338	pRawReader->RewindEvents();
	339	for (int event=0; pRawReader->NextEvent(); event++) {
	340	AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(pRawReader, event, fpEsdManager);
	341	if (pHLTOUT) {
	342	AliInfo(Form("event %d", event));
b005ef92	343	ProcessHLTOUT(pHLTOUT, pEsd, true);
032c5e5e	344	delete pHLTOUT;
	345	} else {
	346	AliError("error creating HLTOUT handler");
	347	}
	348	}
	349	}
	350
	351	void AliHLTReconstructor::PrintHLTOUTContent(AliHLTOUT* pHLTOUT) const
	352	{
	353	// print the block specifications of the HLTOUT data blocks
	354	if (!pHLTOUT) return;
	355	int iResult=0;
	356
	357	for (iResult=pHLTOUT->SelectFirstDataBlock();
	358	iResult>=0;
	359	iResult=pHLTOUT->SelectNextDataBlock()) {
	360	AliHLTComponentDataType dt=kAliHLTVoidDataType;
	361	AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
	362	pHLTOUT->GetDataBlockDescription(dt, spec);
	363	const AliHLTUInt8_t* pBuffer=NULL;
	364	AliHLTUInt32_t size=0;
	365	if (pHLTOUT->GetDataBuffer(pBuffer, size)>=0) {
	366	pHLTOUT->ReleaseDataBuffer(pBuffer);
	367	pBuffer=NULL; // just a dummy
	368	}
	369	AliInfo(Form(" %s 0x%x: size %d", AliHLTComponent::DataType2Text(dt).c_str(), spec, size));
	370	}
	371	}