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

// $Id$

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// class for HLT reconstruction                                              //
// <Cvetan.Cheshkov@cern.ch>                                                 //
// <loizides@ikf.uni-frankfurt.de>                                           //
///////////////////////////////////////////////////////////////////////////////

// very ugly but it has to work fast
#ifdef use_reconstruction

#include <Riostream.h>
#include <TSystem.h>
#include <TArrayF.h>
#include <TObjString.h>

#include <AliRunLoader.h>
#include <AliHeader.h>
#include <AliGenEventHeader.h>
#include <AliESD.h>
#include <AliESDHLTtrack.h>

#include "AliHLTStandardIncludes.h"
#include "AliHLTLogging.h"
#include "AliLevel3.h"
#include "AliHLTEvaluate.h"
#include "AliHLTReconstructor.h"
#include "AliHLTTransform.h"
#include "AliHLTHough.h"
#include "AliHLTFileHandler.h"
#include "AliHLTTrack.h"
#include "AliHLTHoughTrack.h"
#include "AliHLTTrackArray.h"

#include "AliLog.h"
#include "AliRun.h"
#include "AliITS.h"
#include "AliHLTITStracker.h"
#include "AliHLTTPCtracker.h"
#include "MUON/src/AliRoot/AliHLTMUONTracker.h"
#include "MUON/src/AliRoot/AliHLTMUONHitReconstructor.h"
#include "AliRawReader.h"
#include "AliHLTSystem.h"

#if __GNUC__== 3
using namespace std;
#endif

const char* kHLTDefaultLibs[]= {
  "libAliHLTUtil.so", 
  "libAliHLTTPC.so", 
  //  "libAliHLTSample.so",
  "libAliHLTPHOS.so",
  NULL
};

ClassImp(AliHLTReconstructor)

AliHLTReconstructor::AliHLTReconstructor()
  : 
  AliReconstructor(),
  fDoHough(0),
  fDoTracker(1),
  fDoBench(0),
  fDoCleanUp(0),
  fpSystem(NULL)
{ 
  //constructor
#ifndef use_logging
  AliHLTLog::fgLevel=AliHLTLog::kWarning;
#endif
}

AliHLTReconstructor::AliHLTReconstructor(Bool_t doTracker, Bool_t doHough)
  : 
  AliReconstructor(),
  fDoHough(doHough),
  fDoTracker(doTracker),
  fDoBench(0),
  fDoCleanUp(0),
  fpSystem(new AliHLTSystem)
{
  //constructor
#ifndef use_logging
  AliHLTLog::fgLevel=AliHLTLog::kWarning;
#endif
}

AliHLTReconstructor::AliHLTReconstructor(const AliHLTReconstructor&)
  :
  AliReconstructor(),
  fDoHough(0),
  fDoTracker(0),
  fDoBench(0),
  fDoCleanUp(0),
  fpSystem(NULL)
{
  // not a valid copy constructor
}

AliHLTReconstructor& AliHLTReconstructor::operator=(const AliHLTReconstructor&)
{
  // not a valid assignment operator
  fDoHough=0;
  fDoTracker=0;
  fDoBench=0;
  fDoCleanUp=0;
  fpSystem=NULL;
  return *this;
}

AliHLTReconstructor::~AliHLTReconstructor()
{ 
  //destructor
  if(fDoCleanUp){
    char name[256];
    gSystem->Exec("rm -rf hlt");
    sprintf(name, "rm -f confmap_*.root confmap_*.dat");
    gSystem->Exec(name);
    gSystem->Exec("rm -rf hough");
    sprintf(name, "rm -f hough_*.root hough_*.dat");
    gSystem->Exec(name);
  }
  if (fpSystem) {
    delete fpSystem;
  }
  fpSystem=NULL;
}

void AliHLTReconstructor::Init(AliRunLoader* runLoader)
{
  // init the reconstructor
  if(!runLoader) {
    AliError("Missing RunLoader! 0x0");
    return;
  }

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

  TString libs("");
  TString option = GetOption();
  TObjArray* pTokens=option.Tokenize(" ");
  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()) {
	  fpSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
	} else if (param.BeginsWith("0x") &&
		   param.Replace(0,2,"",0).IsHex()) {
	  int severity=0;
	  sscanf(param.Data(),"%x", &severity);
	  fpSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
	} else {
	  AliWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
	}
      } else if (token.Contains("alilog=off")) {
	fpSystem->SwitchAliLog(0);
      } else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
	libs+=token;
	libs+=" ";
      } else {
	AliWarning(Form("unknown option: %s", token.Data()));
      }
    }
    delete pTokens;
  }
  
  Bool_t bForceLibLoad=0;
  if (bForceLibLoad=(libs.IsNull())) {
    const char** deflib=kHLTDefaultLibs;
    while (*deflib) {
      libs+=*deflib++;
      libs+=" ";
    }
  }
  if ((bForceLibLoad || !fpSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
      (fpSystem->LoadComponentLibraries(libs.Data())<0)) {
    AliError("error while loading HLT libraries");
    return;
  }
  if (!fpSystem->CheckStatus(AliHLTSystem::kReady) &&
      (fpSystem->Configure(runLoader))<0) {
    AliError("error during HLT system configuration");
    return;
  }
}

void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader) const
{
  // reconstruction of simulated data
  Reconstruct(runLoader, NULL);
}

void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const 
{
  // reconstruction of real data if rawReader!=NULL
  if(!runLoader) {
    AliError("Missing RunLoader! 0x0");
    return;
  }

  Int_t nEvents = runLoader->GetNumberOfEvents();
  int iResult=0;

  if (fpSystem) {
    if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
      AliError("HLT system in error state");
      return;
    }
    if ((iResult=fpSystem->Reconstruct(nEvents, runLoader, rawReader))>=0) {
    }
  }
}

void AliHLTReconstructor::ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const
{
  // reconstruct with conformal mapper
  AliLevel3 *fHLT = new AliLevel3(runLoader);
  fHLT->Init("./", AliLevel3::kRunLoader, 1);

  Int_t phiSegments = 50;
  Int_t etaSegments = 100;
  Int_t trackletlength = 3;
  Int_t tracklength = 10;
  Int_t rowscopetracklet = 2;
  Int_t rowscopetrack = 10;
  Double_t minPtFit = 0;
  Double_t maxangle = 0.1745;
  Double_t goodDist = 5;
  Double_t maxphi = 0.1;
  Double_t maxeta = 0.1;
  Double_t hitChi2Cut = 20;
  Double_t goodHitChi2 = 5;
  Double_t trackChi2Cut = 10;
  Double_t xyerror = -1;
  Double_t zerror =  -1;
  
  fHLT->SetClusterFinderParam(xyerror,zerror,kTRUE);
  fHLT->SetTrackerParam(phiSegments, etaSegments, 
			trackletlength, tracklength,
			rowscopetracklet, rowscopetrack,
			minPtFit, maxangle, goodDist, hitChi2Cut,
			goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE);
  fHLT->SetTrackerParam(phiSegments, etaSegments, 
			trackletlength, tracklength,
			rowscopetracklet, rowscopetrack,
			minPtFit, maxangle, goodDist, hitChi2Cut,
			goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kFALSE);
  fHLT->SetMergerParameters(2,3,0.003,0.1,0.05);
  fHLT->DoMc();
  fHLT->DoNonVertexTracking(); /*2 tracking passes, last without vertex contraint.*/
  fHLT->WriteFiles("./hlt/");  
  fHLT->ProcessEvent(0, 35, iEvent);
  if(fDoBench){
    char filename[256];
    sprintf(filename, "confmap_%d",iEvent);
    fHLT->DoBench(filename);
  }

  delete fHLT;
}

void AliHLTReconstructor::ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const
{
  //reconstruct with hough
  //not used anymore, Hough tracking is moved out of the local
  //reconstruction chain
  Float_t ptmin = 0.1*AliHLTTransform::GetSolenoidField();

  Float_t zvertex = 0;
  TArrayF mcVertex(3); 
  AliHeader * header = runLoader->GetHeader();
  if (header) {
    AliGenEventHeader * genHeader = header->GenEventHeader();
    if (genHeader) genHeader->PrimaryVertex(mcVertex);
  }
  zvertex = mcVertex[2];

  LOG(AliHLTLog::kInformational,"AliHLTReconstructor::Reconstruct","HoughTransform")
    <<" Hough Transform will run with ptmin="<<ptmin<<" and zvertex="<<zvertex<<ENDLOG;

  AliHLTHough *hough = new AliHLTHough();
    
  hough->SetThreshold(4);
  hough->CalcTransformerParams(ptmin);
  hough->SetPeakThreshold(70,-1);
  hough->SetRunLoader(runLoader);
  hough->Init("./", kFALSE, 100, kFALSE,4,0,0,zvertex);
  hough->SetAddHistograms();

  for(Int_t slice=0; slice<=35; slice++)
    {
      //cout<<"Processing slice "<<slice<<endl;
      hough->ReadData(slice,iEvent);
      hough->Transform();
      hough->AddAllHistogramsRows();
      hough->FindTrackCandidatesRow();
      //hough->WriteTracks(slice,"./hough");
      hough->AddTracks();
    }
  hough->WriteTracks("./hough");
  
  if(fDoBench){
    char filename[256];
    sprintf(filename, "hough_%d",iEvent);
    hough->DoBench(filename);
  }
  delete hough;
}

void AliHLTReconstructor::FillESD(AliRunLoader* runLoader, 
				  AliESD* esd) const
{
  //fill the esd file with found tracks
  if(!runLoader) {
    AliError("Missing RunLoader! 0x0");
    return;
  }
  Int_t iEvent = runLoader->GetEventNumber();
  if (fpSystem) {
    if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
      AliError("HLT system in error state");
      return;
    }
    if (!fpSystem->CheckStatus(AliHLTSystem::kReady)) {
      AliError("HLT system in wrong state");
      return;
    }
    fpSystem->FillESD(iEvent, runLoader, esd);
  }
  /*
  if(fDoTracker) FillESDforConformalMapping(esd,iEvent);
  if(fDoHough) FillESDforHoughTransform(esd,iEvent);
  */
}

void AliHLTReconstructor::FillESDforConformalMapping(AliESD* esd,Int_t iEvent) const
{
  //fill esd with tracks from conformal mapping
  Int_t slicerange[2]={0,35};
  Int_t good = (int)(0.4*AliHLTTransform::GetNRows());
  Int_t nclusters = (int)(0.4*AliHLTTransform::GetNRows());
  Int_t nminpointsontracks = (int)(0.3*AliHLTTransform::GetNRows());
  Float_t ptmin = 0.;
  Float_t ptmax = 0.;
  Float_t maxfalseratio = 0.1;
  
  AliHLTEvaluate *fHLTEval = new AliHLTEvaluate("./hlt",nclusters,good,ptmin,ptmax,slicerange);
  fHLTEval->SetMaxFalseClusters(maxfalseratio);
  fHLTEval->LoadData(iEvent,kTRUE);
  fHLTEval->AssignPIDs();
  fHLTEval->AssignIDs();
  AliHLTTrackArray *fTracks = fHLTEval->GetTracks();
  if(!fTracks){
    delete fHLTEval;
    return;
  }
  for(Int_t i=0; i<fTracks->GetNTracks(); i++)
    {
      AliHLTTrack *tpt = (AliHLTTrack *)fTracks->GetCheckedTrack(i);
      if(!tpt) continue; 
      if(tpt->GetNumberOfPoints() < nminpointsontracks) continue;
      
      AliESDHLTtrack *esdtrack = new AliESDHLTtrack() ; 

      esdtrack->SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
      esdtrack->SetNHits(tpt->GetNHits());
      esdtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
      esdtrack->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ());
      esdtrack->SetPt(tpt->GetPt());
      esdtrack->SetPsi(tpt->GetPsi());
      esdtrack->SetTgl(tpt->GetTgl());
      esdtrack->SetCharge(tpt->GetCharge());
      esdtrack->SetMCid(tpt->GetMCid());
      esdtrack->SetSector(tpt->GetSector());
      esdtrack->SetPID(tpt->GetPID());
      esdtrack->ComesFromMainVertex(tpt->ComesFromMainVertex());

      esd->AddHLTConfMapTrack(esdtrack);
      delete esdtrack;
    }
  delete fHLTEval;
}

void AliHLTReconstructor::FillESDforHoughTransform(AliESD* esd,Int_t iEvent) const
{
  //fill esd with tracks from hough
  char filename[256];
  sprintf(filename,"./hough/tracks_%d.raw",iEvent);
  
  AliHLTFileHandler *tfile = new AliHLTFileHandler();
  if(!tfile->SetBinaryInput(filename)){
    LOG(AliHLTLog::kError,"AliHLTReconstructor::FillESDforHoughTransform","Input file")
      <<" Missing file "<<filename<<ENDLOG;
    return;
  }
  
  AliHLTTrackArray *fTracks = new AliHLTTrackArray("AliHLTHoughTrack");
  tfile->Binary2TrackArray(fTracks);
  tfile->CloseBinaryInput();
  delete tfile;
  if(!fTracks) return; 
  for(Int_t i=0; i<fTracks->GetNTracks(); i++)
    {
      AliHLTHoughTrack *tpt = (AliHLTHoughTrack *)fTracks->GetCheckedTrack(i);
      if(!tpt) continue; 
      
      AliESDHLTtrack *esdtrack = new AliESDHLTtrack() ; 

      esdtrack->SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
      esdtrack->SetNHits(tpt->GetNHits());
      esdtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
      esdtrack->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ());
      esdtrack->SetPt(tpt->GetPt());
      esdtrack->SetPsi(tpt->GetPsi());
      esdtrack->SetTgl(tpt->GetTgl());
      esdtrack->SetCharge(tpt->GetCharge());
      esdtrack->SetMCid(tpt->GetMCid());
      esdtrack->SetWeight(tpt->GetWeight());
      esdtrack->SetSector(tpt->GetSector());
      esdtrack->SetBinXY(tpt->GetBinX(),tpt->GetBinY(),tpt->GetSizeX(),tpt->GetSizeY());
      esdtrack->SetPID(tpt->GetPID());
      esdtrack->ComesFromMainVertex(tpt->ComesFromMainVertex());

      esd->AddHLTHoughTrack(esdtrack);
      delete esdtrack;
    }

  delete fTracks;
}

AliTracker* AliHLTReconstructor::CreateTracker(AliRunLoader* runLoader) const
{
  //Create HLT trackers for TPC and ITS

  TString opt = GetOption();
  if(!opt.CompareTo("TPC")) {
    // Create Hough tracker for TPC
    return new AliHLTTPCtracker(runLoader);
  }
  if(!opt.CompareTo("ITS")) {
    // Create ITS tracker
    return new AliHLTITStracker(0);
  }
  if(!opt.CompareTo("MUON")) {
    return new AliHLTMUONTracker(runLoader);
  }

  return NULL;
}

void AliHLTReconstructor::FillDHLTRecPoint(AliRawReader* rawReader, Int_t nofEvent, Int_t dcCut = 0) const
{
  // Hit recontruction for dimuon-HLT
  AliHLTMUONHitReconstructor kdHLTRec(rawReader);

  Int_t iEvent = 0 ;
  kdHLTRec.SetDCCut(dcCut);
  TString lookupTablePath = getenv("ALICE_ROOT");
  lookupTablePath += "/HLT/MUON/src/AliRoot/Lut";
  kdHLTRec.Init(lookupTablePath.Data(),lookupTablePath.Data());

   while(rawReader->NextEvent() && iEvent < nofEvent){
     AliInfo(Form("Event : %d",iEvent));
     kdHLTRec.WriteDHLTRecHits(iEvent);  
     iEvent++;
   }

}

#endif
Commit	Line	Data
de3c3890	1	// $Id$
	2
	3	///////////////////////////////////////////////////////////////////////////////
	4	// //
	5	// class for HLT reconstruction //
	6	// <Cvetan.Cheshkov@cern.ch> //
2456c180	7	// <loizides@ikf.uni-frankfurt.de> //
de3c3890	8	///////////////////////////////////////////////////////////////////////////////
	9
	10	// very ugly but it has to work fast
	11	#ifdef use_reconstruction
	12
	13	#include <Riostream.h>
	14	#include <TSystem.h>
	15	#include <TArrayF.h>
9b4aa2e5	16	#include <TObjString.h>
de3c3890	17
b1ed0288	18	#include <AliRunLoader.h>
	19	#include <AliHeader.h>
	20	#include <AliGenEventHeader.h>
	21	#include <AliESD.h>
	22	#include <AliESDHLTtrack.h>
	23
4aa41877	24	#include "AliHLTStandardIncludes.h"
4aa41877	25	#include "AliHLTLogging.h"
de3c3890	26	#include "AliLevel3.h"
4aa41877	27	#include "AliHLTEvaluate.h"
de3c3890	28	#include "AliHLTReconstructor.h"
4aa41877	29	#include "AliHLTTransform.h"
	30	#include "AliHLTHough.h"
	31	#include "AliHLTFileHandler.h"
	32	#include "AliHLTTrack.h"
	33	#include "AliHLTHoughTrack.h"
	34	#include "AliHLTTrackArray.h"
de3c3890	35
9b4aa2e5	36	#include "AliLog.h"
f644512a	37	#include "AliRun.h"
f644512a	38	#include "AliITS.h"
4aa41877	39	#include "AliHLTITStracker.h"
4aa41877	40	#include "AliHLTTPCtracker.h"
43f15f99	41	#include "MUON/src/AliRoot/AliHLTMUONTracker.h"
8a296f1c	42	#include "MUON/src/AliRoot/AliHLTMUONHitReconstructor.h"
8a296f1c	43	#include "AliRawReader.h"
9b4aa2e5	44	#include "AliHLTSystem.h"
9b4aa2e5	45
de3c3890	46	#if __GNUC__== 3
	47	using namespace std;
	48	#endif
	49
9b4aa2e5	50	const char* kHLTDefaultLibs[]= {
	51	"libAliHLTUtil.so",
	52	"libAliHLTTPC.so",
	53	// "libAliHLTSample.so",
	54	"libAliHLTPHOS.so",
	55	NULL
	56	};
	57
de3c3890	58	ClassImp(AliHLTReconstructor)
de3c3890	59
9b4aa2e5	60	AliHLTReconstructor::AliHLTReconstructor()
	61	:
	62	AliReconstructor(),
	63	fDoHough(0),
	64	fDoTracker(1),
	65	fDoBench(0),
	66	fDoCleanUp(0),
	67	fpSystem(NULL)
b1ed0288	68	{
b1ed0288	69	//constructor
6e61c746	70	#ifndef use_logging
4aa41877	71	AliHLTLog::fgLevel=AliHLTLog::kWarning;
6e61c746	72	#endif
ff0a6788	73	}
ff0a6788	74
9b4aa2e5	75	AliHLTReconstructor::AliHLTReconstructor(Bool_t doTracker, Bool_t doHough)
	76	:
	77	AliReconstructor(),
	78	fDoHough(doHough),
	79	fDoTracker(doTracker),
	80	fDoBench(0),
	81	fDoCleanUp(0),
	82	fpSystem(new AliHLTSystem)
	83	{
b1ed0288	84	//constructor
6e61c746	85	#ifndef use_logging
4aa41877	86	AliHLTLog::fgLevel=AliHLTLog::kWarning;
6e61c746	87	#endif
9b4aa2e5	88	}
	89
	90	AliHLTReconstructor::AliHLTReconstructor(const AliHLTReconstructor&)
	91	:
	92	AliReconstructor(),
	93	fDoHough(0),
	94	fDoTracker(0),
	95	fDoBench(0),
	96	fDoCleanUp(0),
	97	fpSystem(NULL)
	98	{
	99	// not a valid copy constructor
	100	}
	101
	102	AliHLTReconstructor& AliHLTReconstructor::operator=(const AliHLTReconstructor&)
	103	{
	104	// not a valid assignment operator
	105	fDoHough=0;
	106	fDoTracker=0;
ff0a6788	107	fDoBench=0;
9b4aa2e5	108	fDoCleanUp=0;
	109	fpSystem=NULL;
	110	return *this;
ff0a6788	111	}
	112
	113	AliHLTReconstructor::~AliHLTReconstructor()
b1ed0288	114	{
9b4aa2e5	115	//destructor
ff0a6788	116	if(fDoCleanUp){
	117	char name[256];
	118	gSystem->Exec("rm -rf hlt");
	119	sprintf(name, "rm -f confmap_.root confmap_.dat");
	120	gSystem->Exec(name);
	121	gSystem->Exec("rm -rf hough");
	122	sprintf(name, "rm -f hough_.root hough_.dat");
	123	gSystem->Exec(name);
	124	}
9b4aa2e5	125	if (fpSystem) {
	126	delete fpSystem;
	127	}
	128	fpSystem=NULL;
ff0a6788	129	}
ff0a6788	130
9b4aa2e5	131	void AliHLTReconstructor::Init(AliRunLoader* runLoader)
de3c3890	132	{
9b4aa2e5	133	// init the reconstructor
9a74ed1c	134	if(!runLoader) {
9b4aa2e5	135	AliError("Missing RunLoader! 0x0");
cefeb80d	136	return;
9a74ed1c	137	}
de3c3890	138
9b4aa2e5	139	if (!fpSystem) fpSystem=new AliHLTSystem;
	140	if (!fpSystem) {
	141	AliError("can not create AliHLTSystem object");
	142	return;
	143	}
	144	if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
	145	AliError("HLT system in error state");
de3c3890	146	return;
	147	}
	148
9b4aa2e5	149	TString libs("");
	150	TString option = GetOption();
	151	TObjArray* pTokens=option.Tokenize(" ");
	152	if (pTokens) {
	153	int iEntries=pTokens->GetEntries();
	154	for (int i=0; i<iEntries; i++) {
	155	TString token=(((TObjString*)pTokens->At(i))->GetString());
	156	if (token.Contains("loglevel=")) {
	157	TString param=token.ReplaceAll("loglevel=", "");
	158	if (param.IsDigit()) {
	159	fpSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
	160	} else if (param.BeginsWith("0x") &&
	161	param.Replace(0,2,"",0).IsHex()) {
	162	int severity=0;
	163	sscanf(param.Data(),"%x", &severity);
	164	fpSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
	165	} else {
	166	AliWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
	167	}
	168	} else if (token.Contains("alilog=off")) {
	169	fpSystem->SwitchAliLog(0);
	170	} else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
	171	libs+=token;
	172	libs+=" ";
	173	} else {
	174	AliWarning(Form("unknown option: %s", token.Data()));
	175	}
	176	}
	177	delete pTokens;
	178	}
	179
	180	Bool_t bForceLibLoad=0;
	181	if (bForceLibLoad=(libs.IsNull())) {
	182	const char** deflib=kHLTDefaultLibs;
	183	while (*deflib) {
	184	libs+=*deflib++;
	185	libs+=" ";
	186	}
	187	}
	188	if ((bForceLibLoad \|\| !fpSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
	189	(fpSystem->LoadComponentLibraries(libs.Data())<0)) {
	190	AliError("error while loading HLT libraries");
	191	return;
	192	}
	193	if (!fpSystem->CheckStatus(AliHLTSystem::kReady) &&
	194	(fpSystem->Configure(runLoader))<0) {
	195	AliError("error during HLT system configuration");
	196	return;
	197	}
	198	}
de3c3890	199
9b4aa2e5	200	void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader) const
	201	{
	202	// reconstruction of simulated data
	203	Reconstruct(runLoader, NULL);
	204	}
de3c3890	205
9b4aa2e5	206	void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const
	207	{
	208	// reconstruction of real data if rawReader!=NULL
	209	if(!runLoader) {
	210	AliError("Missing RunLoader! 0x0");
	211	return;
	212	}
	213
	214	Int_t nEvents = runLoader->GetNumberOfEvents();
	215	int iResult=0;
	216
	217	if (fpSystem) {
	218	if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
	219	AliError("HLT system in error state");
	220	return;
	221	}
	222	if ((iResult=fpSystem->Reconstruct(nEvents, runLoader, rawReader))>=0) {
	223	}
de3c3890	224	}
	225	}
	226
	227	void AliHLTReconstructor::ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const
	228	{
b1ed0288	229	// reconstruct with conformal mapper
de3c3890	230	AliLevel3 *fHLT = new AliLevel3(runLoader);
	231	fHLT->Init("./", AliLevel3::kRunLoader, 1);
	232
	233	Int_t phiSegments = 50;
	234	Int_t etaSegments = 100;
	235	Int_t trackletlength = 3;
	236	Int_t tracklength = 10;
	237	Int_t rowscopetracklet = 2;
	238	Int_t rowscopetrack = 10;
	239	Double_t minPtFit = 0;
	240	Double_t maxangle = 0.1745;
	241	Double_t goodDist = 5;
	242	Double_t maxphi = 0.1;
	243	Double_t maxeta = 0.1;
	244	Double_t hitChi2Cut = 20;
	245	Double_t goodHitChi2 = 5;
	246	Double_t trackChi2Cut = 10;
	247	Double_t xyerror = -1;
	248	Double_t zerror = -1;
	249
	250	fHLT->SetClusterFinderParam(xyerror,zerror,kTRUE);
	251	fHLT->SetTrackerParam(phiSegments, etaSegments,
	252	trackletlength, tracklength,
	253	rowscopetracklet, rowscopetrack,
	254	minPtFit, maxangle, goodDist, hitChi2Cut,
	255	goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE);
8c717250	256	fHLT->SetTrackerParam(phiSegments, etaSegments,
	257	trackletlength, tracklength,
	258	rowscopetracklet, rowscopetrack,
	259	minPtFit, maxangle, goodDist, hitChi2Cut,
	260	goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kFALSE);
de3c3890	261	fHLT->SetMergerParameters(2,3,0.003,0.1,0.05);
de3c3890	262	fHLT->DoMc();
8c717250	263	fHLT->DoNonVertexTracking(); /2 tracking passes, last without vertex contraint./
de3c3890	264	fHLT->WriteFiles("./hlt/");
de3c3890	265	fHLT->ProcessEvent(0, 35, iEvent);
2456c180	266	if(fDoBench){
	267	char filename[256];
	268	sprintf(filename, "confmap_%d",iEvent);
	269	fHLT->DoBench(filename);
	270	}
de3c3890	271
de3c3890	272	delete fHLT;
de3c3890	273	}
	274
	275	void AliHLTReconstructor::ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const
	276	{
b1ed0288	277	//reconstruct with hough
f644512a	278	//not used anymore, Hough tracking is moved out of the local
f644512a	279	//reconstruction chain
4aa41877	280	Float_t ptmin = 0.1*AliHLTTransform::GetSolenoidField();
de3c3890	281
	282	Float_t zvertex = 0;
	283	TArrayF mcVertex(3);
69fe5bee	284	AliHeader * header = runLoader->GetHeader();
	285	if (header) {
	286	AliGenEventHeader * genHeader = header->GenEventHeader();
	287	if (genHeader) genHeader->PrimaryVertex(mcVertex);
	288	}
de3c3890	289	zvertex = mcVertex[2];
de3c3890	290
4aa41877	291	LOG(AliHLTLog::kInformational,"AliHLTReconstructor::Reconstruct","HoughTransform")
8c717250	292	<<" Hough Transform will run with ptmin="<<ptmin<<" and zvertex="<<zvertex<<ENDLOG;
de3c3890	293
4aa41877	294	AliHLTHough *hough = new AliHLTHough();
de3c3890	295
de3c3890	296	hough->SetThreshold(4);
1e75562a	297	hough->CalcTransformerParams(ptmin);
de3c3890	298	hough->SetPeakThreshold(70,-1);
	299	hough->SetRunLoader(runLoader);
	300	hough->Init("./", kFALSE, 100, kFALSE,4,0,0,zvertex);
	301	hough->SetAddHistograms();
	302
8c717250	303	for(Int_t slice=0; slice<=35; slice++)
de3c3890	304	{
8c717250	305	//cout<<"Processing slice "<<slice<<endl;
de3c3890	306	hough->ReadData(slice,iEvent);
	307	hough->Transform();
	308	hough->AddAllHistogramsRows();
	309	hough->FindTrackCandidatesRow();
8c717250	310	//hough->WriteTracks(slice,"./hough");
de3c3890	311	hough->AddTracks();
	312	}
	313	hough->WriteTracks("./hough");
	314
2456c180	315	if(fDoBench){
	316	char filename[256];
	317	sprintf(filename, "hough_%d",iEvent);
	318	hough->DoBench(filename);
	319	}
de3c3890	320	delete hough;
	321	}
	322
	323	void AliHLTReconstructor::FillESD(AliRunLoader* runLoader,
	324	AliESD* esd) const
	325	{
b1ed0288	326	//fill the esd file with found tracks
9b4aa2e5	327	if(!runLoader) {
	328	AliError("Missing RunLoader! 0x0");
	329	return;
	330	}
de3c3890	331	Int_t iEvent = runLoader->GetEventNumber();
9b4aa2e5	332	if (fpSystem) {
	333	if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
	334	AliError("HLT system in error state");
	335	return;
	336	}
	337	if (!fpSystem->CheckStatus(AliHLTSystem::kReady)) {
	338	AliError("HLT system in wrong state");
	339	return;
	340	}
	341	fpSystem->FillESD(iEvent, runLoader, esd);
	342	}
	343	/*
8c717250	344	if(fDoTracker) FillESDforConformalMapping(esd,iEvent);
8c717250	345	if(fDoHough) FillESDforHoughTransform(esd,iEvent);
9b4aa2e5	346	*/
de3c3890	347	}
	348
	349	void AliHLTReconstructor::FillESDforConformalMapping(AliESD* esd,Int_t iEvent) const
	350	{
b1ed0288	351	//fill esd with tracks from conformal mapping
8c717250	352	Int_t slicerange[2]={0,35};
4aa41877	353	Int_t good = (int)(0.4*AliHLTTransform::GetNRows());
	354	Int_t nclusters = (int)(0.4*AliHLTTransform::GetNRows());
	355	Int_t nminpointsontracks = (int)(0.3*AliHLTTransform::GetNRows());
8c717250	356	Float_t ptmin = 0.;
	357	Float_t ptmax = 0.;
	358	Float_t maxfalseratio = 0.1;
de3c3890	359
4aa41877	360	AliHLTEvaluate *fHLTEval = new AliHLTEvaluate("./hlt",nclusters,good,ptmin,ptmax,slicerange);
de3c3890	361	fHLTEval->SetMaxFalseClusters(maxfalseratio);
de3c3890	362	fHLTEval->LoadData(iEvent,kTRUE);
	363	fHLTEval->AssignPIDs();
	364	fHLTEval->AssignIDs();
4aa41877	365	AliHLTTrackArray *fTracks = fHLTEval->GetTracks();
2456c180	366	if(!fTracks){
	367	delete fHLTEval;
	368	return;
	369	}
de3c3890	370	for(Int_t i=0; i<fTracks->GetNTracks(); i++)
de3c3890	371	{
4aa41877	372	AliHLTTrack tpt = (AliHLTTrack )fTracks->GetCheckedTrack(i);
de3c3890	373	if(!tpt) continue;
244a5ed5	374	if(tpt->GetNumberOfPoints() < nminpointsontracks) continue;
de3c3890	375
	376	AliESDHLTtrack *esdtrack = new AliESDHLTtrack() ;
	377
	378	esdtrack->SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
	379	esdtrack->SetNHits(tpt->GetNHits());
	380	esdtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
	381	esdtrack->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ());
	382	esdtrack->SetPt(tpt->GetPt());
	383	esdtrack->SetPsi(tpt->GetPsi());
	384	esdtrack->SetTgl(tpt->GetTgl());
	385	esdtrack->SetCharge(tpt->GetCharge());
	386	esdtrack->SetMCid(tpt->GetMCid());
	387	esdtrack->SetSector(tpt->GetSector());
	388	esdtrack->SetPID(tpt->GetPID());
	389	esdtrack->ComesFromMainVertex(tpt->ComesFromMainVertex());
	390
	391	esd->AddHLTConfMapTrack(esdtrack);
	392	delete esdtrack;
	393	}
de3c3890	394	delete fHLTEval;
	395	}
	396
	397	void AliHLTReconstructor::FillESDforHoughTransform(AliESD* esd,Int_t iEvent) const
	398	{
b1ed0288	399	//fill esd with tracks from hough
de3c3890	400	char filename[256];
	401	sprintf(filename,"./hough/tracks_%d.raw",iEvent);
	402
4aa41877	403	AliHLTFileHandler *tfile = new AliHLTFileHandler();
de3c3890	404	if(!tfile->SetBinaryInput(filename)){
4aa41877	405	LOG(AliHLTLog::kError,"AliHLTReconstructor::FillESDforHoughTransform","Input file")
2456c180	406	<<" Missing file "<<filename<<ENDLOG;
de3c3890	407	return;
	408	}
	409
4aa41877	410	AliHLTTrackArray *fTracks = new AliHLTTrackArray("AliHLTHoughTrack");
de3c3890	411	tfile->Binary2TrackArray(fTracks);
	412	tfile->CloseBinaryInput();
	413	delete tfile;
2456c180	414	if(!fTracks) return;
de3c3890	415	for(Int_t i=0; i<fTracks->GetNTracks(); i++)
de3c3890	416	{
4aa41877	417	AliHLTHoughTrack tpt = (AliHLTHoughTrack )fTracks->GetCheckedTrack(i);
de3c3890	418	if(!tpt) continue;
	419
	420	AliESDHLTtrack *esdtrack = new AliESDHLTtrack() ;
	421
	422	esdtrack->SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
	423	esdtrack->SetNHits(tpt->GetNHits());
	424	esdtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
	425	esdtrack->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ());
	426	esdtrack->SetPt(tpt->GetPt());
	427	esdtrack->SetPsi(tpt->GetPsi());
	428	esdtrack->SetTgl(tpt->GetTgl());
	429	esdtrack->SetCharge(tpt->GetCharge());
	430	esdtrack->SetMCid(tpt->GetMCid());
	431	esdtrack->SetWeight(tpt->GetWeight());
	432	esdtrack->SetSector(tpt->GetSector());
	433	esdtrack->SetBinXY(tpt->GetBinX(),tpt->GetBinY(),tpt->GetSizeX(),tpt->GetSizeY());
	434	esdtrack->SetPID(tpt->GetPID());
	435	esdtrack->ComesFromMainVertex(tpt->ComesFromMainVertex());
	436
	437	esd->AddHLTHoughTrack(esdtrack);
	438	delete esdtrack;
	439	}
	440
	441	delete fTracks;
	442	}
f644512a	443
	444	AliTracker* AliHLTReconstructor::CreateTracker(AliRunLoader* runLoader) const
	445	{
	446	//Create HLT trackers for TPC and ITS
	447
	448	TString opt = GetOption();
	449	if(!opt.CompareTo("TPC")) {
	450	// Create Hough tracker for TPC
4aa41877	451	return new AliHLTTPCtracker(runLoader);
f644512a	452	}
	453	if(!opt.CompareTo("ITS")) {
	454	// Create ITS tracker
e341247d	455	return new AliHLTITStracker(0);
f644512a	456	}
43f15f99	457	if(!opt.CompareTo("MUON")) {
	458	return new AliHLTMUONTracker(runLoader);
	459	}
f644512a	460
	461	return NULL;
	462	}
	463
8a296f1c	464	void AliHLTReconstructor::FillDHLTRecPoint(AliRawReader* rawReader, Int_t nofEvent, Int_t dcCut = 0) const
	465	{
	466	// Hit recontruction for dimuon-HLT
	467	AliHLTMUONHitReconstructor kdHLTRec(rawReader);
	468
	469	Int_t iEvent = 0 ;
	470	kdHLTRec.SetDCCut(dcCut);
	471	TString lookupTablePath = getenv("ALICE_ROOT");
	472	lookupTablePath += "/HLT/MUON/src/AliRoot/Lut";
	473	kdHLTRec.Init(lookupTablePath.Data(),lookupTablePath.Data());
	474
	475	while(rawReader->NextEvent() && iEvent < nofEvent){
	476	AliInfo(Form("Event : %d",iEvent));
	477	kdHLTRec.WriteDHLTRecHits(iEvent);
	478	iEvent++;
	479	}
	480
	481	}
	482
de3c3890	483	#endif