[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) 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=new AliHLTEsdManager;
}

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
  AliHLTSystem* pSystem=GetInstance();
  AliInfo("running raw data reconstruction");
}

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;
  }

  //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // code needs to be moved back to Reconstruct as soon es HLT loader is implemented
  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) {
    }
  }
  //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

  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 of simulated data takes place in AliSimulation\n"
		    "        /***  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) 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 (fFctProcessHLTOUT) {
    typedef int (*AliHLTSystemProcessHLTOUT)(AliHLTSystem* pInstance, AliHLTOUT* pHLTOUT, AliESDEvent* esd);
    AliHLTSystemProcessHLTOUT pFunc=(AliHLTSystemProcessHLTOUT)fFctProcessHLTOUT;
    if ((pFunc)(pSystem, pHLTOUT, esd)<0) {
      AliError("error processing HLTOUT");
    }
  }
}

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);
      PrintHLTOUTContent(pHLTOUT);
      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);
      PrintHLTOUTContent(pHLTOUT);
      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
	73	if (fpEsdManager) delete fpEsdManager;
	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
	162	fpEsdManager=new AliHLTEsdManager;
3e820254	163	}
	164
	165	void AliHLTReconstructor::Reconstruct(AliRawReader* /rawReader/, TTree* /clustersTree/) const
	166	{
	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
	171	AliHLTSystem* pSystem=GetInstance();
032c5e5e	172	AliInfo("running raw data reconstruction");
3e820254	173	}
	174
	175	void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /clustersTree/,
	176	AliESDEvent* esd) const
	177	{
	178	// reconstruct real data and fill ESD
c5123824	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
3e820254	186	int iResult=0;
a3ef3c1d	187	AliHLTSystem* pSystem=GetInstance();
	188	if (pSystem) {
	189	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
3e820254	190	AliError("HLT system in error state");
	191	return;
	192	}
a3ef3c1d	193	if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
3e820254	194	AliError("HLT system in wrong state");
	195	return;
	196	}
a3ef3c1d	197	if ((iResult=pSystem->Reconstruct(1, NULL, rawReader))>=0) {
c5123824	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);
f94e8c27	216	delete pHLTOUT;
c5123824	217	} else {
c5123824	218	AliError("error creating HLTOUT handler");
3e820254	219	}
	220	}
	221	}
7f9ab840	222
29312178	223	void AliHLTReconstructor::Reconstruct(TTree* /digitsTree/, TTree* /clustersTree/) const
7f9ab840	224	{
	225	// reconstruct simulated data
	226
	227	// all reconstruction has been moved to FillESD
	228	//AliReconstructor::Reconstruct(digitsTree,clustersTree);
032c5e5e	229	AliInfo("running digit data reconstruction");
7f9ab840	230	}
7f9ab840	231
c5123824	232	void AliHLTReconstructor::FillESD(TTree* /digitsTree/, TTree* /clustersTree/, AliESDEvent* esd) const
7f9ab840	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();
c5123824	240	if (!option.IsNull() &&
c5123824	241	(option.Contains("config=") \|\| option.Contains("chains="))) {
7f9ab840	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	}
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
	274	void AliHLTReconstructor::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd) const
	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
	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	}
7f9ab840	296	}
032c5e5e	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	}