- complete revision and clean-up of the AliHLTReconstructor after recent changes
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Oct 2007 13:00:47 +0000 (13:00 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Oct 2007 13:00:47 +0000 (13:00 +0000)
in the AliRoot reconstruction
- option scanning completely moved to AliHLTSystem

HLT/BASE/AliHLTSystem.cxx
HLT/src/AliHLTReconstructor.cxx
HLT/src/AliHLTReconstructor.h

index 28ff3ed636d40f88074e24dd0a1d6d0e9abf2bfe..9e30b65e72a90de8c4b96e61d724dd1c3e44f704 100644 (file)
@@ -41,6 +41,17 @@ using namespace std;
 #include <TROOT.h>
 #include <TInterpreter.h>
 
+/** HLT default component libraries */
+const char* kHLTDefaultLibs[]= {
+  "libAliHLTUtil.so", 
+  "libAliHLTTPC.so", 
+  //  "libAliHLTSample.so",
+  "libAliHLTPHOS.so",
+  //"libAliHLTMUON.so",
+  "libAliHLTTRD.so",
+  NULL
+};
+
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTSystem)
 
@@ -363,6 +374,8 @@ int AliHLTSystem::Run(Int_t iNofEvents)
            , StopwatchInput.RealTime(),StopwatchInput.CpuTime()
            , StopwatchOutput.RealTime(),StopwatchOutput.CpuTime()
            , StopwatchDA.RealTime(),StopwatchDA.CpuTime());
+  } else  if (iResult==-ENOENT) {
+    iResult=0; // do not propagate the error
   }
   ClearStatusFlags(kRunning);
   return iResult;
@@ -632,6 +645,7 @@ int AliHLTSystem::ScanOptions(const char* options)
   // see header file for class documentation
   int iResult=0;
   if (options) {
+    TString libs("");
     TString alloptions(options);
     TObjArray* pTokens=alloptions.Tokenize(" ");
     if (pTokens) {
@@ -665,12 +679,30 @@ int AliHLTSystem::ScanOptions(const char* options)
        } else if (token.Contains("localrec=")) {
          TString param=token.ReplaceAll("localrec=", "");
          fLocalRec=param.ReplaceAll(",", " ");
+       } else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
+         libs+=token;
+         libs+=" ";
        } else {
          HLTWarning("unknown option \'%s\'", token.Data());
        }
       }
       delete pTokens;
     }
+
+    if (iResult>=0) {
+      if (libs.IsNull()) {
+       const char** deflib=kHLTDefaultLibs;
+       while (*deflib) {
+         libs+=*deflib++;
+         libs+=" ";
+       }
+      }
+      if ((!CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
+         (LoadComponentLibraries(libs.Data())<0)) {
+       HLTError("error while loading HLT libraries");
+       iResult=-EFAULT;
+      }
+    }
   }
   return iResult;
 }
index a205994c67c47e66f9bfcfd92182925f7fa5f3cc..29a38b61bac18f162132dfe657d268bf8f1b9eac 100644 (file)
@@ -7,92 +7,25 @@
 // <loizides@ikf.uni-frankfurt.de>                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <Riostream.h>
 #include <TSystem.h>
-#include <TArrayF.h>
 #include <TObjString.h>
-
-#include <AliESDEvent.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 "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
-
-/** HLT default component libraries */
-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()
 { 
   //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;
   }
@@ -112,6 +45,9 @@ void AliHLTReconstructor::Init()
     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(" ");
@@ -145,15 +81,8 @@ void AliHLTReconstructor::Init()
     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)) &&
+  if (!libs.IsNull() &&
+      (!fpSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
       (fpSystem->LoadComponentLibraries(libs.Data())<0)) {
     AliError("error while loading HLT libraries");
     return;
@@ -179,284 +108,38 @@ void AliHLTReconstructor::Init()
   }
 }
 
-// void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const 
-// {
-//   // reconstruction of real data if rawReader!=NULL
-//   if(!runLoader) {
-//     AliError("Missing RunLoader! 0x0");
-//     return;
-//   }
+void AliHLTReconstructor::Reconstruct(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/) const 
+{
+  // reconstruction of real data without writing of ESD
 
-//   Int_t nEvents = runLoader->GetNumberOfEvents();
+  // all reconstruction has been moved to FillESD
 //   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) {
+//     if ((iResult=fpSystem->Reconstruct(1, NULL, 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];
-
-//   AliInfo(Form("Hough Transform will run with ptmin=%f and zvertex=%f", ptmin, zvertex));
-
-//   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, 
-//                               AliESDEvent* 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(AliESDEvent* 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(AliESDEvent* 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)){
-//     AliError(Form("Missing file %s", filename));
-//     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;
-// }
-
-/* The following functions are deprecated and need to be removed.
-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
+void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /*clustersTree*/, 
+                                 AliESDEvent* esd) 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++;
-   }
-
+  // reconstruct real data and fill ESD
+  int iResult=0;
+  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;
+    }
+    if ((iResult=fpSystem->Reconstruct(1, NULL, rawReader))>=0) {
+      fpSystem->FillESD(-1, NULL, esd);
+    }
+  }
 }
-
-*/
index be6d32db85c108a817b8caf050cc1ad1a366c2e9..ed1a7aeafcfc81fe2ddf107b084a7c1be24caead 100644 (file)
@@ -8,6 +8,8 @@
 #include "AliReconstructor.h"
 
 class AliHLTSystem;
+class AliRawReader;
+class AliESDEvent;
 
 /**
  * @class AliHLTReconstructor
@@ -41,37 +43,43 @@ class AliHLTSystem;
 class AliHLTReconstructor: public AliReconstructor {
 public:
   AliHLTReconstructor();
-  AliHLTReconstructor(Bool_t doTracker, Bool_t doHough);
   /** destructor */
   virtual ~AliHLTReconstructor();
 
   /** init the reconstructor */
   void Init();
 
-  /** create a tracker */
-  // Deprecated and must be removed.
-  //  AliTracker*  CreateTracker() const;
-
-  virtual void         Reconstruct(TTree* digitsTree, TTree* clustersTree) const{
+  /**
+   * This Reconstructor function is not applicable for the AliHLTReconstructor
+   * as it gets a detector specific digits tree. But HLT processes all detectors.
+   * Furthermore it's purely simulated data.
+   */
+  void Reconstruct(TTree* digitsTree, TTree* clustersTree) const{
     AliReconstructor::Reconstruct(digitsTree,clustersTree);
   }
-  virtual void         Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const {
-    AliReconstructor::Reconstruct(rawReader,clustersTree);
-  }
 
-  virtual void         FillESD(TTree* digitsTree, TTree* clustersTree, 
-                              AliESDEvent* esd) const {
+  /**
+   * Reconstruction from RAW data.
+   * The rawReader holds data for all detectors and this version of Reconstruct
+   * is thus applicable for the HLT. The clustersTree is just ignored.
+   */
+  void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
+
+  /**
+   * This function is purely for simulated data and not applicable for HLT.
+   * HLT reconstruction on simulated data is processed at the end of
+   * simulation.
+   */
+  void FillESD(TTree* digitsTree, TTree* clustersTree, AliESDEvent* esd) const {
     AliReconstructor::FillESD(digitsTree,clustersTree,esd);
   }
-  virtual void         FillESD(AliRawReader* rawReader, TTree* clustersTree, 
-                              AliESDEvent* esd) const {
-    AliReconstructor::FillESD(rawReader,clustersTree,esd);
-  }
-  void SetDoBench(Bool_t b){fDoBench=b;}
-  void SetDoCleanup(Bool_t b){fDoCleanUp=b;}
-  
-  // Deprecated and must be removed.
-//  virtual void         FillDHLTRecPoint(AliRawReader* rawReader, Int_t nofEvent, Int_t dcCut) const;
+
+  /**
+   * Fill the ESD from RAW data.
+   * This is the main entry for HLT reconstruction of RAW data. It performs both
+   * the analysis by the defined chains and the filling of the ESD.
+   */
+  void FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESDEvent* esd) const;
 
 private:
   /** copy constructor prohibited */
@@ -79,19 +87,9 @@ private:
   /** assignment operator prohibited */
   AliHLTReconstructor& operator=(const AliHLTReconstructor& src);
 
-/*   void ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const; */
-/*   void ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const; */
-/*   void FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const; */
-/*   void FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const; */
-
-  Bool_t fDoHough;   //do the hough transform
-  Bool_t fDoTracker; //do the standard conformal tracker
-  Bool_t fDoBench;   //store the benchmark results
-  Bool_t fDoCleanUp; //delete tmp tracking files
-
   AliHLTSystem* fpSystem; //! HLT steering object
 
-  ClassDef(AliHLTReconstructor, 2)   // class for the HLT reconstruction
+  ClassDef(AliHLTReconstructor, 3)   // class for the HLT reconstruction
 };
 
 typedef AliHLTReconstructor AliL3Reconstructor; // for backward compatibility