- all digit raw data structures added to AliHLTTPCDigitData.h
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 20 Sep 2007 09:04:59 +0000 (09:04 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 20 Sep 2007 09:04:59 +0000 (09:04 +0000)
- AliHLTTPCRawDataFormat.h depricated
- TPC agent added
- TPCDigitPublisher added
- FileHandler and MemHandler cleaned/documented
- FileHandler enhanced to read AliRoot digit data into buffer
- depricated files removed from the projects (old steering class, depricated CF)

17 files changed:
HLT/TPCLib/AliHLTTPC.cxx [deleted file]
HLT/TPCLib/AliHLTTPC.h [deleted file]
HLT/TPCLib/AliHLTTPCAgent.cxx [new file with mode: 0644]
HLT/TPCLib/AliHLTTPCAgent.h [new file with mode: 0644]
HLT/TPCLib/AliHLTTPCClustFinderNew.cxx [deleted file]
HLT/TPCLib/AliHLTTPCClustFinderNew.h [deleted file]
HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx
HLT/TPCLib/AliHLTTPCDigitData.h
HLT/TPCLib/AliHLTTPCDigitReaderUnpacked.cxx
HLT/TPCLib/AliHLTTPCFileHandler.cxx
HLT/TPCLib/AliHLTTPCFileHandler.h
HLT/TPCLib/AliHLTTPCMemHandler.cxx
HLT/TPCLib/AliHLTTPCMemHandler.h
HLT/TPCLib/AliHLTTPCRawDataFormat.h [deleted file]
HLT/TPCLib/AliHLTTPCRawDataUnpackerComponent.cxx
HLT/TPCLib/legacy.txt [new file with mode: 0644]
HLT/libAliHLTTPC.pkg

diff --git a/HLT/TPCLib/AliHLTTPC.cxx b/HLT/TPCLib/AliHLTTPC.cxx
deleted file mode 100644 (file)
index ddabe95..0000000
+++ /dev/null
@@ -1,670 +0,0 @@
-// @(#) $Id$
-// Original: AliLevel3.cxx,v 1.42 2004/06/11 16:06:33 loizides 
-
-// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
-//*-- Copyright &copy ALICE HLT Group
-
-#ifndef no_root
-#include <TFile.h>
-#include <TDirectory.h>
-#include <TClonesArray.h>
-#include <TStopwatch.h>
-#endif
-
-#include <AliRunLoader.h>
-
-#include "AliHLTTPCLogging.h"
-#include "AliHLTTPC.h"
-#include "AliHLTTPCConfMapper.h"
-#include "AliHLTTPCVertex.h"
-#include "AliHLTTPCVertexFinder.h"
-#include "AliHLTTPCTrackMerger.h"
-#include "AliHLTTPCGlobalMerger.h"
-#include "AliHLTTPCInterMerger.h"
-#include "AliHLTTPCConfMapPoint.h"
-#include "AliHLTTPCConfMapTrack.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCClusterFinder.h"
-#include "AliHLTTPCDigitReaderUnpacked.h"
-#include "AliHLTTPCDigitData.h"
-#include "AliHLTTPCTrackArray.h"
-#include "AliHLTTPCMemHandler.h"
-#include "AliHLTTPCFitter.h"
-#include "AliHLTTPCFileHandler.h"
-#include "AliHLTTPCBenchmark.h"
-#include "AliHLTTPCDigitData.h"
-#include "AliHLTTPCTrackSegmentData.h"
-#include "AliHLTTPCSpacePointData.h"
-#include "AliHLTTPCVertexData.h"
-//#include "AliHLTTPCDDLDataFileHandler.h"
-
-/** \class AliHLTTPC
-<pre>
-//_____________________________________________________________
-//
-//  AliHLTTPC
-//
-//  Interface class for HLTTPC tracker.
-//  For example how to use, see exa/runtracker.C (root)
-//  or programs/runtracker.cxx (standalone program).
-//Begin_Html 
-//<img src="tpcsectorsnb.gif">
-//End_Html
-</pre>
-*/
-
-ClassImp(AliHLTTPC)
-
-AliHLTTPC::AliHLTTPC()
-{
-  //Default constructor. Should also be used when input is from binary files.
-  //In that case the path to where the binary files are located has to be
-  //passed to the AliLevel::Init function.
-  
-  fVertexFinder=0;
-  fVertex=0;
-  fTracker=0;
-  fTrackMerger=0;
-  fInterMerger=0;
-  fFileHandler=0;
-  fGlobalMerger=0;
-  fInputFile=0;
-  fRunLoader=0;
-}
-
-AliHLTTPC::AliHLTTPC(Char_t *infile)
-{
-  //Constructor to use for when input is anything else but binary files,
-  //meaning rootfiles or raw files.
-  
-  fVertexFinder=0;
-  fVertex=0;
-  fTracker=0;
-  fTrackMerger=0;
-  fInterMerger=0;
-  fFileHandler=0;
-  fGlobalMerger=0;
-  fInputFile = infile;
-  fRunLoader=0;
-}
-
-AliHLTTPC::AliHLTTPC(AliRunLoader *rl)
-{
-  //Constructor to use when input is aliroot runloader
-  fVertexFinder=0;
-  fVertex=0;
-  fTracker=0;
-  fTrackMerger=0;
-  fInterMerger=0;
-  fFileHandler=0;
-  fGlobalMerger=0;
-  fInputFile=0;
-  fRunLoader = rl;
-}
-
-Bool_t AliHLTTPC::fgDoVertexFit = kTRUE;//Include the vertex in the final track fit
-
-void AliHLTTPC::Init(Char_t *path,EFileType filetype,Int_t npatches)
-{
-  //Init the whole standard tracker chain
-
-  if((filetype!=kBinary) && (filetype!=kDate) 
-       && (filetype!=kRunLoader)&& !fInputFile)
-    {
-      LOG(AliHLTTPCLog::kError,"AliHLTTPC::Init","Files")
-       <<"You have not supplied the input rootfile; use the appropriate ctor!"<<ENDLOG;
-      return;
-    }
-  if((filetype==kRunLoader) && !fRunLoader)
-    {
-      LOG(AliHLTTPCLog::kError,"AliHLTTPC::Init","Files")
-       <<"You have not supplied the input runloader; use the appropriate ctor!"<<ENDLOG;
-      return;
-    }
-  
-  fWriteOut = kFALSE;
-  fPileUp = kFALSE;
-  fNoCF=kFALSE;
-  fUseBinary = (filetype==kBinary);
-  SetPath(path);
-  
-  fDoRoi = kFALSE;
-  fDoNonVertex = kFALSE;
-  fFindVertex = kFALSE;
-  SetClusterFinderParam();
-
-  fEta[0] = 0.;
-  fEta[1] = 1.1;
-
-  fEvent=0;
-  /*just to be sure*/
-  AliHLTTPCFileHandler::CleanStaticIndex();
-
-  switch(npatches){
-  case 0:
-    fNPatch = 1;
-    fRow[0][0] = AliHLTTPCTransform::GetFirstRow(3);
-    fRow[0][1] = AliHLTTPCTransform::GetLastRow(5);
-    break;
-  case 1:
-    fNPatch = 1;        //number of patches change row in process
-    fRow[0][0] = 0;
-    fRow[0][1] = AliHLTTPCTransform::GetLastRow(-1);
-    break;
-  case 2:
-    fNPatch = 2;        //number of patches change row in process
-    fRow[0][0] = 0;     // first row
-    fRow[0][1] = AliHLTTPCTransform::GetLastRow(1);
-    fRow[1][0] = AliHLTTPCTransform::GetFirstRow(2);
-    fRow[1][1] = AliHLTTPCTransform::GetLastRow(5);
-    break;
-  default: 
-    fNPatch = 6;        
-    fRow[0][0] = AliHLTTPCTransform::GetFirstRow(0);
-    fRow[0][1] = AliHLTTPCTransform::GetLastRow(0);
-    fRow[1][0] = AliHLTTPCTransform::GetFirstRow(1);
-    fRow[1][1] = AliHLTTPCTransform::GetLastRow(1);
-    fRow[2][0] = AliHLTTPCTransform::GetFirstRow(2);
-    fRow[2][1] = AliHLTTPCTransform::GetLastRow(2);
-    fRow[3][0] = AliHLTTPCTransform::GetFirstRow(3);
-    fRow[3][1] = AliHLTTPCTransform::GetLastRow(3);
-    fRow[4][0] = AliHLTTPCTransform::GetFirstRow(4);
-    fRow[4][1] = AliHLTTPCTransform::GetLastRow(4);
-    fRow[5][0] = AliHLTTPCTransform::GetFirstRow(5);
-    fRow[5][1] = AliHLTTPCTransform::GetLastRow(5);
-  }
-
-  fVertexFinder = new AliHLTTPCVertexFinder();
-  fVertex = new AliHLTTPCVertex();
-  fTracker = new AliHLTTPCConfMapper();
-  fTrackMerger = new AliHLTTPCTrackMerger(fNPatch);
-  fInterMerger = new AliHLTTPCInterMerger();
-  fGlobalMerger = new AliHLTTPCGlobalMerger();
-  SetMergerParameters();//Set default merger parameters
-  if(filetype==kRoot){    
-    fFileHandler = new AliHLTTPCFileHandler(kTRUE); //static version
-    fFileHandler->SetAliInput(fInputFile);
-  }else if(filetype==kRaw){
-    LOG(AliHLTTPCLog::kFatal,"AliHLTTPC::Init","Files")
-      <<"AliHLTTPCDDLDataFileHandler not available in this build"<<ENDLOG;
-//     fFileHandler = new AliHLTTPCDDLDataFileHandler();
-//     fFileHandler->SetReaderInput(fInputFile);
-  }else if(filetype==kDate){
-    LOG(AliHLTTPCLog::kFatal,"AliHLTTPC::Init","Files")
-      <<"AliHLTTPCDDLDataFileHandler not available in this build"<<ENDLOG;
-//     fFileHandler = new AliHLTTPCDDLDataFileHandler();
-//     fFileHandler->SetReaderInput(fInputFile,-1);
-  }
-  else if(filetype==kRunLoader){
-    fFileHandler = new AliHLTTPCFileHandler(kTRUE); //static version
-    fFileHandler->SetAliInput(fRunLoader);
-  }
-  else{
-    fFileHandler = new AliHLTTPCMemHandler();
-  }
-  fBenchmark = new AliHLTTPCBenchmark();
-}
-
-void AliHLTTPC::DoBench(char* name)
-{ 
-  //dobench
-  fBenchmark->Analyze(name);
-  delete fBenchmark;
-  fBenchmark = new AliHLTTPCBenchmark();
-}
-
-void AliHLTTPC::DoMc(char* file)
-{ 
-  //domc
-  if(!fFileHandler->IsDigit(fEvent))
-    fFileHandler->SetMCOutput(file);
-}
-
-AliHLTTPC::~AliHLTTPC()
-{
-  //Destructor
-  if(fVertexFinder) delete fVertexFinder;
-  if(fVertex) delete fVertex;
-  if(fTracker) delete fTracker;
-  if(fTrackMerger) delete fTrackMerger;
-  if(fInterMerger) delete fInterMerger;
-  if(fFileHandler) delete fFileHandler;
-  if(fGlobalMerger) delete fGlobalMerger;
-}
-
-void AliHLTTPC::SetClusterFinderParam(Float_t fXYError, Float_t fZError, Bool_t deconv)
-{ 
-  //set cluster finder parameter
-  fXYClusterError=fXYError;
-  fZClusterError=fZError;
-  fClusterDeconv=deconv;
-}
-
-void AliHLTTPC::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
-                               Int_t trackletlength, Int_t tracklength,
-                               Int_t rowscopetracklet, Int_t rowscopetrack,
-                               Double_t min_pt_fit, Double_t maxangle,
-                               Double_t goodDist, Double_t hitChi2Cut,
-                               Double_t goodHitChi2, Double_t trackChi2Cut,
-                               Int_t maxdist,Double_t maxphi,Double_t maxeta,
-                               Bool_t vertexconstraint)
-{
-  //Set parameters input to the tracker
-  //If no arguments are given, default parameters will be used
-  
-  fTracker->SetNSegments(phi_segments,eta_segments);
-  fTracker->SetMaxDca(min_pt_fit);
-  fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexconstraint);
-  fTracker->SetTrackletCuts(maxangle,goodDist,vertexconstraint);
-  if(vertexconstraint)
-    fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack,maxphi,maxeta);
-  else
-    fTracker->NonVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
-  fTracker->InitVolumes();
-}
-
-void AliHLTTPC::SetMergerParameters(Double_t maxy,Double_t maxz,Double_t maxkappa,Double_t maxpsi,Double_t maxtgl)
-{
-  //set global merger parameter
-  fGlobalMerger->SetParameter(maxy,maxz,maxkappa,maxpsi,maxtgl);
-}
-
-void AliHLTTPC::ProcessEvent(Int_t first,Int_t last,Int_t event)
-{
-  //Do tracking on all slices in region [first,last]
-  //Slices numbering in TPC goes from 0-35, which means that one slice
-  //corresponds to inner+outer sector.E.g. slice 2 corresponds to
-  //inner=2 + outer=38.
-
-  fGlobalMerger->Setup(first,last);
-  if(fEvent!=event) AliHLTTPCFileHandler::CleanStaticIndex();
-  fEvent=event;
-  for(Int_t i=first; i<=last; i++){
-    ProcessSlice(i);
-    fGlobalMerger->SetVertex(fVertex);
-    fGlobalMerger->InitSlice(i);
-    fGlobalMerger->FillTracks(fNTrackData,fTrackData);
-    fFileHandler->Free();   //free the memory
-    fNTrackData=0;
-    fTrackData=0;
-  }
-  fBenchmark->Start("Global track merger");
-  //fGlobalMerger->AddAllTracks();
-  fGlobalMerger->Merge();
-  //fGlobalMerger->SlowMerge(fWriteOutPath);
-  fBenchmark->Stop("Global track merger");
-  
-  FitGlobalTracks();
-  
-  if(fWriteOut) WriteResults(); 
-  fFileHandler->FreeDigitsTree();
-}
-
-void AliHLTTPC::ProcessSlice(Int_t slice)
-{
-  //process slice
-  char name[256];
-  Bool_t UseCF = kFALSE;
-  UseCF = fFileHandler->IsDigit(fEvent);
-  if(fUseBinary)
-    UseCF = kTRUE;   //In case you are not using aliroot
-  if(fNoCF == kTRUE) //In case you don't want to run with cluster finder
-    UseCF = kFALSE;
-
-  const Int_t kmaxpoints=120000;
-  const Int_t kpointsize = kmaxpoints * sizeof(AliHLTTPCSpacePointData);
-  AliHLTTPCMemHandler *memory = new AliHLTTPCMemHandler();
-
-  fTrackMerger->Reset();
-  fTrackMerger->SetRows(fRow[0]);
-  
-  for(Int_t patch=fNPatch-1;patch>=0;patch--){
-    fFileHandler->Init(slice,patch,&fRow[patch][0]);
-    UInt_t npoints=0;
-    AliHLTTPCSpacePointData *points =0;
-    UInt_t ndigits=0;
-    AliHLTTPCDigitRowData *digits =0;
-    UInt_t digitSize = 0;
-    if(UseCF){
-      if(fUseBinary) {
-        if(!fDoRoi) { 
-          if(1){     //Binary to Memory
-           fFileHandler->Free();
-            if(fNPatch == 1)
-             sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
-           else
-             sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
-           if(!fFileHandler->SetBinaryInput(name)) return;
-           if(fPileUp)
-             { //Read binary files which are not RLE
-               digits = (AliHLTTPCDigitRowData*)fFileHandler->Allocate();
-               fFileHandler->Binary2Memory(ndigits,digits, digitSize ); 
-               digitSize = fFileHandler->GetFileSize();
-             }
-           else //Read RLE binary files
-               {
-               digits= (AliHLTTPCDigitRowData *)fFileHandler->CompBinary2Memory(ndigits, digitSize);
-               }
-
-           fFileHandler->CloseBinaryInput(); 
-          }
-
-          if(0){     //Binary to Memory with Benchmark 
-           fFileHandler->Free();
-            if(fNPatch == 1)
-             sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
-           else
-             sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
-            if(!memory->SetBinaryInput(name)) return;
-            UInt_t compsize=memory->GetFileSize();
-            UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
-            memory->CompBinary2CompMemory(ndigits,comp);
-            memory->CloseBinaryInput();
-            UInt_t datasize=memory->GetMemorySize(ndigits,comp);
-            digits=(AliHLTTPCDigitRowData *)fFileHandler->Allocate(datasize);
-            fBenchmark->Start("Unpacker"); 
-            fFileHandler->CompMemory2Memory(ndigits,digits,comp,digitSize); 
-            fBenchmark->Stop("Unpacker");
-            memory->Free();
-          }
-  
-          if(0){     //Binary to Memory with Random
-            fFileHandler->Free();
-            fFileHandler->ResetRandom();
-            fFileHandler->SetRandomCluster(100);
-            fFileHandler->SetNGenerate(100);
-            if(fNPatch == 1)
-             sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
-           else
-             sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
-            if(!memory->SetBinaryInput(name)) return;
-            UInt_t compsize=memory->GetFileSize();
-            UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
-            memory->CompBinary2CompMemory(ndigits,comp);
-            memory->CloseBinaryInput();
-            UInt_t dsize=memory->GetMemorySize(ndigits,comp);
-            UInt_t rsize=fFileHandler->GetRandomSize();       
-            digits=(AliHLTTPCDigitRowData*)fFileHandler->Allocate(dsize+rsize);
-            fBenchmark->Start("Unpacker");
-            fFileHandler->CompMemory2Memory(ndigits,digits,comp,digitSize); 
-            fBenchmark->Stop("Unpacker");
-            memory->Free();
-          }
-        }
-
-        else{     //Binary to Memory with Roi
-          fFileHandler->Free();
-          Int_t sli[2]={0,0};
-          fFileHandler->SetROI(fEta,sli);
-          if(fNPatch==1)
-           sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
-         else
-           sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
-          if(!memory->SetBinaryInput(name)) return;
-          UInt_t compsize=memory->GetFileSize();
-          UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
-          memory->CompBinary2CompMemory(ndigits,comp);
-          memory->CloseBinaryInput();
-          UInt_t datasize=memory->GetMemorySize(ndigits,comp);
-          digits=(AliHLTTPCDigitRowData *)fFileHandler->Allocate(datasize);
-          fBenchmark->Start("Unpacker"); 
-          datasize = fFileHandler->CompMemory2Memory(ndigits,digits,comp,digitSize); 
-          fBenchmark->Stop("Unpacker"); 
-          memory->Free();
-        }
-      }//end UseBinary
-      else{
-        fBenchmark->Start("Dummy Unpacker");
-        if(fNPatch==1)
-         sprintf(name,"digits_%d_%d_%d.raw",fEvent,slice,-1);
-       else
-         sprintf(name,"digits_%d_%d_%d.raw",fEvent,slice,patch);
-        fBenchmark->Stop("Dummy Unpacker");
-
-        if(0){   //Ali to Binary
-          fFileHandler->SetBinaryOutput(name);
-          fFileHandler->AliDigits2CompBinary();
-          fFileHandler->CloseBinaryOutput();
-        }
-  
-        if(1){   //Ali to Memory
-          digits=(AliHLTTPCDigitRowData *)fFileHandler->AliAltroDigits2Memory(ndigits,fEvent);
-          if(0){ //Memory to Binary
-            fFileHandler->SetBinaryOutput(name);
-            fFileHandler->Memory2CompBinary(ndigits,digits);
-            fFileHandler->CloseBinaryOutput();
-          }
-        }
-      }//end else UseBinary
-
-      points = (AliHLTTPCSpacePointData *) memory->Allocate(kpointsize);
-      fClusterFinder = new AliHLTTPCClusterFinder();
-      fDigitReader = new AliHLTTPCDigitReaderUnpacked();
-      fClusterFinder->InitSlice(slice,patch,fRow[patch][0],fRow[patch][1],kmaxpoints);
-      fClusterFinder->SetDeconv(fClusterDeconv);
-      fClusterFinder->SetXYError(fXYClusterError);
-      fClusterFinder->SetZError(fZClusterError);
-      if((fXYClusterError>0)&&(fZClusterError>0))
-       fClusterFinder->SetCalcErr(kFALSE);
-      fClusterFinder->SetOutputArray(points);
-      fClusterFinder->SetReader( fDigitReader );
-      fBenchmark->Start("Cluster finder");
-      //fClusterFinder->Read(ndigits,digits);
-      fClusterFinder->Read( (void*)digits, (unsigned long) digitSize );
-      fClusterFinder->ProcessDigits();
-      fBenchmark->Stop("Cluster finder");
-      npoints = fClusterFinder->GetNumberOfClusters();
-      delete fClusterFinder;
-      fClusterFinder = 0;
-      fFileHandler->Free();
-      LOG(AliHLTTPCLog::kInformational,"AliHLTTPC::ProcessSlice","Cluster Finder")
-        <<AliHLTTPCLog::kDec<<"Found "<<npoints<<" Points"<<ENDLOG;
-    }//end UseCF
-    else{// if not use Clusterfinder
-      if(fUseBinary){//Binary to Memory
-        memory->Free();
-        if(fNPatch==1)
-         sprintf(name,"%s/points_%d_%d_%d.raw",fPath,fEvent,slice,-1);
-       else
-         sprintf(name,"%s/points_%d_%d_%d.raw",fPath,fEvent,slice,patch);
-        if(!memory->SetBinaryInput(name)) return;
-        points = (AliHLTTPCSpacePointData *) memory->Allocate();
-        memory->Binary2Memory(npoints,points);
-        memory->CloseBinaryInput();
-        LOG(AliHLTTPCLog::kInformational,"AliHLTTPC::ProcessSlice","Read Cluster")
-        <<AliHLTTPCLog::kDec<<"Found "<<npoints<<" Points in File"<<ENDLOG;
-      }
-      else{
-        points = fFileHandler->AliPoints2Memory(npoints);
-      }
-      fBenchmark->Start("Dummy Unpacker");
-      fBenchmark->Stop("Dummy Unpacker");
-      fBenchmark->Start("Dummy CF");
-      fBenchmark->Stop("Dummy CF");
-    }
-   
-    if(patch == fNPatch-1){
-      // Vertex
-      if(fFindVertex){
-      // Vertex Finder
-      
-        fBenchmark->Start("Vertex Finder Read");
-        fVertexFinder->Reset();
-        fVertexFinder->Read(npoints,points);
-        fBenchmark->Stop("Vertex Finder Read"); 
-        fBenchmark->Start("Vertex Finder");
-        fVertexFinder->Analyze();
-        AliHLTTPCVertexData vertex[1];
-        fVertexFinder->Write(vertex);
-        fVertex->Read(vertex);
-        fBenchmark->Stop("Vertex Finder"); 
-      }
-      else{
-        //use 0,0,0 for vertex
-        fVertex->SetZero();
-      }
-      fTrackMerger->SetVertex(fVertex);
-    }
-
-    fTracker->InitSector(slice,fRow[patch],fEta);
-    fTracker->SetVertex(fVertex);
-    fBenchmark->Start("Tracker setup"); 
-    fTracker->ReadHits(npoints,points);
-    fTracker->MainVertexTracking_a();
-    fBenchmark->Stop("Tracker setup");
-    fBenchmark->Start("Track follower");
-    fTracker->MainVertexTracking_b();
-    fBenchmark->Stop("Track follower");
-    if(fDoNonVertex)
-      fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
-    fBenchmark->Start("Sector track fitting");
-    fTracker->FillTracks();
-    fBenchmark->Stop("Sector track fitting");
-
-    if(fWriteOut) 
-       WriteSpacePoints(npoints, points, slice, patch); //do after Tracking
-
-    //free memory
-    if(UseCF)
-      memory->Free();
-    else
-      fFileHandler->Free();
-
-    UInt_t ntracks0 =0;
-    AliHLTTPCTrackSegmentData *trackdata0  = 
-         (AliHLTTPCTrackSegmentData *) memory->Allocate(fTracker->GetTracks());
-    memory->TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
-
-    //write tracks
-    if(fWriteOut){
-      if(fNPatch==1)
-       sprintf(name,"%s/tracks_tr_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,-1);
-      else
-       sprintf(name,"%s/tracks_tr_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,patch);
-      memory->SetBinaryOutput(name);
-      memory->Memory2Binary(ntracks0,trackdata0);
-      memory->CloseBinaryOutput();
-    }
-
-    fInterMerger->Reset();
-    fInterMerger->Init(fRow[patch],patch);
-
-    fInterMerger->FillTracks(ntracks0,trackdata0);
-    
-    //fBenchmark->Start("Inter Merger");
-    // fInterMerger->Merge();
-    //    fInterMerger->SlowMerge();
-    
-    //fBenchmark->Stop("Inter Merger");
-    /*
-    //write inter merged tracks
-    if(fWriteOut){
-      sprintf(name,"%stracks_im_%d_%d.raw",fWriteOutPath,slice,patch);
-      WriteTracks(name,fInterMerger,'i'); //write output of intermerger
-      }
-    */
-    memory->Free();
-    
-    UInt_t ntracks1 =0;
-    AliHLTTPCTrackSegmentData *trackdata1 =
-      (AliHLTTPCTrackSegmentData *) memory->Allocate(fInterMerger->GetInTracks(0));
-    memory->TrackArray2Memory(ntracks1,trackdata1,fInterMerger->GetInTracks(0));
-
-    fTrackMerger->InitSector(slice,patch);
-    fTrackMerger->FillTracks(ntracks1,trackdata1);
-
-    memory->Free();
-  }
-  //fBenchmark->Start("Patch Merger");
-  //fTrackMerger->SlowMerge();
-  fTrackMerger->AddAllTracks();
-  //fTrackMerger->Merge();
-  //fBenchmark->Stop("Patch Merger");
-  /*
-  //write merged tracks
-  if(fWriteOut){
-    sprintf(name,"%stracks_tm_%d.raw",fWriteOutPath,slice);
-    WriteTracks(name,fTrackMerger,'o'); //write output of trackmerger
-  }
-  */
-  fTrackData = (AliHLTTPCTrackSegmentData *) 
-                         fFileHandler->Allocate(fTrackMerger->GetOutTracks());
-
-  fFileHandler->TrackArray2Memory(fNTrackData,fTrackData,
-                                                fTrackMerger->GetOutTracks());
-
-  delete memory;
-}
-
-void AliHLTTPC::FitGlobalTracks()
-{ 
-  //fit global tracks
-  AliHLTTPCFitter *fitter = new AliHLTTPCFitter(fVertex,AliHLTTPC::DoVertexFit());
-  if(fNPatch==1)
-    fitter->LoadClusters(fWriteOutPath,fEvent,kTRUE);
-  else
-    fitter->LoadClusters(fWriteOutPath,fEvent,kFALSE);
-  
-  fBenchmark->Start("Global track fitter");
-  AliHLTTPCTrackArray *tracks = fGlobalMerger->GetOutTracks();
-  for(Int_t i=0; i<tracks->GetNTracks(); i++)
-    {
-      AliHLTTPCTrack *tr = tracks->GetCheckedTrack(i);
-      if(!tr) continue;
-      fitter->FitHelix(tr);
-      tr->UpdateToFirstPoint();
-    }
-  fBenchmark->Stop("Global track fitter");
-  delete fitter;
-}
-
-void AliHLTTPC::WriteSpacePoints(UInt_t npoints,AliHLTTPCSpacePointData *points,
-                                Int_t slice,Int_t patch) const
-{ 
-  //write space points
-  char name[256];
-  if(fNPatch==1)
-    sprintf(name,"%s/points_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,-1);
-  else
-    sprintf(name,"%s/points_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,patch);
-  AliHLTTPCMemHandler * memory = new AliHLTTPCMemHandler();
-  memory->SetBinaryOutput(name);
-  memory->Transform(npoints,points,slice);
-  memory->Memory2Binary(npoints,points);
-  memory->CloseBinaryOutput();
-  delete  memory;
-}
-
-Int_t AliHLTTPC::WriteTracks(char *filename,AliHLTTPCMerger *merger,char opt) const
-{ 
-  //write tracks
-  AliHLTTPCMemHandler *memory = new AliHLTTPCMemHandler();
-  memory->SetBinaryOutput(filename);
-  if(opt=='a'||opt=='i'){  //add intracks
-    for(Int_t i=0;i<merger->GetNIn();i++){
-      AliHLTTPCTrackArray *tr=merger->GetInTracks(i);
-      memory->TrackArray2Binary(tr);
-    }
-  }
-
-  if(opt=='o'||opt=='a'){
-    AliHLTTPCTrackArray *tr=merger->GetOutTracks();
-    memory->TrackArray2Binary(tr);
-  }
-
-  memory->CloseBinaryOutput();
-  delete memory;
-  return 1;
-}
-
-void AliHLTTPC::WriteResults()
-{
-  //Write the resulting tracks to outputfile
-  Char_t fname[256];
-  sprintf(fname,"%s/tracks_%d.raw",fWriteOutPath,fEvent);
-  WriteTracks(fname,fGlobalMerger,'a');
-  //WriteTracks("tracks.raw",fGlobalMerger,'a');
-  sprintf(fname,"%s/tracks_gl_%d.raw",fWriteOutPath,fEvent);
-  WriteTracks(fname,fGlobalMerger,'o');
-  //WriteTracks("tracks_gl.raw",fGlobalMerger,'o');
-}
diff --git a/HLT/TPCLib/AliHLTTPC.h b/HLT/TPCLib/AliHLTTPC.h
deleted file mode 100644 (file)
index bd69632..0000000
+++ /dev/null
@@ -1,131 +0,0 @@
-// @(#) $Id$
-// Original: AliLevel3.h,v 1.24 2004/06/11 16:06:33 loizides 
-
-#ifndef ALIHLTTPC_H
-#define ALIHLTTPC_H
-
-#ifndef no_root
-#include <TObject.h>
-#include <TFile.h>
-#endif
-
-class AliRunLoader;
-
-#include "AliHLTTPCDigitData.h"
-#include "AliHLTTPCRootTypes.h"
-
-class AliHLTTPCSpacePointData;
-class AliHLTTPCDigitRowData;
-class AliHLTTPCTrackSegmentData;
-class AliHLTTPCDigitData;
-class AliHLTTPCConfMapper;
-class AliHLTTPCVertex;
-class AliHLTTPCVertexFinder;
-class AliHLTTPCTrackMerger;
-class AliHLTTPCGlobalMerger;
-#ifndef no_root
-class TDirectory;
-#endif
-class AliHLTTPCClusterFinder;
-class AliHLTTPCDigitReaderUnpacked;
-class AliHLTTPCMerger;
-class AliHLTTPCInterMerger;
-class AliHLTTPCFileHandler;
-class AliHLTTPCMemHandler;
-class AliHLTTPCBenchmark;
-
-#ifdef no_root
-class AliHLTTPC {
-#else
-class AliHLTTPC : public TObject {
-#endif
-
- private:
-  UInt_t fNTrackData; //count data
-  AliHLTTPCTrackSegmentData* fTrackData; //!
-  AliHLTTPCConfMapper *fTracker; //!
-  AliHLTTPCVertex *fVertex; //! 
-  AliHLTTPCVertexFinder *fVertexFinder; //!
-  AliHLTTPCTrackMerger *fTrackMerger; //!
-  AliHLTTPCGlobalMerger *fGlobalMerger; //!
-  AliHLTTPCInterMerger *fInterMerger; //!
-  AliHLTTPCClusterFinder *fClusterFinder; //! 
-  AliHLTTPCDigitReaderUnpacked* fDigitReader; //!
-  AliHLTTPCMemHandler *fFileHandler; //!
-  AliHLTTPCBenchmark *fBenchmark;//!
-
-  Int_t fEvent;    //event number
-  Int_t fNPatch;   //number of patches
-  Int_t fRow[6][2];//rows
-  Float_t fEta[2]; //eta
-  
-  Char_t *fInputFile;//!
-  AliRunLoader *fRunLoader; //runloader
-  Char_t fPath[256]; //path to aliroot
-  Char_t fWriteOutPath[256]; //path to store
-  
-  Bool_t fDoRoi; //do region of interest
-  Bool_t fFindVertex; //find vertex
-  Bool_t fDoNonVertex;//do non vertex pass
-  Bool_t fPileUp; //do pileup
-  Bool_t fNoCF; //dont do cluster finder
-  
-  Bool_t fUseBinary; //use binary input
-  Bool_t fWriteOut; //write tracks
-  
-  static Bool_t fgDoVertexFit; //do vertex fix
-
-  Bool_t fClusterDeconv; //do cluster deconv
-  Float_t fXYClusterError; //Cluster error
-  Float_t fZClusterError; //Cluster error
-
-  void WriteSpacePoints(UInt_t npoints,AliHLTTPCSpacePointData *points,
-                        Int_t slice,Int_t patch) const;
-  Int_t WriteTracks(char *filename,AliHLTTPCMerger *merger,char opt='o') const;  
-  void WriteResults();
-  void FitGlobalTracks();
-  void SetPath(char *p){sprintf(fPath,"%s",p);}
-
- public:
-  AliHLTTPC ();
-  AliHLTTPC(Char_t *infile);
-  AliHLTTPC(AliRunLoader *rl);
-  virtual ~AliHLTTPC();
-  enum EFileType {kBinary, kBinary8, kRoot, kRaw, kDate, kRunLoader};
-  void Init(Char_t *path,EFileType filetype=kBinary,Int_t npatches=6);
-  void SetMergerParameters(Double_t maxy=1.2,Double_t maxz=1.6,Double_t maxkappa=0.003,
-                          Double_t maxpsi=0.02,Double_t maxtgl=0.03);
-  void SetTrackerParam(Int_t phi_segments=50,Int_t eta_segments=100,
-                      Int_t trackletlength=3,Int_t tracklength=5,
-                      Int_t rowscopetracklet=2,Int_t rowscopetrack=3,
-                      Double_t min_pt_fit=0,Double_t maxangle=1.31,
-                      Double_t goodDist=5,Double_t hitChi2Cut=10,
-                      Double_t goodHitChi2=20,Double_t trackChi2Cut=50,
-                      Int_t maxdist=50,Double_t maxphi=0.1,Double_t maxeta=0.1,
-                       Bool_t vertexconstraint=kTRUE);
-  void SetClusterFinderParam(Float_t fXYError=0.2,Float_t fZError=0.3,Bool_t deconv=kTRUE);
-
-  void ProcessEvent(Int_t first,Int_t last,Int_t event=0);
-  void ProcessSlice(Int_t slice);
-
-  void DoMc(char* file="point_mc.dat");
-  void DoNonVertexTracking() {fDoNonVertex=kTRUE;}
-  void FindVertex() {fFindVertex=kTRUE;}
-  void DoBench(char* name="benchmark");
-  void DoPileup() {fPileUp = kTRUE;}
-  void NoCF() {fNoCF=kTRUE;}
-  void DoRoi(Float_t e0=0.4,Float_t e1=0.5){fEta[0]=e0;fEta[1]=e1;fDoRoi=kTRUE;}
-  void WriteFiles(Char_t *path="./"){fWriteOut = kTRUE; sprintf(fWriteOutPath,"%s",path);}
-  
-  static void SetVertexFit(Bool_t f)   {fgDoVertexFit=f;}
-  static Bool_t DoVertexFit()          {return fgDoVertexFit;}
-
-  ClassDef(AliHLTTPC,1) //Interface class for HLTTPC-tracking
-};
-
-#endif
-
-
-
-
-
diff --git a/HLT/TPCLib/AliHLTTPCAgent.cxx b/HLT/TPCLib/AliHLTTPCAgent.cxx
new file mode 100644 (file)
index 0000000..d326c83
--- /dev/null
@@ -0,0 +1,75 @@
+// @(#) $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   AliHLTTPCAgent.cxx
+    @author Matthias Richter
+    @date   
+    @brief  Agent of the libAliHLTTPC library
+*/
+
+#include "AliHLTTPCAgent.h"
+#include "AliHLTConfiguration.h"
+
+/** global instance for agent registration */
+AliHLTTPCAgent gAliHLTTPCAgent;
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTTPCAgent)
+
+AliHLTTPCAgent::AliHLTTPCAgent()
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+AliHLTTPCAgent::~AliHLTTPCAgent()
+{
+  // see header file for class documentation
+}
+
+int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
+                                         AliRunLoader* runloader) const
+{
+  // see header file for class documentation
+  if (handler) {
+    // digit publisher configuration
+    TString arg("-slice 0 -partition 0");
+    HLTDebug(arg.Data());
+    handler->CreateConfiguration("digit-publisher"  , "TPCDigitPublisher", NULL , arg.Data());
+
+    // the writer configuration
+    handler->CreateConfiguration("sink1", "FileWriter"   , "digit-publisher" , NULL);
+  }
+  return 0;
+}
+
+const char* AliHLTTPCAgent::GetLocalRecConfigurations(AliRunLoader* runloader) const
+{
+  // see header file for class documentation
+  return NULL;
+  //return "sink1";
+}
+
+const char* AliHLTTPCAgent::GetRequiredComponentLibraries() const
+{
+  // see header file for class documentation
+  return NULL;
+}
diff --git a/HLT/TPCLib/AliHLTTPCAgent.h b/HLT/TPCLib/AliHLTTPCAgent.h
new file mode 100644 (file)
index 0000000..af07b83
--- /dev/null
@@ -0,0 +1,67 @@
+// @(#) $Id$
+
+#ifndef ALIHLTTPCAGENT_H
+#define ALIHLTTPCAGENT_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/** @file   AliHLTTPCAgent.h
+    @author Matthias Richter
+    @date   
+    @brief  Agent of the libAliHLTTPC library
+*/
+
+#include "AliHLTModuleAgent.h"
+
+/**
+ * @class AliHLTTPCAgent
+ * This is the agent for the AliHLTTPC library.
+ *
+ * @ingroup alihlt_system
+ */
+class AliHLTTPCAgent : public AliHLTModuleAgent {
+ public:
+  /**
+   * standard constructor. The agent is automatically registered in the
+   * global agent manager
+   */
+  AliHLTTPCAgent();
+  /** destructor */
+  virtual ~AliHLTTPCAgent();
+
+  /**
+   * Register all configurations belonging to this module with the
+   * AliHLTConfigurationHandler. The agent can adapt the configurations
+   * to be registered to the current AliRoot setup by checking the
+   * runloader.
+   * @param handler      the configuration handler
+   * @param runloader    AliRoot runloader
+   * @return neg. error code if failed
+   */
+  int CreateConfigurations(AliHLTConfigurationHandler* handler,
+                          AliRunLoader* runloader=NULL) const;
+
+  /**
+   * Get the top configurations belonging to this module.
+   * A top configuration describes a processing chain. It can simply be
+   * described by the last configuration(s) in the chain. 
+   * The agent can adapt the configurations to be registered to the current
+   * AliRoot setup by checking the runloader.
+   * @param runloader    AliRoot runloader
+   * @return number of configurations, neg. error code if failed
+   */
+  const char* GetLocalRecConfigurations(AliRunLoader* runloader=NULL) const;
+
+  /**
+   * Component libraries which the configurations of this agent depend on.
+   * @return list of component libraries as a blank-separated string.
+   */
+  const char* GetRequiredComponentLibraries() const;
+
+ protected:
+
+ private:
+  ClassDef(AliHLTTPCAgent, 0);
+};
+
+#endif
diff --git a/HLT/TPCLib/AliHLTTPCClustFinderNew.cxx b/HLT/TPCLib/AliHLTTPCClustFinderNew.cxx
deleted file mode 100644 (file)
index 68da982..0000000
+++ /dev/null
@@ -1,505 +0,0 @@
-// @(#) $Id$
-//Original: AliHLTClustFinderNew.cxx,v 1.29 2005/06/14 10:55:21 cvetan 
-
-// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Constantin Loizides <mailto:loizides@ikf.uni-frankfurt.de>
-//*-- Copyright &copy ALICE HLT Group
-
-#include "AliHLTTPCRootTypes.h"
-#include "AliHLTTPCLogging.h"
-#include "AliHLTTPCClustFinderNew.h"
-#include "AliHLTTPCDigitData.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCSpacePointData.h"
-#include "AliHLTTPCMemHandler.h"
-
-#if __GNUC__ >= 3
-using namespace std;
-#endif
-
-/** \class AliHLTTPCClustFinderNew
-<pre>
-//_____________________________________________________________
-// AliHLTTPCClustFinderNew
-//
-// The current cluster finder for HLT
-// (Based on STAR L3)
-// 
-// The cluster finder is initialized with the Init function, 
-// providing the slice and patch information to work on. 
-// The input is a AliHLTTPCDigitRowData structure using the 
-// Read function. The resulting space points will be in the
-// array given by the SetOutputArray function.
-// 
-// There are several setters which control the behaviour:
-//
-// - SetXYError(Float_t):   set fixed error in XY direction
-// - SetZError(Float_t):    set fixed error in Z  direction
-//                            (used if errors are not calculated) 
-// - SetDeconv(Bool_t):     switch on/off deconvolution
-// - SetThreshold(UInt_t):  set charge threshold for cluster
-// - SetMatchWidth(UInt_t): set the match distance in 
-//                            time for sequences to be merged 
-// - SetSTDOutput(Bool_t):  switch on/off output about found clusters   
-// - SetCalcErr(Bool_t):    switch on/off calculation of 
-//                          space point errors (or widths in raw system)
-// - SetRawSP(Bool_t):      switch on/off convertion to raw system
-//
-//
-// Example Usage:
-//
-// AliHLTTPCFileHandler *file = new AliHLTTPCFileHandler();
-// file->SetAliInput(digitfile); //give some input file
-// for(int slice=0; slice<=35; slice++){
-//   for(int patch=0; pat<6; pat++){
-//     file->Init(slice,patch);
-//     UInt_t ndigits=0;
-//     UInt_t maxclusters=100000;
-//     UInt_t pointsize = maxclusters*sizeof(AliHLTTPCSpacePointData);
-//     AliHLTTPCSpacePointData *points = (AliHLTTPCSpacePointData*)memory->Allocate(pointsize);
-//     AliHLTTPCDigitRowData *digits = (AliHLTTPCDigitRowData*)file->AliAltroDigits2Memory(ndigits,event);
-//     AliHLTTPCClustFinderNew *cf = new AliHLTTPCClustFinderNew();
-//     cf->SetMatchWidth(2);
-//     cf->InitSlice(slice,patch,maxclusters);
-//     cf->SetSTDOutput(kTRUE);    //Some output to standard IO
-//     cf->SetRawSP(kFALSE);       //Convert space points to local system
-//     cf->SetThreshold(5);        //Threshold of cluster charge
-//     cf->SetDeconv(kTRUE);       //Deconv in pad and time direction
-//     cf->SetCalcErr(kTRUE);      //Calculate the errors of the spacepoints
-//     cf->SetOutputArray(points); //Move the spacepoints to the array
-//     cf->Read(ndigits,digits);   //give the data to the cf
-//     cf->ProcessDigits();        //process the rows given by init
-//     Int_t npoints = cf->GetNumberOfClusters();
-//     AliHLTTPCMemHandler *out= new AliHLTTPCMemHandler();
-//     out->SetBinaryOutput(fname);
-//     out->Memory2Binary(npoints,points); //store the spacepoints
-//     out->CloseBinaryOutput();
-//     delete out;
-//     file->free();
-//     delete cf;
-//   }
-// }
-</pre> 
-*/
-
-ClassImp(AliHLTTPCClustFinderNew)
-
-AliHLTTPCClustFinderNew::AliHLTTPCClustFinderNew()
-{
-  //constructor
-  fMatch = 1;
-  fThreshold = 10;
-  fXYErr = 0.2;
-  fZErr = 0.3;
-  fDeconvPad = kTRUE;
-  fDeconvTime = kTRUE;
-  fStdout = kFALSE;
-  fCalcerr = kTRUE;
-  fRawSP = kFALSE;
-  fFirstRow=0;
-  fLastRow=0;
-}
-
-AliHLTTPCClustFinderNew::~AliHLTTPCClustFinderNew()
-{
-  //destructor
-  ;
-}
-
-void AliHLTTPCClustFinderNew::InitSlice(Int_t slice,Int_t patch,Int_t firstrow, Int_t lastrow,Int_t nmaxpoints)
-{
-  //init slice
-  fNClusters = 0;
-  fMaxNClusters = nmaxpoints;
-  fCurrentSlice = slice;
-  fCurrentPatch = patch;
-  fFirstRow = firstrow;
-  fLastRow = lastrow;
-}
-
-void AliHLTTPCClustFinderNew::InitSlice(Int_t slice,Int_t patch,Int_t nmaxpoints)
-{
-  //init slice
-  fNClusters = 0;
-  fMaxNClusters = nmaxpoints;
-  fCurrentSlice = slice;
-  fCurrentPatch = patch;
-  fFirstRow=AliHLTTPCTransform::GetFirstRow(patch);
-  fLastRow=AliHLTTPCTransform::GetLastRow(patch);
-}
-
-void AliHLTTPCClustFinderNew::SetOutputArray(AliHLTTPCSpacePointData *pt)
-{
-  //set pointer to output
-  fSpacePointData = pt;
-}
-
-void AliHLTTPCClustFinderNew::Read(UInt_t ndigits,AliHLTTPCDigitRowData *ptr)
-{
-  //set input pointer
-  fNDigitRowData = ndigits;
-  fDigitRowData = ptr;
-}
-
-void AliHLTTPCClustFinderNew::ProcessDigits()
-{
-  //Loop over rows, and call processrow
-  AliHLTTPCDigitRowData *tempPt = (AliHLTTPCDigitRowData*)fDigitRowData;
-  fNClusters = 0; 
-  for(Int_t i=fFirstRow; i<=fLastRow; i++)
-    {
-      fCurrentRow = i;
-      if((Int_t)tempPt->fRow!=fCurrentRow){
-       LOG(AliHLTTPCLog::kWarning,"AliHLTTPCClustFinderNew::ProcessDigits","Digits")
-         <<"Row number should match! "<<tempPt->fRow<<" "<<fCurrentRow<<ENDLOG;
-       continue;
-      }
-      ProcessRow(tempPt);
-      Byte_t *tmp = (Byte_t*)tempPt;
-      Int_t size = sizeof(AliHLTTPCDigitRowData) + tempPt->fNDigit*sizeof(AliHLTTPCDigitData);
-      tmp += size;
-      tempPt = (AliHLTTPCDigitRowData*)tmp;
-    }
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCClustFinderNew::ProcessDigits","Space points")
-    <<"Cluster finder found "<<fNClusters<<" clusters in slice "<<fCurrentSlice
-    <<" patch "<<fCurrentPatch<<ENDLOG;
-}
-
-void AliHLTTPCClustFinderNew::ProcessRow(AliHLTTPCDigitRowData *tempPt)
-{
-  //process row
-  UInt_t lastpad = 123456789;
-
-  AliClusterData *pad1[5000]; //2 lists for internal memory=2pads
-  AliClusterData *pad2[5000]; //2 lists for internal memory=2pads
-  AliClusterData clusterlist[10000]; //Clusterlist
-
-  AliClusterData **currentPt;  //List of pointers to the current pad
-  AliClusterData **previousPt; //List of pointers to the previous pad
-  currentPt = pad2;
-  previousPt = pad1;
-  UInt_t nprevious=0,ncurrent=0,ntotal=0;
-
-  //Loop over sequences of this row:
-  for(UInt_t bin=0; bin<tempPt->fNDigit; bin++)
-    {
-      AliHLTTPCDigitData *data = tempPt->fDigitData;
-      if(data[bin].fPad != lastpad)
-       {
-         //This is a new pad
-         
-         //Switch the lists:
-         if(currentPt == pad2)
-           {
-             currentPt = pad1;
-             previousPt = pad2;
-           }
-         else 
-           {
-             currentPt = pad2;
-             previousPt = pad1;
-           }
-         nprevious = ncurrent;
-         ncurrent = 0;
-         if(bin[data].fPad != lastpad+1)
-           {
-             //this happens if there is a pad with no signal.
-             nprevious = ncurrent = 0;
-           }
-         lastpad = data[bin].fPad;
-       }
-
-      Bool_t newcluster = kTRUE;
-      UInt_t seqcharge=0,seqaverage=0,seqerror=0;
-      UInt_t lastcharge=0,lastwas_falling=0;
-      Int_t newbin=-1;
-
-      if(fDeconvTime)
-       {
-       redo: //This is a goto.
-         if(newbin > -1)
-           {
-             bin = newbin;
-             newbin = -1;
-           }
-         
-         lastcharge=0;
-         lastwas_falling = 0;
-       }
-      
-      while(1) //Loop over current sequence
-       {
-         if(data[bin].fTime >= AliHLTTPCTransform::GetNTimeBins())
-           {
-             LOG(AliHLTTPCLog::kFatal,"AliHLTTPCClustFinderNew::ProcessRow","Digits")
-               <<"Timebin out of range "<<(Int_t)data[bin].fTime<<ENDLOG;
-             break;
-           }
-
-         //Get the current ADC-value
-         UInt_t charge = data[bin].fCharge;
-         
-         if(fDeconvTime)
-           {
-             //Check if the last pixel in the sequence is smaller than this
-             if(charge > lastcharge)
-               {
-                 if(lastwas_falling)
-                   {
-                     newbin = bin;
-                     break;
-                   }
-               }
-             else lastwas_falling = 1; //last pixel was larger than this
-             lastcharge = charge;
-           }
-         
-         //Sum the total charge of this sequence
-         seqcharge += charge;
-         seqaverage += data[bin].fTime*charge;
-         seqerror += data[bin].fTime*data[bin].fTime*charge;
-
-         //Check where to stop:
-         if(bin >= tempPt->fNDigit - 1) //out of range
-           break;
-         if(data[bin+1].fPad != data[bin].fPad) //new pad
-           break;
-         if(data[bin+1].fTime != data[bin].fTime+1) //end of sequence
-           break;
-         
-         bin++;
-       }//end loop over sequence
-      
-      //Calculate mean of sequence:
-      Int_t seqmean=0;
-      if(seqcharge)
-       seqmean = seqaverage/seqcharge;
-      else
-       {
-         LOG(AliHLTTPCLog::kFatal,"AliHLTTPCClustFinderNew::ProcessRow","Data")
-           <<"Error in data given to the cluster finder"<<ENDLOG;
-         seqmean = 1;
-         seqcharge = 1;
-       }
-      
-      //Calculate mean in pad direction:
-      Int_t padmean = seqcharge*data[bin].fPad;
-      Int_t paderror = data[bin].fPad*padmean;
-
-      //Compare with results on previous pad:
-      for(UInt_t p=0; p<nprevious; p++)
-       {
-         //dont merge sequences on the same pad twice
-         if(previousPt[p]->fLastMergedPad==data[bin].fPad) continue;
-
-         Int_t difference = seqmean - previousPt[p]->fMean;
-         if(difference < -fMatch) break;
-
-         if(difference <= fMatch) //There is a match here!!
-           {
-             AliClusterData *local = previousPt[p];
-
-             if(fDeconvPad)
-               {
-                 if(seqcharge > local->fLastCharge)
-                   {
-                     if(local->fChargeFalling) //The previous pad was falling
-                       {                       
-                         break; //create a new cluster
-                       }                   
-                   }
-                 else
-                   local->fChargeFalling = 1;
-                 local->fLastCharge = seqcharge;
-               }
-             
-             //Don't create a new cluster, because we found a match
-             newcluster = kFALSE;
-             
-             //Update cluster on current pad with the matching one:
-             local->fTotalCharge += seqcharge;
-             local->fPad += padmean;
-             local->fPad2 += paderror;
-             local->fTime += seqaverage;
-             local->fTime2 += seqerror;
-             local->fMean = seqmean;
-             local->fFlags++; //means we have more than one pad 
-             local->fLastMergedPad = data[bin].fPad;
-
-             currentPt[ncurrent] = local;
-             ncurrent++;
-             
-             break;
-           } //Checking for match at previous pad
-       } //Loop over results on previous pad.
-      
-      if(newcluster)
-       {
-         //Start a new cluster. Add it to the clusterlist, and update
-         //the list of pointers to clusters in current pad.
-         //current pad will be previous pad on next pad.
-
-         //Add to the clusterlist:
-         AliClusterData *tmp = &clusterlist[ntotal];
-         tmp->fTotalCharge = seqcharge;
-         tmp->fPad = padmean;
-         tmp->fPad2 = paderror;
-         tmp->fTime = seqaverage;
-         tmp->fTime2 = seqerror;
-         tmp->fMean = seqmean;
-         tmp->fFlags = 0;  //flags for single pad clusters
-         tmp->fLastMergedPad = data[bin].fPad;
-
-         if(fDeconvPad)
-           {
-             tmp->fChargeFalling = 0;
-             tmp->fLastCharge = seqcharge;
-           }
-
-         //Update list of pointers to previous pad:
-         currentPt[ncurrent] = &clusterlist[ntotal];
-         ntotal++;
-         ncurrent++;
-       }
-
-      if(fDeconvTime)
-       if(newbin >= 0) goto redo;
-    }//Loop over digits on this padrow
-  
-  WriteClusters(ntotal,clusterlist);
-}
-
-void AliHLTTPCClustFinderNew::WriteClusters(Int_t nclusters,AliClusterData *list)
-{
-  //write cluster to output pointer
-  Int_t thisrow,thissector;
-  UInt_t counter = fNClusters;
-  
-  for(int j=0; j<nclusters; j++)
-    {
-      if(!list[j].fFlags) continue; //discard single pad clusters
-      if(list[j].fTotalCharge < fThreshold) continue; //noise cluster
-
-      Float_t xyz[3];      
-      Float_t fpad =(Float_t)list[j].fPad / list[j].fTotalCharge;
-      Float_t fpad2=fXYErr*fXYErr; //fixed given error
-      Float_t ftime =(Float_t)list[j].fTime / list[j].fTotalCharge;
-      Float_t ftime2=fZErr*fZErr;  //fixed given error
-
-      if(fCalcerr) { //calc the errors, otherwice take the fixed error 
-       Int_t patch = AliHLTTPCTransform::GetPatch(fCurrentRow);
-       UInt_t q2=list[j].fTotalCharge*list[j].fTotalCharge;
-       Float_t sy2=list[j].fPad2 * list[j].fTotalCharge - list[j].fPad * list[j].fPad;
-       sy2/=q2;
-       if(sy2 < 0) {
-           LOG(AliHLTTPCLog::kError,"AliHLTTPCClustFinderNew::WriteClusters","Cluster width")
-             <<"SigmaY2 negative "<<sy2<<" on row "<<fCurrentRow<<" "<<fpad<<" "<<ftime<<ENDLOG;
-           continue;
-       } else {
-         if(!fRawSP){
-           fpad2 = (sy2 + 1./12)*AliHLTTPCTransform::GetPadPitchWidth(patch)*AliHLTTPCTransform::GetPadPitchWidth(patch);
-           if(sy2 != 0){
-             fpad2*=0.108; //constants are from offline studies
-             if(patch<2)
-               fpad2*=2.07;
-           }
-         } else fpad2=sy2; //take the width not the error
-       }
-       Float_t sz2=list[j].fTime2*list[j].fTotalCharge - list[j].fTime*list[j].fTime;
-       sz2/=q2;
-       if(sz2 < 0){
-         LOG(AliHLTTPCLog::kError,"AliHLTTPCClustFinderNew::WriteClusters","Cluster width")
-           <<"SigmaZ2 negative "<<sz2<<" on row "<<fCurrentRow<<" "<<fpad<<" "<<ftime<<ENDLOG;
-         continue;
-       } else {
-         if(!fRawSP){
-           ftime2 = (sz2 + 1./12)*AliHLTTPCTransform::GetZWidth()*AliHLTTPCTransform::GetZWidth();
-           if(sz2 != 0) {
-             ftime2 *= 0.169; //constants are from offline studies
-             if(patch<2)
-               ftime2 *= 1.77;
-           }
-         } else ftime2=sz2; //take the width, not the error
-       }
-      }
-      if(fStdout==kTRUE)
-       cout<<"WriteCluster: padrow "<<fCurrentRow<<" pad "<<fpad << " +- "<<fpad2<<" time "<<ftime<<" +- "<<ftime2<<" charge "<<list[j].fTotalCharge<<endl;
-      
-      if(!fRawSP){
-       AliHLTTPCTransform::Slice2Sector(fCurrentSlice,fCurrentRow,thissector,thisrow);
-       AliHLTTPCTransform::Raw2Local(xyz,thissector,thisrow,fpad,ftime);
-       
-       if(xyz[0]==0) LOG(AliHLTTPCLog::kError,"AliHLTTPCClustFinder","Cluster Finder")
-         <<AliHLTTPCLog::kDec<<"Zero cluster"<<ENDLOG;
-       if(fNClusters >= fMaxNClusters)
-         {
-           LOG(AliHLTTPCLog::kError,"AliHLTTPCClustFinder::WriteClusters","Cluster Finder")
-             <<AliHLTTPCLog::kDec<<"Too many clusters "<<fNClusters<<ENDLOG;
-           return;
-         }  
-       
-       fSpacePointData[counter].fX = xyz[0];
-       fSpacePointData[counter].fY = xyz[1];
-       fSpacePointData[counter].fZ = xyz[2];
-       
-      } else {
-       fSpacePointData[counter].fX = fCurrentRow;
-       fSpacePointData[counter].fY = fpad;
-       fSpacePointData[counter].fZ = ftime;
-      }
-      
-      fSpacePointData[counter].fCharge = list[j].fTotalCharge;
-      fSpacePointData[counter].fPadRow = fCurrentRow;
-      fSpacePointData[counter].fSigmaY2 = fpad2;
-      fSpacePointData[counter].fSigmaZ2  = ftime2;
-
-      Int_t patch=fCurrentPatch;
-      if(patch==-1) patch=0; //never store negative patch number
-      fSpacePointData[counter].fID = counter
-       +((fCurrentSlice&0x7f)<<25)+((patch&0x7)<<22);//Uli
-#ifdef do_mc
-      Int_t trackID[3];
-      GetTrackID((Int_t)rint(fpad),(Int_t)rint(ftime),trackID);
-
-      fSpacePointData[counter].fTrackID[0] = trackID[0];
-      fSpacePointData[counter].fTrackID[1] = trackID[1];
-      fSpacePointData[counter].fTrackID[2] = trackID[2];
-
-      //cout<<"padrow "<<fCurrentRow<<" pad "<<(Int_t)rint(fpad)<<" time "<<(Int_t)rint(ftime)<<" Trackid "<<trackID[0]<<endl;
-#endif
-      
-      fNClusters++;
-      counter++;
-    }
-}
-
-#ifdef do_mc
-void AliHLTTPCClustFinderNew::GetTrackID(Int_t pad,Int_t time,Int_t *trackID)
-{
-  //get mc id
-  AliHLTTPCDigitRowData *rowPt = (AliHLTTPCDigitRowData*)fDigitRowData;
-  
-  trackID[0]=trackID[1]=trackID[2]=-2;
-  //cout<<"Looking for pad "<<pad<<" time "<<time<<endl;
-  for(Int_t i=fFirstRow; i<=fLastRow; i++){
-    if(rowPt->fRow < (UInt_t)fCurrentRow){
-      AliHLTTPCMemHandler::UpdateRowPointer(rowPt);
-      continue;
-    }
-    AliHLTTPCDigitData *digPt = (AliHLTTPCDigitData*)rowPt->fDigitData;
-    for(UInt_t j=0; j<rowPt->fNDigit; j++){
-      Int_t cpad = digPt[j].fPad;
-      Int_t ctime = digPt[j].fTime;
-      if(cpad != pad) continue;
-      if(ctime != time) continue;
-
-      trackID[0] = digPt[j].fTrackID[0];
-      trackID[1] = digPt[j].fTrackID[1];
-      trackID[2] = digPt[j].fTrackID[2];
-      
-      //cout<<"Reading row "<<fCurrentRow<<" pad "<<cpad<<" time "<<ctime<<" trackID "<<digPt[j].fTrackID[0]<<endl;
-      break;
-    }
-    break;
-  }
-}
-#endif
diff --git a/HLT/TPCLib/AliHLTTPCClustFinderNew.h b/HLT/TPCLib/AliHLTTPCClustFinderNew.h
deleted file mode 100644 (file)
index 6a85c13..0000000
+++ /dev/null
@@ -1,79 +0,0 @@
-// @(#) $Id$
-// Original: AliHLTClustFinderNew.h,v 1.13 2004/06/18 10:55:26 loizides 
-#ifndef AliHLTTPC_ClustFinderNew
-#define AliHLTTPC_ClustFinderNew
-
-class AliHLTTPCDigitRowData;
-class AliHLTTPCSpacePointData;
-
-class AliHLTTPCClustFinderNew {
-
- public:
-  struct AliClusterData
-  {
-    UInt_t fTotalCharge;   //tot charge of cluster
-    UInt_t fPad;           //pad value
-    UInt_t fTime;          //time value
-    ULong64_t fPad2;       //for error in XY direction
-    ULong64_t fTime2;      //for error in Z  direction
-    UInt_t fMean;          //mean in time
-    UInt_t fFlags;         //different flags
-    UInt_t fChargeFalling; //for deconvolution
-    UInt_t fLastCharge;    //for deconvolution
-    UInt_t fLastMergedPad; //dont merge twice per pad
-  };
-  typedef struct AliClusterData AliClusterData; //!
-
- private:
-  AliHLTTPCDigitRowData *fDigitRowData; //!
-  AliHLTTPCSpacePointData *fSpacePointData; //!
-  Bool_t fDeconvTime; //deconv in time direction
-  Bool_t fDeconvPad;  //deconv in pad direction
-  Bool_t fStdout;     //have print out in write clusters
-  Bool_t fCalcerr;    //calculate centroid sigmas
-  Bool_t fRawSP;      //store centroids in raw system
-
-  UInt_t fNDigitRowData; //ndigts on row
-  Int_t fFirstRow;       //first row
-  Int_t fLastRow;        //last row
-  Int_t fCurrentRow;     //current active row
-  Int_t fCurrentSlice;   //current slice
-  Int_t fCurrentPatch;   //current patch
-  Int_t fMatch;          //size of match
-  UInt_t fThreshold;     //threshold for clusters
-  Int_t fNClusters;      //number of found clusters
-  Int_t fMaxNClusters;   //max. number of clusters
-  Float_t fXYErr;        //fixed error in XY
-  Float_t fZErr;         //fixed error in Z
-
-#ifdef do_mc
-  void GetTrackID(Int_t pad,Int_t time,Int_t *trackID);
-#endif
-  
- public:
-  AliHLTTPCClustFinderNew();
-  virtual ~AliHLTTPCClustFinderNew();
-  
-  void Read(UInt_t ndigits,AliHLTTPCDigitRowData *ptr);
-  void InitSlice(Int_t slice,Int_t patch,Int_t firstrow, Int_t lastrow,Int_t maxpoints);
-  void InitSlice(Int_t slice,Int_t patch,Int_t maxpoints);
-  void ProcessDigits();
-  void ProcessRow(AliHLTTPCDigitRowData *tempPt);
-  void SetOutputArray(AliHLTTPCSpacePointData *pt);
-  void WriteClusters(Int_t n_clusters,AliClusterData *list);
-
-  void SetXYError(Float_t f) {fXYErr=f;}
-  void SetZError(Float_t f) {fZErr=f;}
-  void SetDeconv(Bool_t f) {fDeconvPad=f; fDeconvTime=f;}
-  void SetThreshold(UInt_t i) {fThreshold=i;}
-  void SetMatchWidth(UInt_t i) {fMatch=i;}
-  void SetSTDOutput(Bool_t f=kFALSE) {fStdout=f;}  
-  void SetCalcErr(Bool_t f=kTRUE) {fCalcerr=f;}
-  void SetRawSP(Bool_t f=kFALSE) {fRawSP=f;}
-  Int_t GetNumberOfClusters() const {return fNClusters;}
-  
-  ClassDef(AliHLTTPCClustFinderNew,1) //Fast cluster finder
-};
-#endif
-
-
index 29fcf7c..0e4c649 100644 (file)
@@ -34,7 +34,6 @@ using namespace std;
 #include "AliHLTTPCDigitReaderRaw.h"
 #include "AliHLTTPCClusterFinder.h"
 #include "AliHLTTPCSpacePointData.h"
-#include "AliHLTTPCRawDataFormat.h"
 #include "AliHLTTPCClusterDataFormat.h"
 #include "AliHLTTPCTransform.h"
 #include "AliHLTTPCClusters.h"
index 0f2a99f..1e6ba7b 100644 (file)
@@ -6,21 +6,33 @@
 
 #include "AliHLTTPCRootTypes.h" 
 
+/**
+ * @struct AliHLTTPCDigitData
+ * Raw data structure for one row of TPC data. A digit corresponds to one
+ * measured signal in 2 coordinates: pad and time <br>
+ * The hight of the signal is given by the charge. <br>
+ * This structure is only used while runnig HLT analysis in the offline
+ * framework. Thats why it comes with a MC track id by default.
+ *
+ * The exact meaning of the 3 track ID fields is currently not known to me.
+ * (Matthias 18.09.2007) 
+ * @ingroup alihlt-tpc-datastructs
+ */
 struct AliHLTTPCDigitData
 {
-#ifdef do_mc
-  Int_t fTrackID[3];
-#endif
   UShort_t fCharge;
-  UChar_t fPad;
+  UChar_t  fPad;
   UShort_t fTime;
-#ifdef IA64
-  UChar_t dummy1;
-  UChar_t dummy2;
-#endif
+  Int_t    fTrackID[3];
 };
 typedef struct AliHLTTPCDigitData AliHLTTPCDigitData;
 
+/**
+ * @struct AliHLTTPCDigitRowData
+ * A container for TPC raw data organized in rows.
+ * This is the 3rd coordinate which is missing in @ref AliHLTTPCDigitData.
+ * @ingroup alihlt-tpc-datastructs
+ */
 struct AliHLTTPCDigitRowData
 {
   UInt_t fNDigit;
@@ -33,6 +45,16 @@ struct AliHLTTPCDigitRowData
 };
 typedef struct AliHLTTPCDigitRowData AliHLTTPCDigitRowData;
 
+/**
+ * @struct AliHLTTPCRandomDigitData
+ * Raw data structure for TPC data. A digit corresponds to one
+ * measured signal in r coordinates: row, pad and time <br>
+ * The hight of the signal is given by the charge. <br>
+ *
+ * The structure is not used for data exchange between components,
+ * it's here for legacy reasons.
+ * @ingroup alihlt-tpc-datastructs
+ */
 struct AliHLTTPCRandomDigitData{
   UChar_t fRow;
   UShort_t fCharge;
@@ -40,4 +62,20 @@ struct AliHLTTPCRandomDigitData{
   UShort_t fTime;
 };
 typedef struct AliHLTTPCRandomDigitData AliHLTTPCRandomDigitData;
+
+/**
+ * @struct AliHLTTPCPackedRawData
+ * Container structure for TPC data.
+ * It contains an array of TPC data objects, organized by pad rows.
+ * @ingroup alihlt-tpc-datastructs
+ */
+struct AliHLTTPCUnpackedRawData
+{
+#ifndef __SUNPRO_CC
+  AliHLTTPCDigitRowData fDigits[];
+#else
+  AliHLTTPCDigitRowData fDigits[1];
+#endif
+};
+
 #endif /* _ALIHLTTPCDIGITDATA_H_ */
index 87e851e..f5159cf 100644 (file)
@@ -30,7 +30,6 @@ using namespace std;
 
 #include "AliHLTTPCDigitReaderUnpacked.h"
 #include "AliHLTTPCDigitData.h"
-#include "AliHLTTPCRawDataFormat.h"
 #include "AliHLTTPCTransform.h"
 #include "AliHLTStdIncludes.h"
 
index 012810a..535792e 100644 (file)
@@ -1,8 +1,36 @@
 // @(#) $Id$
 // Original: AliHLTFileHandler.cxx,v 1.49 2005/06/23 17:46:55 hristov 
 
-// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>, Anders Vestbo <mailto:vestbo$fi.uib.no>, C. Loizides <mailto:loizides@ikf.uni-frankfurt.de>
-//*-- Copyright &copy ALICE HLT Group 
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ *                                                                        *
+ * Primary Authors: U. Frankenfeld, A. Vestbo, C. Loizides                *
+ *                  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   AliHLTTPCFileHandler.cxx
+    @author U. Frankenfeld, A. Vestbo, C. Loizides, maintained by
+            Matthias Richter
+    @date   
+    @brief  file input for the TPC tracking code before migration to the
+            HLT component framework
+
+// see below for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+                                                                          */
 
 #include <TClonesArray.h>
 #include <TSystem.h>
@@ -91,26 +119,6 @@ AliHLTTPCFileHandler::AliHLTTPCFileHandler(Bool_t b)
   if(fUseStaticIndex&&!fgStaticIndexCreated) CleanStaticIndex();
 }
 
-AliHLTTPCFileHandler::AliHLTTPCFileHandler(const AliHLTTPCFileHandler& ref)
-  :
-  fInAli(NULL),
-  fUseRunLoader(kFALSE),
-  fParam(NULL),
-  fDigits(NULL),
-  fDigitsTree(NULL),
-  fMC(NULL),
-  fIndexCreated(kFALSE),
-  fUseStaticIndex(ref.fUseStaticIndex)
-{
-  HLTFatal("copy constructor untested");
-}
-
-AliHLTTPCFileHandler& AliHLTTPCFileHandler::operator=(const AliHLTTPCFileHandler&)
-{ 
-  HLTFatal("assignment operator untested");
-  return *this;
-}
-
 AliHLTTPCFileHandler::~AliHLTTPCFileHandler()
 {
   //Destructor
@@ -333,7 +341,7 @@ Bool_t AliHLTTPCFileHandler::IsDigit(Int_t event)
 }
 
 ///////////////////////////////////////// Digit IO  
-Bool_t AliHLTTPCFileHandler::AliDigits2Binary(Int_t event,Bool_t altro)
+Bool_t AliHLTTPCFileHandler::AliDigits2BinaryFile(Int_t event,Bool_t altro)
 {
   //save alidigits as binary
   Bool_t out = kTRUE;
@@ -343,7 +351,7 @@ Bool_t AliHLTTPCFileHandler::AliDigits2Binary(Int_t event,Bool_t altro)
     data = AliAltroDigits2Memory(nrow,event);
   else
     data = AliDigits2Memory(nrow,event);
-  out = Memory2Binary(nrow,data);
+  out = Memory2BinaryFile(nrow,data);
   Free();
   return out;
 }
@@ -413,9 +421,10 @@ Bool_t AliHLTTPCFileHandler::CreateIndex()
   return kTRUE;
 }
 
-AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int_t event)
+AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int_t event, Byte_t* tgtBuffer, UInt_t *pTgtSize)
 {
-  //Read data from AliROOT file into memory, and store it in the HLT data format.
+  //Read data from AliROOT file into memory, and store it in the HLT data format
+  //in the provided buffer or an allocated buffer.
   //Returns a pointer to the data.
 
   AliHLTTPCDigitRowData *data = 0;
@@ -441,22 +450,38 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int
       <<"No TPC digits (entries==0)!"<<ENDLOG;
     nrow = (UInt_t)(fRowMax-fRowMin+1);
     Int_t size = nrow*sizeof(AliHLTTPCDigitRowData);
-    data=(AliHLTTPCDigitRowData*) Allocate(size);
+    if (tgtBuffer!=NULL && pTgtSize!=NULL && *pTgtSize>0) {
+      if (size<=*pTgtSize) {
+       data=reinterpret_cast<AliHLTTPCDigitRowData*>(tgtBuffer);
+      } else {
+      }
+    } else {
+      data=reinterpret_cast<AliHLTTPCDigitRowData*>(Allocate(size));
+    }
     AliHLTTPCDigitRowData *tempPt = data;
+    if (data) {
+    if (pTgtSize) *pTgtSize=size;
     for(Int_t r=fRowMin;r<=fRowMax;r++){
       tempPt->fRow = r;
       tempPt->fNDigit = 0;
       tempPt++;
     }
+    }
     return data;
   }
 
   Int_t * ndigits = new Int_t[fRowMax+1];
   Float_t xyz[3];
 
+  // The digits of the current event have been indexed: all digits are organized in
+  // rows, all digits of one row are stored in a AliSimDigits object (fDigit) which
+  // are stored in the digit tree.
+  // The index map relates the AliSimDigits objects in the tree to dedicated pad rows
+  // in the TPC
+  // This loop filters the pad rows according to the slice no set via Init
   for(Int_t r=fRowMin;r<=fRowMax;r++){
     Int_t n=fIndex[fSlice][r];
-    if(n!=-1){ //data on that row
+    if(n!=-1){ // there is data on that row available
       fDigitsTree->GetEvent(n);
       fParam->AdjustSectorRow(fDigits->GetID(),sector,row);
       AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row);
@@ -496,7 +521,16 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int
   LOG(AliHLTTPCLog::kDebug,"AliHLTTPCFileHandler::AliDigits2Memory","Digits")
     <<AliHLTTPCLog::kDec<<"Found "<<ndigitcount<<" Digits"<<ENDLOG;
   
-  data=(AliHLTTPCDigitRowData*) Allocate(size);
+  if (tgtBuffer!=NULL && pTgtSize!=NULL && *pTgtSize>0) {
+    if (size<=*pTgtSize) {
+      data=reinterpret_cast<AliHLTTPCDigitRowData*>(tgtBuffer);
+    } else {
+    }
+  } else {
+    data=reinterpret_cast<AliHLTTPCDigitRowData*>(Allocate(size));
+  }
+  if (pTgtSize) *pTgtSize=size;
+  if (data==NULL) return NULL;
   nrow = (UInt_t)nrows;
   AliHLTTPCDigitRowData *tempPt = data;
 
@@ -540,11 +574,9 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int
        tempPt->fDigitData[localcount].fCharge=dig;
        tempPt->fDigitData[localcount].fPad=pad;
        tempPt->fDigitData[localcount].fTime=time;
-#ifdef do_mc
        tempPt->fDigitData[localcount].fTrackID[0] = fDigits->GetTrackID(time,pad,0);
        tempPt->fDigitData[localcount].fTrackID[1] = fDigits->GetTrackID(time,pad,1);
        tempPt->fDigitData[localcount].fTrackID[2] = fDigits->GetTrackID(time,pad,2);
-#endif
        localcount++;
       } while (fDigits->Next());
     }
@@ -876,7 +908,6 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliAltroDigits2Memory(UInt_t & nro
          tempPt->fDigitData[localcount].fCharge=dig;
          tempPt->fDigitData[localcount].fPad=pad;
          tempPt->fDigitData[localcount].fTime=time;
-#ifdef do_mc
          tempPt->fDigitData[localcount].fTrackID[0] = (fDigits->GetTrackIDFast(time,pad,0)-2);
          tempPt->fDigitData[localcount].fTrackID[1] = (fDigits->GetTrackIDFast(time,pad,1)-2);
          tempPt->fDigitData[localcount].fTrackID[2] = (fDigits->GetTrackIDFast(time,pad,2)-2);
@@ -889,7 +920,6 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliAltroDigits2Memory(UInt_t & nro
              tempPt->fDigitData[localcount].fTrackID[1] += ((event&0x3ff)<<22);
              tempPt->fDigitData[localcount].fTrackID[2] += ((event&0x3ff)<<22);
            }
-#endif
          localcount++;
        }
       }
index 5b887fd..3745207 100644 (file)
@@ -3,7 +3,23 @@
 
 #ifndef ALIHLTTPCFILEHANDLER_H
 #define ALIHLTTPCFILEHANDLER_H
-
+/* This file is property of and copyright by the ALICE HLT Project        * 
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ * See cxx source for full Copyright notice                               */
+
+/** @file   AliHLTTPCFileHandler.h
+    @author U. Frankenfeld, A. Vestbo, C. Loizides, maintained by
+            Matthias Richter
+    @date   
+    @brief  file input for the TPC tracking code before migration to the
+            HLT component framework
+
+// see below for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+                                                                          */
 #include "AliHLTTPCMemHandler.h"
 
 class TClonesArray;
@@ -15,7 +31,6 @@ class AliTPCParam;
 class TObject;
 class TFile;
 class TTree;
-#include "AliHLTLogging.h"
 
 class AliHLTTPCSpacePointData;
 class AliHLTTPCDigitRowData;
@@ -28,15 +43,11 @@ class AliHLTTPCTrackArray;
  * the HLT component framework.
  * 
  */
-class AliHLTTPCFileHandler:public AliHLTTPCMemHandler, public AliHLTLogging {
+class AliHLTTPCFileHandler:public AliHLTTPCMemHandler {
 
  public:
   /** standard constructor */
   AliHLTTPCFileHandler(Bool_t b=kFALSE);
-  /** not a valid copy constructor, defined according to effective C++ style */
-  AliHLTTPCFileHandler(const AliHLTTPCFileHandler&);
-  /** not a valid assignment op, but defined according to effective C++ style */
-  AliHLTTPCFileHandler& operator=(const AliHLTTPCFileHandler&);
   /** destructor */
   virtual ~AliHLTTPCFileHandler();
 
@@ -55,11 +66,67 @@ class AliHLTTPCFileHandler:public AliHLTTPCMemHandler, public AliHLTLogging {
   void CloseMCOutput();
 
   //Digit IO
-  Bool_t AliDigits2Binary(Int_t event=0,Bool_t altro=kFALSE);
-  AliHLTTPCDigitRowData *AliDigits2Memory(UInt_t & nrow,Int_t event=0); //Allocates Memory
+
+  /**
+   * Write AliDigits from AliRoot file to binary file.
+   * @param event      event no
+   * @param altro      use @ref AliDigits2Memory if kFALSE and @ref
+   *                   AliDigits2Memory if kTRUE
+   *
+   * Calls the @ref AliHLTTPCMemHandler::Memory2BinaryFile to write the file.
+   */
+  Bool_t AliDigits2BinaryFile(Int_t event=0,Bool_t altro=kFALSE);
+
+  /**
+   * Convert AliDigits from AliRoot file to HLT Digit data in memory.
+   * Read and convert/write digits to memory buffer. If no target buffer available,
+   * an appropriate buffer is allocated.<br>
+   * If the variable pTgtSize is prvided, the total size of the result array is
+   * returned. \b Note: the total size differs as the @ref AliHLTTPCDigitRowData
+   * structs are variable in size depending on the no of digits for that particular
+   * row.
+   * @param nrow       [OUT] number of rows
+   * @param event      the event no
+   * @param tgtBuffer  target buffer (optional)
+   * @param pTgtSize   size of target buffer (optional)
+   * @return pointer to array, size in nrow <br>
+   *         NULL in case of failure, required size in pTgtSize
+   */
+  AliHLTTPCDigitRowData *AliDigits2Memory(UInt_t & nrow,Int_t event=0, Byte_t* tgtBuffer=NULL, UInt_t* pTgtSize=NULL);
+
+  /**
+   * Convert and filetr AliDigits from AliRoot file to HLT Digit data in memory.
+   * This functions is the same as @ref AliDigits2Memory but in addition it
+   * filters out single timebins, which is noise. The timebins which
+   * are removed are timebins which have the 4 zero neighbours; 
+   * (pad-1,time),(pad+1,time),(pad,time-1),(pad,time+1).
+   *
+   * This is legacy code, the two function contain big portions of identical code
+   * will be merged.
+   * See @ref AliDigits2Memory for detailed description.
+   */
   AliHLTTPCDigitRowData *AliAltroDigits2Memory(UInt_t & nrow,Int_t event=0,Bool_t eventmerge=kFALSE); 
-  //Allocates Memory
+
+  /**
+   * Write AliDigits from AliRoot file to binary file.
+   * @param event      event no
+   * @param altro      use @ref AliDigits2Memory if kFALSE and @ref
+   *                   AliDigits2Memory if kTRUE
+   *
+   * \b Note: pretty much the same as @ref AliDigits2BinaryFile.
+   * Calls the @ref AliHLTTPCMemHandler::Memory2CompBinary to write the file.
+   */
   Bool_t AliDigits2CompBinary(Int_t event=0,Bool_t altro=kFALSE);  
+
+  /**
+   * Write the data stored in rowPt, into a new AliROOT file.
+   * The data is stored in the AliROOT format 
+   * This is specially a nice thing if you have modified data, and wants to run it  
+   * through the offline reconstruction chain.
+   * The arguments is a pointer to the data, and the name of the new AliROOT file.
+   * Remember to pass the original AliROOT file (the one that contains the original
+   * simulated data) to this object, in order to retrieve the MC id's of the digits.
+  */
   void AliDigits2RootFile(AliHLTTPCDigitRowData *rowPt,Char_t *newDigitsfile);
 
   //Point IO
@@ -87,6 +154,12 @@ class AliHLTTPCFileHandler:public AliHLTTPCMemHandler, public AliHLTLogging {
   Bool_t GetDigitsTree(Int_t event);
   Bool_t CreateIndex();  //create the index
 
+ private:
+  /** copy constructor prohibited */
+  AliHLTTPCFileHandler(const AliHLTTPCFileHandler&);
+  /** assignment operator prohibited */
+  AliHLTTPCFileHandler& operator=(const AliHLTTPCFileHandler&);
+
   ClassDef(AliHLTTPCFileHandler,1)   //Filehandler class
 };
 
index 0b1f984..9f69b91 100644 (file)
@@ -1,9 +1,36 @@
 // @(#) $Id$
 // Original: AliHLTMemHandler.cxx,v 1.52 2005/06/14 10:55:21 cvetan 
 
-// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>, Anders Vestbo <mailto:vestbo$fi.uib.no>, Constantin Loizides <mailto:loizides@ikf.uni-frankfurt.de>
-//*-- Copyright &copy ALICE HLT Group 
-
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ *                                                                        *
+ * Primary Authors: U. Frankenfeld, A. Vestbo, C. Loizides                *
+ *                  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   AliHLTTPCMemHandler.cxx
+    @author U. Frankenfeld, A. Vestbo, C. Loizides, maintained by
+            Matthias Richter
+    @date   
+    @brief  input interface base class for the TPC tracking code before
+            migration to the HLT component framework
+
+// see below for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+                                                                          */
 /** \class AliHLTTPCMemHandler 
 <pre>
 //_____________________________________________________________
@@ -102,32 +129,6 @@ AliHLTTPCMemHandler::AliHLTTPCMemHandler()
   ResetROI();
 }
 
-AliHLTTPCMemHandler::AliHLTTPCMemHandler(const AliHLTTPCMemHandler& src)
-  :
-  fRowMin(0),
-  fRowMax(0),
-  fSlice(0),
-  fPatch(0),
-  fInBinary(NULL),
-  fOutBinary(NULL),
-  fPt(NULL),
-  fSize(0),
-  fIsRandom(kFALSE),
-  fNRandom(0),
-  fNGenerate(0),
-  fNUsed(0),
-  fNDigits(0),
-  fDPt(NULL),
-  fRandomDigits(NULL),
-  fDummy(0)
-{
-}
-
-AliHLTTPCMemHandler& AliHLTTPCMemHandler::operator=(const AliHLTTPCMemHandler& src)
-{
-  return (*this);
-}
-
 AliHLTTPCMemHandler::~AliHLTTPCMemHandler()
 {
   //Destructor
@@ -472,10 +473,10 @@ void AliHLTTPCMemHandler::DigitizePoint(Int_t row, Int_t pad,
 }
 
 ///////////////////////////////////////// Digit IO  
-Bool_t AliHLTTPCMemHandler::Memory2Binary(UInt_t nrow,AliHLTTPCDigitRowData *data)
+Bool_t AliHLTTPCMemHandler::Memory2BinaryFile(UInt_t nrow,AliHLTTPCDigitRowData *data)
 {
   //Write data to the outputfile as is. No run-length encoding is done.
-  
+
   if(!fOutBinary){
     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
       <<"No Output File"<<ENDLOG;
@@ -526,6 +527,11 @@ Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *d
   while(!feof(fInBinary)){
     Byte_t  *bytePt =(Byte_t *) rowPt;
 
+    if (sz<outsize+sizeof(AliHLTTPCDigitRowData)) {
+      LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","Memory")
+       << "target data buffer too small" <<ENDLOG;
+      return kFALSE;
+    }
     if(fread(rowPt,sizeof(AliHLTTPCDigitRowData),1,fInBinary)!=1) break;
 
     bytePt += sizeof(AliHLTTPCDigitRowData);
@@ -533,6 +539,11 @@ Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *d
 
     Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit;
 
+    if (sz<outsize+size) {
+      LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","Memory")
+       << "target data buffer too small" <<ENDLOG;
+      return kFALSE;
+    }
     //if(fread(bytePt,size,1,fInBinary)!=1) break;
     fread(bytePt,size,1,fInBinary);
     bytePt += size;
index a84e30d..7d246bc 100644 (file)
@@ -2,7 +2,23 @@
 // Original: AliHLTMemHandler.h,v 1.30 2004/10/06 08:51:20 cvetan 
 #ifndef ALIHLTTPC_MEMHANDLER_H
 #define ALIHLTTPC_MEMHANDLER_H
-
+/* This file is property of and copyright by the ALICE HLT Project        * 
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ * See cxx source for full Copyright notice                               */
+
+/** @file   AliHLTTPCMemHandler.h
+    @author U. Frankenfeld, A. Vestbo, C. Loizides, maintained by
+            Matthias Richter
+    @date   
+    @brief  input interface base class for the TPC tracking code before
+            migration to the HLT component framework
+
+// see below for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+                                                                          */
 //_____________________________________________________________
 // AliHLTTPCMemHandler
 //
@@ -32,8 +48,6 @@ class AliHLTTPCMemHandler {
  public:
   AliHLTTPCMemHandler();
   virtual ~AliHLTTPCMemHandler();
-  AliHLTTPCMemHandler(const AliHLTTPCMemHandler& src);
-  AliHLTTPCMemHandler& operator=(const AliHLTTPCMemHandler& src);
    
   void Reset(){CloseBinaryInput();CloseBinaryOutput();Free();}  
   void Init(Int_t s,Int_t p, Int_t *r=0);
@@ -58,10 +72,33 @@ class AliHLTTPCMemHandler {
   void SetROI(Float_t *eta,Int_t *slice);
   void ResetROI();
 
-  //Digit IO
-  Bool_t Memory2Binary(UInt_t nrow,AliHLTTPCDigitRowData *data);
+  ////////////////////////////////////////////////////////////////////////////////////
+  //
+  // Digit IO
+
+  /**
+   * Write digit data to binary file.
+   * The function loops over the rows and dumps all data of the
+   * AliHLTTPCDigitRowData in binary format to the file.
+   * @param nrow    size of the array
+   * @param data    data array
+   * @return kTRUE if succeeded, kFALSE if error
+   */
+  Bool_t Memory2BinaryFile(UInt_t nrow,AliHLTTPCDigitRowData *data);
+
+  /**
+   * Read digit data from binary file.
+   * @param nrow    size of the array
+   * @param data    data buffer to receive the data
+   * @param sz      [IN] buffer size [OUT] total output size
+   * @return kTRUE if succeeded, kFALSE if error
+   */
   Bool_t Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *data, UInt_t& sz);
-  Bool_t Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *data){UInt_t tmp;return Binary2Memory(nrow,data,tmp);};
+
+  // Matthias 18.09.2007
+  // this function is highly error prone, no size check for data buffer
+  // depricated
+  //Bool_t Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *data){UInt_t tmp;return Binary2Memory(nrow,data,tmp);};
 
   Int_t Memory2CompMemory(UInt_t nrow,AliHLTTPCDigitRowData *data,UInt_t *comp);
   Int_t CompMemory2Memory(UInt_t nrow,AliHLTTPCDigitRowData *data,UInt_t *comp,UInt_t& sz);
@@ -176,6 +213,10 @@ class AliHLTTPCMemHandler {
   FILE *fOutBinary;//!
 
  private:
+  /** copy constructor prohibited */
+  AliHLTTPCMemHandler(const AliHLTTPCMemHandler& src);
+  /** assignment operator prohibited */
+  AliHLTTPCMemHandler& operator=(const AliHLTTPCMemHandler& src);
   
   Byte_t *fPt;//!
   UInt_t fSize; //size of allocated data structure
diff --git a/HLT/TPCLib/AliHLTTPCRawDataFormat.h b/HLT/TPCLib/AliHLTTPCRawDataFormat.h
deleted file mode 100644 (file)
index 4944ed0..0000000
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef _ALIHLTTPCRAWDATAFORMAT_HPP_
-#define _ALIHLTTPCRAWDATAFORMAT_HPP_
-
-#include "Rtypes.h"
-#include "AliHLTTPCDigitData.h"
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* AliHLTTPCRawData
- */
-
-struct AliHLTTPCPackedRawData
-    {
-#ifndef __SUNPRO_CC
-       UInt_t fPackedDigits[];
-#else
-       UInt_t fPackedDigits[1];
-#endif
-    };
-
-struct AliHLTTPCUnpackedRawData
-    {
-#ifndef __SUNPRO_CC
-       AliHLTTPCDigitRowData fDigits[];
-#else
-       AliHLTTPCDigitRowData fDigits[1];
-#endif
-    };
-
-#endif // _ALIHLTTPCRAWDATAFORMAT_HPP_
index 239bc58..b0d4a83 100644 (file)
@@ -31,7 +31,6 @@ using namespace std;
 #include "AliTPCRawStream.h"
 #include "AliRawDataHeader.h"
 #include "AliRawReaderMemory.h"
-#include "AliHLTTPCRawDataFormat.h"
 #include "AliHLTTPCDigitData.h"
 #include "AliHLTTPCTransform.h"
 #include <stdlib.h>
diff --git a/HLT/TPCLib/legacy.txt b/HLT/TPCLib/legacy.txt
new file mode 100644 (file)
index 0000000..cd61ee4
--- /dev/null
@@ -0,0 +1,10 @@
+Some files have been kept for the sake of legacy and are now 
+removed from the repository:
+- AliHLTTPCClustFinderNew.h/.cxx removed 20.09.2007
+  was the active cluster finder when the TPC HLT code was migrated to the new
+  component interface and project scheme. Unfortunately it got the name "New"
+  when it was developed. The present AliHLTTPCClusterFinder originates from it.
+- AliHLTTPC.cxx/.h  removed 20.09.2007
+  old steering class of TPC reconstruction
+- AliHLTTPCRawDataFormat.h removed 20.09.2007
+  the structure has been added to AliHLTTPCDigitData.h
index c86a6e7..6c6efa9 100644 (file)
@@ -4,6 +4,7 @@
 include $(MODDIR)/hlt.conf
 
 MODULE_SRCS=   AliHLTTPCLog.cxx \
+               AliHLTTPCAgent.cxx \
                AliHLTTPCTransform.cxx \
                AliHLTTPCMemHandler.cxx \
                AliHLTTPCDataCompressorHelper.cxx \
@@ -31,6 +32,7 @@ MODULE_SRCS=  AliHLTTPCLog.cxx \
                tracking/AliHLTTPCHistogram.cxx \
                tracking/AliHLTTPCHistogram1D.cxx \
                tracking/AliHLTTPCHistogramAdaptive.cxx \
+               offline/AliHLTTPCDigitPublisherComponent.cxx \
                AliHLTTPCClusters.cxx \
                AliHLTTPCConfMapFit.cxx \
                AliHLTTPCConfMapTrack.cxx \
@@ -58,6 +60,7 @@ MODULE_SRCS=  AliHLTTPCLog.cxx \
 #              AliHLTTPCDDLDataFileHandler.cxx
 
 CLASS_HDRS:=   AliHLTTPCTransform.h \
+               AliHLTTPCAgent.h \
                AliHLTTPCMemHandler.h \
                AliHLTTPCDataCompressorHelper.h \
                AliHLTTPCFitter.h \
@@ -84,6 +87,7 @@ CLASS_HDRS:=          AliHLTTPCTransform.h \
                tracking/AliHLTTPCHistogram.h \
                tracking/AliHLTTPCHistogram1D.h \
                tracking/AliHLTTPCHistogramAdaptive.h \
+               offline/AliHLTTPCDigitPublisherComponent.h \
                AliHLTTPCClusters.h \
                AliHLTTPCConfMapFit.h \
                AliHLTTPCConfMapTrack.h \
@@ -121,7 +125,6 @@ MODULE_HDRS:=       $(CLASS_HDRS) \
                AliHLTTPCTrackSegmentData.h \
                AliHLTTPCVertexData.h \
                AliHLTTPCTrackletDataFormat.h \
-               AliHLTTPCRawDataFormat.h \
                AliHLTTPCClusterDataFormat.h \
                AliHLTTPCModels.h