L3 becomes HLT
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 30 Nov 2006 17:45:45 +0000 (17:45 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 30 Nov 2006 17:45:45 +0000 (17:45 +0000)
357 files changed:
ALIROOT/binaliroot.pkg
ANALYSIS/binaliengui.pkg
EVE/binalieve.pkg
EVE/macros/alieve_loadlibs.C
HLT/BASE/AliHLTStdIncludes.h
HLT/ChangeLog
HLT/ITS/AliHLTITSLinkDef.h [new file with mode: 0644]
HLT/ITS/AliHLTITSVertexerZ.cxx [moved from HLT/ITS/AliL3ITSVertexerZ.cxx with 96% similarity]
HLT/ITS/AliHLTITSVertexerZ.h [moved from HLT/ITS/AliL3ITSVertexerZ.h with 79% similarity]
HLT/ITS/AliHLTITSclusterer.cxx [moved from HLT/ITS/AliL3ITSclusterer.cxx with 92% similarity]
HLT/ITS/AliHLTITSclusterer.h [moved from HLT/ITS/AliL3ITSclusterer.h with 77% similarity]
HLT/ITS/AliHLTITStrack.cxx [moved from HLT/ITS/AliL3ITStrack.cxx with 90% similarity]
HLT/ITS/AliHLTITStrack.h [moved from HLT/ITS/AliL3ITStrack.h with 77% similarity]
HLT/ITS/AliHLTITStracker.cxx [moved from HLT/ITS/AliL3ITStracker.cxx with 93% similarity]
HLT/ITS/AliHLTITStracker.h [moved from HLT/ITS/AliL3ITStracker.h with 77% similarity]
HLT/ITS/AliL3ITSLinkDef.h [deleted file]
HLT/ITS/RunHLTITS.C
HLT/Makefile.rules
HLT/TPCLib/AliHLTTPCBenchmark.h
HLT/TPCLib/AliHLTTPCClustFinderNew.cxx
HLT/TPCLib/AliHLTTPCClustFinderNew.h
HLT/TPCLib/AliHLTTPCClusterFinder.cxx
HLT/TPCLib/AliHLTTPCClusterFinder.h
HLT/TPCLib/AliHLTTPCConfMapFit.cxx
HLT/TPCLib/AliHLTTPCConfMapFit.h
HLT/TPCLib/AliHLTTPCConfMapPoint.cxx
HLT/TPCLib/AliHLTTPCConfMapPoint.h
HLT/TPCLib/AliHLTTPCConfMapTrack.cxx
HLT/TPCLib/AliHLTTPCConfMapTrack.h
HLT/TPCLib/AliHLTTPCConfMapper.cxx
HLT/TPCLib/AliHLTTPCConfMapper.h
HLT/TPCLib/AliHLTTPCDataCompressorHelper.cxx
HLT/TPCLib/AliHLTTPCDataCompressorHelper.h
HLT/TPCLib/AliHLTTPCDigitData.h
HLT/TPCLib/AliHLTTPCFileHandler.cxx
HLT/TPCLib/AliHLTTPCFileHandler.h
HLT/TPCLib/AliHLTTPCFitter.cxx
HLT/TPCLib/AliHLTTPCFitter.h
HLT/TPCLib/AliHLTTPCGlobalMerger.cxx
HLT/TPCLib/AliHLTTPCGlobalMerger.h
HLT/TPCLib/AliHLTTPCInterMerger.cxx
HLT/TPCLib/AliHLTTPCInterMerger.h
HLT/TPCLib/AliHLTTPCLog.cxx
HLT/TPCLib/AliHLTTPCLog.h
HLT/TPCLib/AliHLTTPCLogging.h
HLT/TPCLib/AliHLTTPCMemHandler.cxx
HLT/TPCLib/AliHLTTPCMemHandler.h
HLT/TPCLib/AliHLTTPCMerger.cxx
HLT/TPCLib/AliHLTTPCMerger.h
HLT/TPCLib/AliHLTTPCModelTrack.cxx
HLT/TPCLib/AliHLTTPCModelTrack.h
HLT/TPCLib/AliHLTTPCModels.h
HLT/TPCLib/AliHLTTPCRootTypes.h
HLT/TPCLib/AliHLTTPCSpacePointData.h
HLT/TPCLib/AliHLTTPCTrack.cxx
HLT/TPCLib/AliHLTTPCTrack.h
HLT/TPCLib/AliHLTTPCTrackArray.cxx
HLT/TPCLib/AliHLTTPCTrackArray.h
HLT/TPCLib/AliHLTTPCTrackMerger.cxx
HLT/TPCLib/AliHLTTPCTrackMerger.h
HLT/TPCLib/AliHLTTPCTrackSegmentData.h
HLT/TPCLib/AliHLTTPCTransform.cxx
HLT/TPCLib/AliHLTTPCTransform.h
HLT/TPCLib/AliHLTTPCVertex.cxx
HLT/TPCLib/AliHLTTPCVertex.h
HLT/TPCLib/AliHLTTPCVertexArray.cxx
HLT/TPCLib/AliHLTTPCVertexArray.h
HLT/TPCLib/AliHLTTPCVertexData.h
HLT/TPCLib/AliHLTTPCVertexFinder.cxx
HLT/TPCLib/AliHLTTPCVertexFinder.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplay.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplay.h
HLT/bin/sethlt.sh
HLT/comp/AliHLTClusterFitter.cxx [moved from HLT/comp/AliL3ClusterFitter.cxx with 74% similarity]
HLT/comp/AliHLTClusterFitter.h [moved from HLT/comp/AliL3ClusterFitter.h with 57% similarity]
HLT/comp/AliHLTCompLinkDef.h [new file with mode: 0644]
HLT/comp/AliHLTCompress.cxx [moved from HLT/comp/AliL3Compress.cxx with 63% similarity]
HLT/comp/AliHLTCompress.h [new file with mode: 0644]
HLT/comp/AliHLTCompressAC.cxx [moved from HLT/comp/AliL3CompressAC.cxx with 76% similarity]
HLT/comp/AliHLTCompressAC.h [moved from HLT/comp/AliL3CompressAC.h with 72% similarity]
HLT/comp/AliHLTDataCompressor.cxx [moved from HLT/comp/AliL3DataCompressor.cxx with 68% similarity]
HLT/comp/AliHLTDataCompressor.h [moved from HLT/comp/AliL3DataCompressor.h with 74% similarity]
HLT/comp/AliHLTDataCompressorHelper.cxx [new file with mode: 0644]
HLT/comp/AliHLTDataCompressorHelper.h [moved from HLT/comp/AliL3DataCompressorHelper.h with 88% similarity]
HLT/comp/AliHLTFitUtilities.c [moved from HLT/comp/AliL3FitUtilities.c with 99% similarity]
HLT/comp/AliHLTFitUtilities.h [moved from HLT/comp/AliL3FitUtilities.h with 96% similarity]
HLT/comp/AliHLTModelTrack.cxx [new file with mode: 0644]
HLT/comp/AliHLTModelTrack.h [moved from HLT/comp/AliL3ModelTrack.h with 78% similarity]
HLT/comp/AliHLTModeller.cxx [moved from HLT/comp/AliL3Modeller.cxx with 68% similarity]
HLT/comp/AliHLTModeller.h [moved from HLT/comp/AliL3Modeller.h with 70% similarity]
HLT/comp/AliHLTModels.h [moved from HLT/comp/AliL3Models.h with 50% similarity]
HLT/comp/AliHLTOfflineDataCompressor.cxx [moved from HLT/comp/AliL3OfflineDataCompressor.cxx with 76% similarity]
HLT/comp/AliHLTOfflineDataCompressor.h [new file with mode: 0644]
HLT/comp/AliL3CompLinkDef.h [deleted file]
HLT/comp/AliL3Compress.h [deleted file]
HLT/comp/AliL3DataCompressorHelper.cxx [deleted file]
HLT/comp/AliL3ModelTrack.cxx [deleted file]
HLT/comp/AliL3OfflineDataCompressor.h [deleted file]
HLT/comp/Makefile
HLT/comp/rootlogon.C
HLT/doc/README
HLT/doc/changelog.bin
HLT/doc/changelog.comp
HLT/doc/changelog.doc
HLT/doc/changelog.exa
HLT/doc/changelog.hough
HLT/doc/changelog.kalman
HLT/doc/changelog.misc
HLT/doc/changelog.programs
HLT/doc/changelog.src
HLT/doc/changelog.top
HLT/doc/changelog.trigger
HLT/doc/l3transform-062003.config
HLT/doc/l3transform-cosmic-022003.config
HLT/exa/MakePileup.C
HLT/exa/SetFitParameters.C
HLT/exa/SetHoughParameters.C
HLT/exa/SetTrackingParameters_2000bf02.C
HLT/exa/SetTrackingParameters_2000bf04.C
HLT/exa/SetTrackingParameters_4000bf02.C
HLT/exa/SetTrackingParameters_4000bf04.C
HLT/exa/SetTrackingParameters_8000bf02.C
HLT/exa/SetTrackingParameters_8000bf04.C
HLT/exa/SetTrackingParameters_pp.C
HLT/exa/binary.C
HLT/exa/convert.C
HLT/exa/ddl2binary.C
HLT/exa/deconvclusters.C
HLT/exa/display.C
HLT/exa/evalrowhough.C
HLT/exa/evaltracker.C
HLT/exa/fill_pp.C
HLT/exa/read.C
HLT/exa/rootlogon-old.C
HLT/exa/rootlogon.C
HLT/exa/runcf.C
HLT/exa/runhough.C
HLT/exa/runkalman.C
HLT/exa/runrowhough.C
HLT/exa/runtracker.C
HLT/exa/runtracker_pp.C
HLT/exa/trigger_pp.C
HLT/hough/AliHLTHistogram.cxx [moved from HLT/hough/AliL3Histogram.cxx with 71% similarity]
HLT/hough/AliHLTHistogram.h [moved from HLT/hough/AliL3Histogram.h with 77% similarity]
HLT/hough/AliHLTHistogram1D.cxx [moved from HLT/hough/AliL3Histogram1D.cxx with 69% similarity]
HLT/hough/AliHLTHistogram1D.h [moved from HLT/hough/AliL3Histogram1D.h with 75% similarity]
HLT/hough/AliHLTHistogramAdaptive.cxx [moved from HLT/hough/AliL3HistogramAdaptive.cxx with 73% similarity]
HLT/hough/AliHLTHistogramAdaptive.h [moved from HLT/hough/AliL3HistogramAdaptive.h with 60% similarity]
HLT/hough/AliHLTHough.cxx [moved from HLT/hough/AliL3Hough.cxx with 70% similarity]
HLT/hough/AliHLTHough.h [moved from HLT/hough/AliL3Hough.h with 73% similarity]
HLT/hough/AliHLTHoughBaseTransformer.cxx [moved from HLT/hough/AliL3HoughBaseTransformer.cxx with 62% similarity]
HLT/hough/AliHLTHoughBaseTransformer.h [moved from HLT/hough/AliL3HoughBaseTransformer.h with 76% similarity]
HLT/hough/AliHLTHoughClusterTransformer.cxx [moved from HLT/hough/AliL3HoughClusterTransformer.cxx with 65% similarity]
HLT/hough/AliHLTHoughClusterTransformer.h [moved from HLT/hough/AliL3HoughClusterTransformer.h with 51% similarity]
HLT/hough/AliHLTHoughDisplay.cxx [moved from HLT/hough/AliL3HoughDisplay.cxx with 63% similarity]
HLT/hough/AliHLTHoughDisplay.h [new file with mode: 0644]
HLT/hough/AliHLTHoughEval.cxx [moved from HLT/hough/AliL3HoughEval.cxx with 67% similarity]
HLT/hough/AliHLTHoughEval.h [new file with mode: 0644]
HLT/hough/AliHLTHoughGlobalMerger.cxx [new file with mode: 0644]
HLT/hough/AliHLTHoughGlobalMerger.h [new file with mode: 0644]
HLT/hough/AliHLTHoughIntMerger.cxx [moved from HLT/hough/AliL3HoughIntMerger.cxx with 57% similarity]
HLT/hough/AliHLTHoughIntMerger.h [new file with mode: 0644]
HLT/hough/AliHLTHoughKalmanTrack.cxx [moved from HLT/hough/AliL3HoughKalmanTrack.cxx with 79% similarity]
HLT/hough/AliHLTHoughKalmanTrack.h [moved from HLT/hough/AliL3HoughKalmanTrack.h with 69% similarity]
HLT/hough/AliHLTHoughLinkDef.h [new file with mode: 0644]
HLT/hough/AliHLTHoughMaxFinder.cxx [moved from HLT/hough/AliL3HoughMaxFinder.cxx with 89% similarity]
HLT/hough/AliHLTHoughMaxFinder.h [moved from HLT/hough/AliL3HoughMaxFinder.h with 66% similarity]
HLT/hough/AliHLTHoughMerger.cxx [moved from HLT/hough/AliL3HoughMerger.cxx with 67% similarity]
HLT/hough/AliHLTHoughMerger.h [new file with mode: 0644]
HLT/hough/AliHLTHoughTest.cxx [moved from HLT/hough/AliL3HoughTest.cxx with 64% similarity]
HLT/hough/AliHLTHoughTest.h [new file with mode: 0644]
HLT/hough/AliHLTHoughTrack.cxx [moved from HLT/hough/AliL3HoughTrack.cxx with 68% similarity]
HLT/hough/AliHLTHoughTrack.h [moved from HLT/hough/AliL3HoughTrack.h with 84% similarity]
HLT/hough/AliHLTHoughTransformer.cxx [moved from HLT/hough/AliL3HoughTransformer.cxx with 56% similarity]
HLT/hough/AliHLTHoughTransformer.h [moved from HLT/hough/AliL3HoughTransformer.h with 64% similarity]
HLT/hough/AliHLTHoughTransformerGlobal.cxx [moved from HLT/hough/AliL3HoughTransformerGlobal.cxx with 60% similarity]
HLT/hough/AliHLTHoughTransformerGlobal.h [moved from HLT/hough/AliL3HoughTransformerGlobal.h with 54% similarity]
HLT/hough/AliHLTHoughTransformerLUT.cxx [moved from HLT/hough/AliL3HoughTransformerLUT.cxx with 71% similarity]
HLT/hough/AliHLTHoughTransformerLUT.h [moved from HLT/hough/AliL3HoughTransformerLUT.h with 73% similarity]
HLT/hough/AliHLTHoughTransformerNew.cxx [moved from HLT/hough/AliL3HoughTransformerNew.cxx with 50% similarity]
HLT/hough/AliHLTHoughTransformerNew.h [moved from HLT/hough/AliL3HoughTransformerNew.h with 50% similarity]
HLT/hough/AliHLTHoughTransformerRow.cxx [moved from HLT/hough/AliL3HoughTransformerRow.cxx with 76% similarity]
HLT/hough/AliHLTHoughTransformerRow.h [moved from HLT/hough/AliL3HoughTransformerRow.h with 74% similarity]
HLT/hough/AliHLTHoughTransformerVhdl.cxx [moved from HLT/hough/AliL3HoughTransformerVhdl.cxx with 79% similarity]
HLT/hough/AliHLTHoughTransformerVhdl.h [moved from HLT/hough/AliL3HoughTransformerVhdl.h with 61% similarity]
HLT/hough/AliL3HoughDisplay.h [deleted file]
HLT/hough/AliL3HoughEval.h [deleted file]
HLT/hough/AliL3HoughGlobalMerger.cxx [deleted file]
HLT/hough/AliL3HoughGlobalMerger.h [deleted file]
HLT/hough/AliL3HoughIntMerger.h [deleted file]
HLT/hough/AliL3HoughLinkDef.h [deleted file]
HLT/hough/AliL3HoughMerger.h [deleted file]
HLT/hough/AliL3HoughTest.h [deleted file]
HLT/hough/Makefile
HLT/kalman/AliHLTKalman.cxx [moved from HLT/kalman/AliL3Kalman.cxx with 73% similarity]
HLT/kalman/AliHLTKalman.h [new file with mode: 0644]
HLT/kalman/AliHLTKalmanLinkDef.h [new file with mode: 0644]
HLT/kalman/AliHLTKalmanTrack.cxx [moved from HLT/kalman/AliL3KalmanTrack.cxx with 89% similarity]
HLT/kalman/AliHLTKalmanTrack.h [moved from HLT/kalman/AliL3KalmanTrack.h with 83% similarity]
HLT/kalman/AliL3Kalman.h [deleted file]
HLT/kalman/AliL3KalmanLinkDef.h [deleted file]
HLT/kalman/Makefile
HLT/libAliL3Comp.pkg [deleted file]
HLT/libAliL3Hough.pkg [deleted file]
HLT/libAliL3ITS.pkg [deleted file]
HLT/libAliL3MUON.pkg [deleted file]
HLT/libAliL3Misc.pkg [deleted file]
HLT/libAliL3Src.pkg [deleted file]
HLT/misc/AliHLTAltroMemHandler.cxx [moved from HLT/misc/AliL3AltroMemHandler.cxx with 72% similarity]
HLT/misc/AliHLTAltroMemHandler.h [moved from HLT/misc/AliL3AltroMemHandler.h with 86% similarity]
HLT/misc/AliHLTDDLDataFileHandler.cxx [moved from HLT/misc/AliL3DDLDataFileHandler.cxx with 61% similarity]
HLT/misc/AliHLTDDLDataFileHandler.h [moved from HLT/misc/AliL3DDLDataFileHandler.h with 50% similarity]
HLT/misc/AliHLTDDLRawReader.cxx [moved from HLT/misc/AliL3DDLRawReader.cxx with 74% similarity]
HLT/misc/AliHLTDDLRawReader.h [moved from HLT/misc/AliL3DDLRawReader.h with 83% similarity]
HLT/misc/AliHLTDDLRawReaderFile.cxx [moved from HLT/misc/AliL3DDLRawReaderFile.cxx with 83% similarity]
HLT/misc/AliHLTDDLRawReaderFile.h [moved from HLT/misc/AliL3DDLRawReaderFile.h with 63% similarity]
HLT/misc/AliHLTDDLTPCRawStream.cxx [moved from HLT/misc/AliL3DDLTPCRawStream.cxx with 82% similarity]
HLT/misc/AliHLTDDLTPCRawStream.h [moved from HLT/misc/AliL3DDLTPCRawStream.h with 83% similarity]
HLT/misc/AliHLTDataHandler.cxx [moved from HLT/misc/AliL3DataHandler.cxx with 75% similarity]
HLT/misc/AliHLTDataHandler.h [new file with mode: 0644]
HLT/misc/AliHLTFFloat.cxx [moved from HLT/misc/AliL3FFloat.cxx with 62% similarity]
HLT/misc/AliHLTFFloat.h [new file with mode: 0644]
HLT/misc/AliHLTMiscLinkDef.h [new file with mode: 0644]
HLT/misc/AliHLTStopwatch.cxx [moved from HLT/misc/AliL3Stopwatch.cxx with 75% similarity]
HLT/misc/AliHLTStopwatch.h [moved from HLT/misc/AliL3Stopwatch.h with 86% similarity]
HLT/misc/AliHLTTPCMapping-iroc.generated [new file with mode: 0644]
HLT/misc/AliHLTTPCMapping-oroc.generated [new file with mode: 0644]
HLT/misc/AliHLTTPCMapping.cxx [moved from HLT/misc/AliL3TPCMapping.cxx with 88% similarity]
HLT/misc/AliHLTTPCMapping.h [moved from HLT/misc/AliL3TPCMapping.h with 93% similarity]
HLT/misc/AliHLTTransBit.cxx [moved from HLT/misc/AliL3TransBit.cxx with 92% similarity]
HLT/misc/AliHLTTransBit.h [moved from HLT/misc/AliL3TransBit.h with 57% similarity]
HLT/misc/AliHLTVHDLClusterFinder.cxx [moved from HLT/misc/AliL3VHDLClusterFinder.cxx with 83% similarity]
HLT/misc/AliHLTVHDLClusterFinder.h [moved from HLT/misc/AliL3VHDLClusterFinder.h with 88% similarity]
HLT/misc/AliL3DataHandler.h [deleted file]
HLT/misc/AliL3FFloat.h [deleted file]
HLT/misc/AliL3MiscLinkDef.h [deleted file]
HLT/misc/AliL3TPCMapping-iroc.generated [deleted file]
HLT/misc/AliL3TPCMapping-oroc.generated [deleted file]
HLT/misc/Makefile
HLT/programs/Makefile
HLT/programs/ali2raw.cxx
HLT/programs/convcosmicsfile.cxx
HLT/programs/gettransform.cxx
HLT/programs/read.cxx
HLT/programs/runhough.cxx
HLT/programs/runit.cxx
HLT/programs/runtracker.cxx
HLT/programs/runvhdlcf.cxx
HLT/programs/runvhdlhough.cxx
HLT/programs/speedtest.cxx
HLT/programs/speedtest.h
HLT/programs/tpcbeamtestdisplay.cxx
HLT/programs/tpcbeamtesttracker.cxx
HLT/sim/AliHLTGenerator.cxx [moved from HLT/sim/AliL3Generator.cxx with 57% similarity]
HLT/sim/AliHLTGenerator.h [new file with mode: 0644]
HLT/sim/AliL3Generator.h [deleted file]
HLT/src/AliHLTBenchmark.cxx [moved from HLT/src/AliL3Benchmark.cxx with 86% similarity]
HLT/src/AliHLTBenchmark.h [moved from HLT/src/AliL3Benchmark.h with 72% similarity]
HLT/src/AliHLTClustFinderNew.cxx [moved from HLT/src/AliL3ClustFinderNew.cxx with 78% similarity]
HLT/src/AliHLTClustFinderNew.h [moved from HLT/src/AliL3ClustFinderNew.h with 78% similarity]
HLT/src/AliHLTConfMapFit.cxx [moved from HLT/src/AliL3ConfMapFit.cxx with 81% similarity]
HLT/src/AliHLTConfMapFit.h [new file with mode: 0644]
HLT/src/AliHLTConfMapPoint.cxx [moved from HLT/src/AliL3ConfMapPoint.cxx with 84% similarity]
HLT/src/AliHLTConfMapPoint.h [moved from HLT/src/AliL3ConfMapPoint.h with 83% similarity]
HLT/src/AliHLTConfMapTrack.cxx [moved from HLT/src/AliL3ConfMapTrack.cxx with 73% similarity]
HLT/src/AliHLTConfMapTrack.h [moved from HLT/src/AliL3ConfMapTrack.h with 68% similarity]
HLT/src/AliHLTConfMapper.cxx [moved from HLT/src/AliL3ConfMapper.cxx with 73% similarity]
HLT/src/AliHLTConfMapper.h [moved from HLT/src/AliL3ConfMapper.h with 76% similarity]
HLT/src/AliHLTDigitData.h [new file with mode: 0644]
HLT/src/AliHLTDisplay.cxx [moved from HLT/src/AliL3Display.cxx with 80% similarity]
HLT/src/AliHLTDisplay.h [moved from HLT/src/AliL3Display.h with 56% similarity]
HLT/src/AliHLTEvaluate.cxx [moved from HLT/src/AliL3Evaluate.cxx with 78% similarity]
HLT/src/AliHLTEvaluate.h [moved from HLT/src/AliL3Evaluate.h with 82% similarity]
HLT/src/AliHLTFileHandler.cxx [moved from HLT/src/AliL3FileHandler.cxx with 73% similarity]
HLT/src/AliHLTFileHandler.h [moved from HLT/src/AliL3FileHandler.h with 69% similarity]
HLT/src/AliHLTFitter.cxx [moved from HLT/src/AliL3Fitter.cxx with 86% similarity]
HLT/src/AliHLTFitter.h [new file with mode: 0644]
HLT/src/AliHLTGlobalMerger.cxx [moved from HLT/src/AliL3GlobalMerger.cxx with 77% similarity]
HLT/src/AliHLTGlobalMerger.h [new file with mode: 0644]
HLT/src/AliHLTInterMerger.cxx [moved from HLT/src/AliL3InterMerger.cxx with 67% similarity]
HLT/src/AliHLTInterMerger.h [moved from HLT/src/AliL3InterMerger.h with 55% similarity]
HLT/src/AliHLTLog.cxx [new file with mode: 0644]
HLT/src/AliHLTLog.h [moved from HLT/src/AliL3Log.h with 68% similarity]
HLT/src/AliHLTLogger.cxx [moved from HLT/src/AliL3Logger.cxx with 51% similarity]
HLT/src/AliHLTLogger.h [moved from HLT/src/AliL3Logger.h with 78% similarity]
HLT/src/AliHLTLogging.h [new file with mode: 0644]
HLT/src/AliHLTMemHandler.cxx [moved from HLT/src/AliL3MemHandler.cxx with 62% similarity]
HLT/src/AliHLTMemHandler.h [moved from HLT/src/AliL3MemHandler.h with 65% similarity]
HLT/src/AliHLTMerger.cxx [moved from HLT/src/AliL3Merger.cxx with 70% similarity]
HLT/src/AliHLTMerger.h [new file with mode: 0644]
HLT/src/AliHLTRawDataFileHandler.cxx [moved from HLT/src/AliL3RawDataFileHandler.cxx with 63% similarity]
HLT/src/AliHLTRawDataFileHandler.h [moved from HLT/src/AliL3RawDataFileHandler.h with 83% similarity]
HLT/src/AliHLTReconstructor.cxx
HLT/src/AliHLTReconstructor.h
HLT/src/AliHLTRootTypes.h [moved from HLT/src/AliL3RootTypes.h with 96% similarity]
HLT/src/AliHLTSpacePointData.h [moved from HLT/src/AliL3SpacePointData.h with 71% similarity]
HLT/src/AliHLTSrcLinkDef.h [new file with mode: 0644]
HLT/src/AliHLTStandardIncludes.h [moved from HLT/src/AliL3StandardIncludes.h with 100% similarity]
HLT/src/AliHLTTPCBeamTestMemHandler.cxx [moved from HLT/src/AliL3TPCBeamTestMemHandler.cxx with 64% similarity]
HLT/src/AliHLTTPCBeamTestMemHandler.h [moved from HLT/src/AliL3TPCBeamTestMemHandler.h with 74% similarity]
HLT/src/AliHLTTPCtracker.cxx [moved from HLT/src/AliL3TPCtracker.cxx with 84% similarity]
HLT/src/AliHLTTPCtracker.h [moved from HLT/src/AliL3TPCtracker.h with 84% similarity]
HLT/src/AliHLTTrack.cxx [moved from HLT/src/AliL3Track.cxx with 75% similarity]
HLT/src/AliHLTTrack.h [moved from HLT/src/AliL3Track.h with 92% similarity]
HLT/src/AliHLTTrackArray.cxx [moved from HLT/src/AliL3TrackArray.cxx with 65% similarity]
HLT/src/AliHLTTrackArray.h [new file with mode: 0644]
HLT/src/AliHLTTrackMerger.cxx [moved from HLT/src/AliL3TrackMerger.cxx with 67% similarity]
HLT/src/AliHLTTrackMerger.h [moved from HLT/src/AliL3TrackMerger.h with 56% similarity]
HLT/src/AliHLTTrackSegmentData.h [moved from HLT/src/AliL3TrackSegmentData.h with 87% similarity]
HLT/src/AliHLTTransform.cxx [moved from HLT/src/AliL3Transform.cxx with 82% similarity]
HLT/src/AliHLTTransform.h [moved from HLT/src/AliL3Transform.h with 98% similarity]
HLT/src/AliHLTVertex.cxx [moved from HLT/src/AliL3Vertex.cxx with 60% similarity]
HLT/src/AliHLTVertex.h [moved from HLT/src/AliL3Vertex.h with 73% similarity]
HLT/src/AliHLTVertexArray.cxx [moved from HLT/src/AliL3VertexArray.cxx with 83% similarity]
HLT/src/AliHLTVertexArray.h [moved from HLT/src/AliL3VertexArray.h with 73% similarity]
HLT/src/AliHLTVertexData.h [moved from HLT/src/AliL3VertexData.h with 65% similarity]
HLT/src/AliHLTVertexFinder.cxx [moved from HLT/src/AliL3VertexFinder.cxx with 59% similarity]
HLT/src/AliHLTVertexFinder.h [moved from HLT/src/AliL3VertexFinder.h with 60% similarity]
HLT/src/AliL3ConfMapFit.h [deleted file]
HLT/src/AliL3DigitData.h [deleted file]
HLT/src/AliL3Fitter.h [deleted file]
HLT/src/AliL3GlobalMerger.h [deleted file]
HLT/src/AliL3Log.cxx [deleted file]
HLT/src/AliL3Logging.h [deleted file]
HLT/src/AliL3Merger.h [deleted file]
HLT/src/AliL3SrcLinkDef.h [deleted file]
HLT/src/AliL3TrackArray.h [deleted file]
HLT/src/AliLevel3.cxx
HLT/src/AliLevel3.h
HLT/src/Makefile
HLT/src/l3transform.config
HLT/trigger/AliD0Trigger.cxx
HLT/trigger/AliD0Trigger.h
HLT/trigger/AliHLTTrigger.cxx [moved from HLT/trigger/AliL3Trigger.cxx with 59% similarity]
HLT/trigger/AliHLTTrigger.h [new file with mode: 0644]
HLT/trigger/AliHLTTriggerLinkDef.h [moved from HLT/trigger/AliL3TriggerLinkDef.h with 100% similarity]
HLT/trigger/AliL3Trigger.h [deleted file]
HLT/trigger/Makefile
JETAN/jetan2004/AliJetParticlesReaderHLT.cxx
JETAN/jetan2004/rootlogon.C
MONITOR/AliMonitorHLT.cxx
MONITOR/AliMonitorHLTHough.cxx
MONITOR/AliMonitorProcess.cxx
MONITOR/AliMonitorProcess.h
MONITOR/binmonitorCheck.pkg
MONITOR/binmonitorGDC.pkg
MONITOR/client.C
MONITOR/monitor.C
MONITOR/monitorGDC.cxx
RAW/AliHoughFilter.cxx
RAW/Makefile
RAW/binalimdc.pkg
RAW/bindateStream.pkg
STEER/AliReconstruction.cxx
build/module.dep
macros/loadlibs.C
macros/loadlibsrec.C

index 7e2d484..c29f98e 100644 (file)
@@ -18,8 +18,8 @@ ELIBS:= MUONgeometry MUONrec MUONsim MUONbase MUONraw MUONmapping \
         hijing TMEVSIM mevsim THbtp HBTP TEPEMGEN EPEMGEN \
         FASTSIM microcern \
        RAWDatabase RAWDatarec RAWDatasim \
-       AliL3Src AliL3Comp AliL3Misc AliL3MUON \
-       AliL3Hough AliL3ITS \
+       AliHLTSrc AliHLTComp AliHLTMisc AliHLTMUON \
+       AliHLTHough AliHLTITS \
 #      THerwig herwig TPHIC
 
 ifeq (macosx,$(ALICE_TARGET))
index df1442c..ce2dd76 100644 (file)
@@ -16,8 +16,8 @@ ELIBS    := Aliengui MUONgeometry MUONrec MUONsim MUONbase MUONraw MUONmapping \
   hijing TMEVSIM mevsim THbtp HBTP TEPEMGEN EPEMGEN \
   FASTSIM microcern \
   RAWDatabase RAWDatarec RAWDatasim \
-  AliL3Src AliL3Comp AliL3Misc AliL3MUON \
-  AliL3Hough AliL3ITS
+  AliHLTSrc AliHLTComp AliHLTMisc AliHLTMUON \
+  AliHLTHough AliHLTITS
 
 PACKBLIBS := -L$(ROOTSYS)/lib $(ROOTCLIBS) $(ROOTPLIBS) $(SYSLIBS)
 
index 59bbd03..178c60d 100644 (file)
@@ -17,8 +17,8 @@ ELIBS    := Reve Alieve \
   hijing TMEVSIM mevsim THbtp HBTP TEPEMGEN EPEMGEN \
   FASTSIM microcern \
   RAWDatabase RAWDatarec RAWDatasim \
-  AliL3Src AliL3Comp AliL3Misc AliL3MUON \
-  AliL3Hough AliL3ITS \
+  AliHLTSrc AliHLTComp AliHLTMisc AliHLTMUON \
+  AliHLTHough AliHLTITS \
 # THerwig herwig TPHIC
 
 PACKBLIBS := $(ROOTCLIBS) $(ROOTPLIBS) -lTreePlayer -lGeomPainter -lGed -lRGL $(SYSLIBS)
index 1d8bd68..8ba5488 100644 (file)
@@ -93,12 +93,12 @@ void alieve_loadlibs ()
   gSystem->Load("libTOFsim");
   gSystem->Load("libTOFrec");
 
-  gSystem->Load("libAliL3ITS");
-  gSystem->Load("libAliL3Src");
-  gSystem->Load("libAliL3Misc");
-  gSystem->Load("libAliL3Comp");
+  gSystem->Load("libAliHLTITS");
+  gSystem->Load("libAliHLTSrc");
+  gSystem->Load("libAliHLTMisc");
+  gSystem->Load("libAliHLTComp");
   gSystem->Load("libThread");
-  gSystem->Load("libAliL3Hough");
+  gSystem->Load("libAliHLTHough");
   gSystem->Load("libANALYSIS");
 
   gSystem->Load("libAlieve.so");
index 47acaea..2e44784 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original file : src/AliL3StandardIncludes.h,v 1.5
+// Original file : src/AliHLTStandardIncludes.h,v 1.5
 
 #ifndef ALIHLTSTDINCLUDESH
 #define ALIHLTSTDINCLUDESH
index f6b9062..6220e8c 100644 (file)
 
 2005-09-07 Files imported from src comp and kalman into new TPCLib
        a short history of files ...
-       AliHLTTPCBenchmark.cxx                           AliL3Benchmark.cxx,v 1.10 2005/06/14 10:55:21 cvetan Exp 
-       AliHLTTPCBenchmark.h                             AliL3Benchmark.h,v 1.6 2004/06/26 11:39:40 loizides 
-       AliHLTTPCClusterFinder.cxx                       original AliL3ClustFinderNew.cxx
-       AliHLTTPCClusterFinder.h                         original AliL3ClustFinderNew.h                                          
-       AliHLTTPCClustFinderNew.cxx                      AliL3ClustFinderNew.cxx,v 1.29 2005/06/14 10:55:21 cvetan Exp  
-       AliHLTTPCClustFinderNew.h                        AliL3ClustFinderNew.h,v 1.13 2004/06/18 10:55:26 loizides Exp          
-       AliHLTTPCConfMapFit.cxx                          AliL3ConfMapFit.cxx,v 1.14 2005/06/14 10:55:21 cvetan Exp      
-       AliHLTTPCConfMapFit.h                            AliL3ConfMapFit.h,v 1.5 2004/07/05 09:03:11 loizides Exp          
-       AliHLTTPCConfMapper.cxx                          AliL3ConfMapper.cxx,v 1.26 2005/06/14 10:55:21 cvetan Exp $    
-       AliHLTTPCConfMapper.h                            AliL3ConfMapper.h,v 1.11 2004/07/05 09:03:11 loizides Exp $              
-       AliHLTTPCConfMapPoint.cxx                        AliL3ConfMapPoint.cxx,v 1.10 2005/06/23 17:46:55 hristov Exp $ 
-       AliHLTTPCConfMapPoint.h                          AliL3ConfMapPoint.h,v 1.8 2005/06/23 17:46:55 hristov Exp $    
-       AliHLTTPCConfMapTrack.cxx                        AliL3ConfMapTrack.cxx,v 1.16 2005/06/14 10:55:21 cvetan Exp $  
-       AliHLTTPCConfMapTrack.h                          AliL3ConfMapTrack.h,v 1.4 2004/06/16 11:25:06 loizides Exp $   
+       AliHLTTPCBenchmark.cxx                           AliHLTBenchmark.cxx,v 1.10 2005/06/14 10:55:21 cvetan Exp 
+       AliHLTTPCBenchmark.h                             AliHLTBenchmark.h,v 1.6 2004/06/26 11:39:40 loizides 
+       AliHLTTPCClusterFinder.cxx                       original AliHLTClustFinderNew.cxx
+       AliHLTTPCClusterFinder.h                         original AliHLTClustFinderNew.h                                                 
+       AliHLTTPCClustFinderNew.cxx                      AliHLTClustFinderNew.cxx,v 1.29 2005/06/14 10:55:21 cvetan Exp         
+       AliHLTTPCClustFinderNew.h                        AliHLTClustFinderNew.h,v 1.13 2004/06/18 10:55:26 loizides Exp                 
+       AliHLTTPCConfMapFit.cxx                          AliHLTConfMapFit.cxx,v 1.14 2005/06/14 10:55:21 cvetan Exp     
+       AliHLTTPCConfMapFit.h                            AliHLTConfMapFit.h,v 1.5 2004/07/05 09:03:11 loizides Exp         
+       AliHLTTPCConfMapper.cxx                          AliHLTConfMapper.cxx,v 1.26 2005/06/14 10:55:21 cvetan Exp $   
+       AliHLTTPCConfMapper.h                            AliHLTConfMapper.h,v 1.11 2004/07/05 09:03:11 loizides Exp $             
+       AliHLTTPCConfMapPoint.cxx                        AliHLTConfMapPoint.cxx,v 1.10 2005/06/23 17:46:55 hristov Exp $        
+       AliHLTTPCConfMapPoint.h                          AliHLTConfMapPoint.h,v 1.8 2005/06/23 17:46:55 hristov Exp $           
+       AliHLTTPCConfMapTrack.cxx                        AliHLTConfMapTrack.cxx,v 1.16 2005/06/14 10:55:21 cvetan Exp $ 
+       AliHLTTPCConfMapTrack.h                          AliHLTConfMapTrack.h,v 1.4 2004/06/16 11:25:06 loizides Exp $  
        AliHLTTPC.cxx                                    AliLevel3.cxx,v 1.42 2004/06/11 16:06:33 loizides Exp $
                                                                Mod: Digits-thing
-       AliHLTTPCDigitData.h                             AliL3DigitData.h,v 1.5 2004/05/12 11:51:27 loizides Exp $      
-       AliHLTTPCDisplay.cxx                             AliL3Display.cxx,v 1.26 2005/06/14 10:55:21 cvetan Exp $
+       AliHLTTPCDigitData.h                             AliHLTDigitData.h,v 1.5 2004/05/12 11:51:27 loizides Exp $     
+       AliHLTTPCDisplay.cxx                             AliHLTDisplay.cxx,v 1.26 2005/06/14 10:55:21 cvetan Exp $
                                                                Mod.
-       AliHLTTPCDisplay.h                               AliL3Display.h,v 1.14 2004/06/30 08:30:14 loizides Exp $
+       AliHLTTPCDisplay.h                               AliHLTDisplay.h,v 1.14 2004/06/30 08:30:14 loizides Exp $
                                                                Mod. 
-       AliHLTTPCFileHandler.cxx                         AliL3FileHandler.cxx,v 1.49 2005/06/23 17:46:55 hristov Exp $           
-       AliHLTTPCFileHandler.h                           AliL3FileHandler.h,v 1.19 2004/06/11 16:06:33 loizides Exp $   
-       AliHLTTPCFitter.cxx                              AliL3Fitter.cxx,v 1.14 2005/06/14 10:55:21 cvetan Exp $        
-       AliHLTTPCFitter.h                                AliL3Fitter.h,v 1.7 2004/07/05 09:02:18 loizides Exp $         
-       AliHLTTPCGlobalMerger.cxx                        AliL3GlobalMerger.cxx,v 1.13 2005/06/14 10:55:21 cvetan Exp $  
-       AliHLTTPCGlobalMerger.h                          AliL3GlobalMerger.h,v 1.6 2004/02/02 15:00:34 loizides Exp $   
+       AliHLTTPCFileHandler.cxx                         AliHLTFileHandler.cxx,v 1.49 2005/06/23 17:46:55 hristov Exp $          
+       AliHLTTPCFileHandler.h                           AliHLTFileHandler.h,v 1.19 2004/06/11 16:06:33 loizides Exp $  
+       AliHLTTPCFitter.cxx                              AliHLTFitter.cxx,v 1.14 2005/06/14 10:55:21 cvetan Exp $       
+       AliHLTTPCFitter.h                                AliHLTFitter.h,v 1.7 2004/07/05 09:02:18 loizides Exp $                
+       AliHLTTPCGlobalMerger.cxx                        AliHLTGlobalMerger.cxx,v 1.13 2005/06/14 10:55:21 cvetan Exp $ 
+       AliHLTTPCGlobalMerger.h                          AliHLTGlobalMerger.h,v 1.6 2004/02/02 15:00:34 loizides Exp $  
        AliHLTTPC.h                                      AliLevel3.h,v 1.24 2004/06/11 16:06:33 loizides 
                                                                Added AliHLTDigitReaderUnpacked  
-       AliHLTTPCInterMerger.cxx                         AliL3InterMerger.cxx,v 1.8 2005/06/14 10:55:21 cvetan Exp $    
-       AliHLTTPCInterMerger.h                           AliL3InterMerger.h,v 1.4 2004/02/02 15:00:34 loizides Exp $    
-       AliHLTTPCLog.cxx                                 AliL3Log.cxx,v 1.1 2004/05/14 09:37:22 loizides Exp $  
-       AliHLTTPCLogging.h                               AliL3Logging.h,v 1.11 2004/10/09 11:28:31 loizides Exp $       
-       AliHLTTPCLog.h                                   AliL3Log.h,v 1.2 2004/06/11 16:06:33 loizides Exp $    
-       AliHLTTPCMemHandler.cxx                          AliL3MemHandler.cxx,v 1.52 2005/06/14 10:55:21 cvetan Exp $    
-       AliHLTTPCMemHandler.h                            AliL3MemHandler.h,v 1.30 2004/10/06 08:51:20 cvetan Exp $               
-       AliHLTTPCMerger.cxx                              AliL3Merger.cxx,v 1.16 2005/06/14 10:55:21 cvetan Exp $        
-       AliHLTTPCMerger.h                                AliL3Merger.h,v 1.8 2004/06/11 16:06:33 loizides Exp $ 
-       AliHLTTPCRootTypes.h                             AliL3RootTypes.h,v 1.12 2004/06/15 14:02:38 loizides Exp $     
-       AliHLTTPCSpacePointData.h                        AliL3SpacePointData.h,v1.4 2003/07/27 21:02:09 loizides Exp $
+       AliHLTTPCInterMerger.cxx                         AliHLTInterMerger.cxx,v 1.8 2005/06/14 10:55:21 cvetan Exp $   
+       AliHLTTPCInterMerger.h                           AliHLTInterMerger.h,v 1.4 2004/02/02 15:00:34 loizides Exp $   
+       AliHLTTPCLog.cxx                                 AliHLTLog.cxx,v 1.1 2004/05/14 09:37:22 loizides Exp $ 
+       AliHLTTPCLogging.h                               AliHLTLogging.h,v 1.11 2004/10/09 11:28:31 loizides Exp $      
+       AliHLTTPCLog.h                                   AliHLTLog.h,v 1.2 2004/06/11 16:06:33 loizides Exp $   
+       AliHLTTPCMemHandler.cxx                          AliHLTMemHandler.cxx,v 1.52 2005/06/14 10:55:21 cvetan Exp $   
+       AliHLTTPCMemHandler.h                            AliHLTMemHandler.h,v 1.30 2004/10/06 08:51:20 cvetan Exp $              
+       AliHLTTPCMerger.cxx                              AliHLTMerger.cxx,v 1.16 2005/06/14 10:55:21 cvetan Exp $       
+       AliHLTTPCMerger.h                                AliHLTMerger.h,v 1.8 2004/06/11 16:06:33 loizides Exp $        
+       AliHLTTPCRootTypes.h                             AliHLTRootTypes.h,v 1.12 2004/06/15 14:02:38 loizides Exp $    
+       AliHLTTPCSpacePointData.h                        AliHLTSpacePointData.h,v1.4 2003/07/27 21:02:09 loizides Exp $
                                                                Added: Bool_t fUsed;
-       AliHLTTPCStandardIncludes.h                      AliL3StandardIncludes.h,v 1.5 2005/06/14 10:55:21 cvetan Exp $ 
-       AliHLTTPCTrackArray.cxx                          AliL3TrackArray.cxx,v 1.21 2005/06/14 10:55:21 cvetan Exp $    
-       AliHLTTPCTrackArray.h                            AliL3TrackArray.h,v 1.7 2004/06/11 16:06:33 loizides Exp $     
-       AliHLTTPCTrack.cxx                               AliL3Track.cxx,v 1.322005/06/14 10:55:21 cvetan Exp $  
-       AliHLTTPCTrack.h                                 AliL3Track.h,v 1.18 2005/03/31 04:48:58 cvetan Exp $   
-       AliHLTTPCTrackMerger.cxx                         AliL3TrackMerger.cxx,v 1.12 2005/06/14 10:55:21 cvetan Exp $   
-       AliHLTTPCTrackMerger.h                           AliL3TrackMerger.h,v 1.6 2005/04/19 04:29:01 cvetan Exp $      
-       AliHLTTPCTrackSegmentData.h                      AliL3TrackSegmentData.h,v 1.7 2005/03/31 04:48:59 cvetan Exp $ 
-       AliHLTTPCTransform.cxx                           AliL3Transform.cxx,v 1.53 2005/06/14 10:55:21 cvetan Exp $     
-       AliHLTTPCTransform.h                             AliL3Transform.h,v 1.37 2005/06/14 10:55:21 cvetan Exp $       
-       AliHLTTPCVertexArray.cxx                         AliL3VertexArray.cxx,v 1.7 2005/06/14 10:55:21 cvetan Exp $    
-       AliHLTTPCVertexArray.h                           AliL3VertexArray.h,v 1.4 2004/06/11 16:06:33 loizides Exp $    
-       AliHLTTPCVertex.cxx                              AliL3Vertex.cxx,v 1.5 2004/07/02 11:41:18 loizides Exp $       
-       AliHLTTPCVertexData.h                            AliL3VertexData.h,v 1.2 2003/07/27 21:02:09 loizides Exp $     
-       AliHLTTPCVertexFinder.cxx                        AliL3VertexFinder.cxx,v 1.9 2005/06/14 10:55:21 cvetan Exp $   
-       AliHLTTPCVertexFinder.h                          AliL3VertexFinder.h,v 1.7 2004/06/18 10:55:26 loizides Exp $   
-       AliHLTTPCVertex.h                                AliL3Vertex.h,v 1.4 2004/07/02 11:41:18 loizides Exp $
-       AliHLTTPCDataCompressorHelper.cxx                From comp: AliL3DataCompressorHelper.cxx,v 1.5 2004/06/15 10:26:57 hristov Exp $
-       AliHLTTPCDataCompressorHelper.h                  From comp: AliL3DataCompressorHelper.h,v 1.4 2004/06/15 10:26:57 hristov Exp $
-       AliHLTTPCModels.h                                From comp: AliL3Models.h,v 1.11 2004/05/17 16:37:19 hristov Exp $
-       AliHLTTPCModelTrack.h                            From comp: AliL3ModelTrack.h,v 1.13 2004/06/15 10:26:57 hristov Exp $
-       AliHLTTPCModelTrack.cxx                          From comp: AliL3ModelTrack.cxx,v 1.18 2005/02/14 11:50:11 hristov Exp $
+       AliHLTTPCStandardIncludes.h                      AliHLTStandardIncludes.h,v 1.5 2005/06/14 10:55:21 cvetan Exp $        
+       AliHLTTPCTrackArray.cxx                          AliHLTTrackArray.cxx,v 1.21 2005/06/14 10:55:21 cvetan Exp $   
+       AliHLTTPCTrackArray.h                            AliHLTTrackArray.h,v 1.7 2004/06/11 16:06:33 loizides Exp $    
+       AliHLTTPCTrack.cxx                               AliHLTTrack.cxx,v 1.322005/06/14 10:55:21 cvetan Exp $ 
+       AliHLTTPCTrack.h                                 AliHLTTrack.h,v 1.18 2005/03/31 04:48:58 cvetan Exp $  
+       AliHLTTPCTrackMerger.cxx                         AliHLTTrackMerger.cxx,v 1.12 2005/06/14 10:55:21 cvetan Exp $  
+       AliHLTTPCTrackMerger.h                           AliHLTTrackMerger.h,v 1.6 2005/04/19 04:29:01 cvetan Exp $     
+       AliHLTTPCTrackSegmentData.h                      AliHLTTrackSegmentData.h,v 1.7 2005/03/31 04:48:59 cvetan Exp $        
+       AliHLTTPCTransform.cxx                           AliHLTTransform.cxx,v 1.53 2005/06/14 10:55:21 cvetan Exp $    
+       AliHLTTPCTransform.h                             AliHLTTransform.h,v 1.37 2005/06/14 10:55:21 cvetan Exp $      
+       AliHLTTPCVertexArray.cxx                         AliHLTVertexArray.cxx,v 1.7 2005/06/14 10:55:21 cvetan Exp $   
+       AliHLTTPCVertexArray.h                           AliHLTVertexArray.h,v 1.4 2004/06/11 16:06:33 loizides Exp $   
+       AliHLTTPCVertex.cxx                              AliHLTVertex.cxx,v 1.5 2004/07/02 11:41:18 loizides Exp $      
+       AliHLTTPCVertexData.h                            AliHLTVertexData.h,v 1.2 2003/07/27 21:02:09 loizides Exp $    
+       AliHLTTPCVertexFinder.cxx                        AliHLTVertexFinder.cxx,v 1.9 2005/06/14 10:55:21 cvetan Exp $  
+       AliHLTTPCVertexFinder.h                          AliHLTVertexFinder.h,v 1.7 2004/06/18 10:55:26 loizides Exp $  
+       AliHLTTPCVertex.h                                AliHLTVertex.h,v 1.4 2004/07/02 11:41:18 loizides Exp $
+       AliHLTTPCDataCompressorHelper.cxx                From comp: AliHLTDataCompressorHelper.cxx,v 1.5 2004/06/15 10:26:57 hristov Exp $
+       AliHLTTPCDataCompressorHelper.h                  From comp: AliHLTDataCompressorHelper.h,v 1.4 2004/06/15 10:26:57 hristov Exp $
+       AliHLTTPCModels.h                                From comp: AliHLTModels.h,v 1.11 2004/05/17 16:37:19 hristov Exp $
+       AliHLTTPCModelTrack.h                            From comp: AliHLTModelTrack.h,v 1.13 2004/06/15 10:26:57 hristov Exp $
+       AliHLTTPCModelTrack.cxx                          From comp: AliHLTModelTrack.cxx,v 1.18 2005/02/14 11:50:11 hristov Exp $
        AliHLTTPCRawDataFormat.h                         from online Pub/Sub framework
        AliHLTTPCClusterDataFormat.h                     from online Pub/Sub framework  
        AliHLTTPCTrackletDataFormat.h                    from online Pub/Sub framework  
diff --git a/HLT/ITS/AliHLTITSLinkDef.h b/HLT/ITS/AliHLTITSLinkDef.h
new file mode 100644 (file)
index 0000000..26b0ba9
--- /dev/null
@@ -0,0 +1,15 @@
+
+#ifdef __CINT__
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#ifdef use_aliroot
+#pragma link C++ class AliHLTITStrack; 
+#pragma link C++ class AliHLTITStracker; 
+#pragma link C++ class AliHLTITSVertexerZ;
+#pragma link C++ class AliHLTITSclusterer;
+#endif
+
+#endif
similarity index 96%
rename from HLT/ITS/AliL3ITSVertexerZ.cxx
rename to HLT/ITS/AliHLTITSVertexerZ.cxx
index c61ba89..3e3716a 100644 (file)
@@ -12,7 +12,7 @@
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-#include "AliL3ITSVertexerZ.h"
+#include "AliHLTITSVertexerZ.h"
 #include<TString.h>
 #include<TH1.h>
 #include<TMath.h>
@@ -29,9 +29,9 @@
 //          Origin: Cvetan Cheshkov, CERN, Cvetan.Cheshkov@cern.ch
 //-------------------------------------------------------------------------
 
-ClassImp(AliL3ITSVertexerZ)
+ClassImp(AliHLTITSVertexerZ)
 
-AliL3ITSVertexerZ::AliL3ITSVertexerZ():AliITSVertexerZ(){
+AliHLTITSVertexerZ::AliHLTITSVertexerZ():AliITSVertexerZ(){
   // Constructor in case that there is no runloader
 
   SetDiffPhiMax();
@@ -52,13 +52,13 @@ AliL3ITSVertexerZ::AliL3ITSVertexerZ():AliITSVertexerZ(){
   SetDebug();
 }
 
-AliL3ITSVertexerZ::AliL3ITSVertexerZ(TString filename,Float_t x0, Float_t y0):AliITSVertexerZ(filename,x0,y0)
+AliHLTITSVertexerZ::AliHLTITSVertexerZ(TString filename,Float_t x0, Float_t y0):AliITSVertexerZ(filename,x0,y0)
 {
   // Standard Constructor
 }
 
 //______________________________________________________________________
-AliESDVertex* AliL3ITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
+AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
   // Defines the AliESDVertex for the current event
 
   fCurrentVertex = 0;
@@ -87,7 +87,7 @@ AliESDVertex* AliL3ITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
 }
 
 //______________________________________________________________________
-AliESDVertex* AliL3ITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTree *tR){
+AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTree *tR){
   // Defines the AliESDVertex for the current event
 
   fCurrentVertex = 0;
similarity index 79%
rename from HLT/ITS/AliL3ITSVertexerZ.h
rename to HLT/ITS/AliHLTITSVertexerZ.h
index c265a33..b258cf7 100644 (file)
@@ -20,15 +20,17 @@ class TTree;
 class AliITSgeom;
 
 //-------------------------------------------------------------------------
-class AliL3ITSVertexerZ : public AliITSVertexerZ {
+class AliHLTITSVertexerZ : public AliITSVertexerZ {
 public:
-  AliL3ITSVertexerZ();
-  AliL3ITSVertexerZ(TString filename,Float_t x0=0., Float_t y0=0.);
+  AliHLTITSVertexerZ();
+  AliHLTITSVertexerZ(TString filename,Float_t x0=0., Float_t y0=0.);
 
   AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb);
   AliESDVertex* FindVertexForCurrentEvent(AliITSgeom *geom,TTree *tR);
 
-  ClassDef(AliL3ITSVertexerZ,1)   //HLT ITS vertexer
+  ClassDef(AliHLTITSVertexerZ,1)   //HLT ITS vertexer
 };
 
+typedef AliHLTITSVertexerZ AliL3ITSVertexerZ; // for backward compatibility
+
 #endif
similarity index 92%
rename from HLT/ITS/AliL3ITSclusterer.cxx
rename to HLT/ITS/AliHLTITSclusterer.cxx
index 1b7108a..79ebc6b 100644 (file)
@@ -22,7 +22,7 @@
 //          Origin: Cvetan Cheshkov, CERN, Cvetan.Cheshkov@cern.ch
 //-------------------------------------------------------------------------
 
-#include "AliL3ITSclusterer.h"
+#include "AliHLTITSclusterer.h"
 #include "AliRawReader.h"
 #include "AliITSgeom.h"
 #include "AliITSRawStreamSPD.h"
 #include <TTree.h>
 #include <TClonesArray.h>
 
-ClassImp(AliL3ITSclusterer)
+ClassImp(AliHLTITSclusterer)
 
-AliL3ITSclusterer::AliL3ITSclusterer(const AliITSgeom *geom):AliITSclustererV2(geom)
+AliHLTITSclusterer::AliHLTITSclusterer(const AliITSgeom *geom):AliITSclustererV2(geom)
 {
 fNModule = geom->GetIndexMax();
 }
 
-void AliL3ITSclusterer::Digits2Clusters(AliRawReader* rawReader,TTree *cTree)
+void AliHLTITSclusterer::Digits2Clusters(AliRawReader* rawReader,TTree *cTree)
 {
 
   TClonesArray *array=new TClonesArray("AliITSclusterV2",1000);
similarity index 77%
rename from HLT/ITS/AliL3ITSclusterer.h
rename to HLT/ITS/AliHLTITSclusterer.h
index 254a4c8..ba8e3fd 100644 (file)
@@ -19,17 +19,19 @@ class AliITSgeom;
 class AliRawReader;
 
 //-------------------------------------------------------------------------
-class AliL3ITSclusterer : public AliITSclustererV2 {
+class AliHLTITSclusterer : public AliITSclustererV2 {
 public:
-  AliL3ITSclusterer():AliITSclustererV2(){fNModule = 0;}
-  AliL3ITSclusterer(const AliITSgeom *geom);
+  AliHLTITSclusterer():AliITSclustererV2(){fNModule = 0;}
+  AliHLTITSclusterer(const AliITSgeom *geom);
 
   void Digits2Clusters(AliRawReader* rawReader,TTree *cTree);
 
 private:
   Int_t fNModule;             // total number of modules
  
-  ClassDef(AliL3ITSclusterer,1)   //HLT ITS clusterer
+  ClassDef(AliHLTITSclusterer,1)   //HLT ITS clusterer
 };
 
+typedef AliHLTITSclusterer AliL3ITSclusterer; // for backward compatibility
+
 #endif
similarity index 90%
rename from HLT/ITS/AliL3ITStrack.cxx
rename to HLT/ITS/AliHLTITStrack.cxx
index 5fe2339..d484257 100644 (file)
 
 #include <TMath.h>
 
-#include "AliL3ITStrack.h"
+#include "AliHLTITStrack.h"
 
-ClassImp(AliL3ITStrack)
+ClassImp(AliHLTITStrack)
 
 //____________________________________________________________________________
-AliL3ITStrack::AliL3ITStrack()
+AliHLTITStrack::AliHLTITStrack()
               :AliITStrackV2()
 {
   //------------------------------------------------------------------
@@ -35,7 +35,7 @@ AliL3ITStrack::AliL3ITStrack()
 }
 
 //____________________________________________________________________________
-AliL3ITStrack::AliL3ITStrack(AliESDtrack& t)
+AliHLTITStrack::AliHLTITStrack(AliESDtrack& t)
               :AliITStrackV2(t)
 {
   //------------------------------------------------------------------
@@ -44,7 +44,7 @@ AliL3ITStrack::AliL3ITStrack(AliESDtrack& t)
 }
 
 //____________________________________________________________________________
-AliL3ITStrack::AliL3ITStrack(const AliL3ITStrack& t) 
+AliHLTITStrack::AliHLTITStrack(const AliHLTITStrack& t) 
               : AliITStrackV2(t)
 {
   //------------------------------------------------------------------
@@ -53,11 +53,11 @@ AliL3ITStrack::AliL3ITStrack(const AliL3ITStrack& t)
 }
 
 //_____________________________________________________________________________
-Int_t AliL3ITStrack::Compare(const TObject *o) const {
+Int_t AliHLTITStrack::Compare(const TObject *o) const {
   //-----------------------------------------------------------------
   // This function compares tracks according to the their curvature
   //-----------------------------------------------------------------
-  AliL3ITStrack *t=(AliL3ITStrack*)o;
+  AliHLTITStrack *t=(AliHLTITStrack*)o;
   Double_t co=TMath::Abs(t->Get1Pt());
   Double_t c =TMath::Abs(Get1Pt());
   //  Double_t co=t->GetSigmaY2()*t->GetSigmaZ2();
similarity index 77%
rename from HLT/ITS/AliL3ITStrack.h
rename to HLT/ITS/AliHLTITStrack.h
index 6e7621c..2a29c72 100644 (file)
 
 #include <AliITStrackV2.h>
 
-class AliL3ITStrack : public AliITStrackV2 {
+class AliHLTITStrack : public AliITStrackV2 {
 public:
-  AliL3ITStrack();
-  AliL3ITStrack(AliESDtrack& t);
-  AliL3ITStrack(const AliL3ITStrack& t);
+  AliHLTITStrack();
+  AliHLTITStrack(AliESDtrack& t);
+  AliHLTITStrack(const AliHLTITStrack& t);
 
   Int_t Compare(const TObject *o) const;
 
-  ClassDef(AliL3ITStrack,2)   //HLT ITS reconstructed track
+  ClassDef(AliHLTITStrack,2)   //HLT ITS reconstructed track
 };
 
+typedef AliHLTITStrack AliL3ITStrack; // for backward compatibility
+
 #endif
similarity index 93%
rename from HLT/ITS/AliL3ITStracker.cxx
rename to HLT/ITS/AliHLTITStracker.cxx
index 8a9ba37..ed125f2 100644 (file)
 //-------------------------------------------------------------------------
 
 #include "AliESD.h"
-#include "AliL3ITStrack.h"
-#include "AliL3ITStracker.h"
+#include "AliHLTITStrack.h"
+#include "AliHLTITStracker.h"
 
-ClassImp(AliL3ITStracker)
+ClassImp(AliHLTITStracker)
 
 static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
   //--------------------------------------------------------------------
@@ -60,7 +60,7 @@ static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
   return 0;
 }
 
-Int_t AliL3ITStracker::Clusters2Tracks(AliESD *event) {
+Int_t AliHLTITStracker::Clusters2Tracks(AliESD *event) {
   //--------------------------------------------------------------------
   // This functions reconstructs HLT ITS tracks
   //--------------------------------------------------------------------
@@ -74,9 +74,9 @@ Int_t AliL3ITStracker::Clusters2Tracks(AliESD *event) {
 
       AliESDtrack *esd=event->GetTrack(nentr);
 
-      AliL3ITStrack *t=0;
+      AliHLTITStrack *t=0;
       try {
-        t=new AliL3ITStrack(*esd);
+        t=new AliHLTITStrack(*esd);
       } catch (const Char_t *msg) {
         Warning("Clusters2Tracks",msg);
         delete t;
@@ -105,7 +105,7 @@ Int_t AliL3ITStracker::Clusters2Tracks(AliESD *event) {
   for (fPass=0; fPass<2; fPass++) {
      Int_t &constraint=fConstraint[fPass]; if (constraint<0) continue;
      for (Int_t i=0; i<nentr; i++) {
-       AliL3ITStrack *t=(AliL3ITStrack*)itsTracks.UncheckedAt(i);
+       AliHLTITStrack *t=(AliHLTITStrack*)itsTracks.UncheckedAt(i);
        if (t==0) continue;              //this track has been already tracked
        Int_t tpcLabel=t->GetLabel(); //save the TPC track label
        ResetTrackToFollow(*t);
@@ -142,7 +142,7 @@ Int_t AliL3ITStracker::Clusters2Tracks(AliESD *event) {
   return 0;
 }
 
-Int_t AliL3ITStracker::PropagateBack(AliESD *event) {
+Int_t AliHLTITStracker::PropagateBack(AliESD *event) {
   //--------------------------------------------------------------------
   // This functions propagates reconstructed ITS tracks back
   //--------------------------------------------------------------------
@@ -151,7 +151,7 @@ Int_t AliL3ITStracker::PropagateBack(AliESD *event) {
   return 0;
 }
 
-Int_t AliL3ITStracker::RefitInward(AliESD *event) {
+Int_t AliHLTITStracker::RefitInward(AliESD *event) {
   //--------------------------------------------------------------------
   // This functions refits ITS tracks using the 
   // "inward propagated" TPC tracks
similarity index 77%
rename from HLT/ITS/AliL3ITStracker.h
rename to HLT/ITS/AliHLTITStracker.h
index a7efbd8..581ea41 100644 (file)
 
 class AliESD;
 class AliITSgeom;
-class AliL3ITStrack;
+class AliHLTITStrack;
 
 //-------------------------------------------------------------------------
-class AliL3ITStracker : public AliITStrackerV2 {
+class AliHLTITStracker : public AliITStrackerV2 {
 public:
-  AliL3ITStracker():AliITStrackerV2(){ fConstraint[0]=1; fConstraint[1]=0; }
-  AliL3ITStracker(const AliITSgeom *geom) : AliITStrackerV2(geom){ fConstraint[0]=1; fConstraint[1]=0; }
+  AliHLTITStracker():AliITStrackerV2(){ fConstraint[0]=1; fConstraint[1]=0; }
+  AliHLTITStracker(const AliITSgeom *geom) : AliITStrackerV2(geom){ fConstraint[0]=1; fConstraint[1]=0; }
 
   Int_t Clusters2Tracks(AliESD *event);
   Int_t PropagateBack(AliESD *event);
   Int_t RefitInward(AliESD *event);
 
-  ClassDef(AliL3ITStracker,1)   //HLT ITS tracker
+  ClassDef(AliHLTITStracker,1)   //HLT ITS tracker
 };
 
+typedef AliHLTITStracker AliL3ITStracker; // for backward compatibility
+
 #endif
diff --git a/HLT/ITS/AliL3ITSLinkDef.h b/HLT/ITS/AliL3ITSLinkDef.h
deleted file mode 100644 (file)
index ed3665e..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-
-#ifdef __CINT__
-#pragma link off all globals;
-#pragma link off all classes;
-#pragma link off all functions;
-
-#ifdef use_aliroot
-#pragma link C++ class AliL3ITStrack; 
-#pragma link C++ class AliL3ITStracker; 
-#pragma link C++ class AliL3ITSVertexerZ;
-#pragma link C++ class AliL3ITSclusterer;
-#endif
-
-#endif
index bcb12f8..e79c75d 100644 (file)
   #include "AliMagF.h"
   #include "AliGenEventHeader.h"
 
-  #include "AliL3ITStrack.h"
-  #include "AliL3ITStracker.h"
-  #include "AliL3ITSVertexerZ.h"
+  #include "AliHLTITStrack.h"
+  #include "AliHLTITStracker.h"
+  #include "AliHLTITSVertexerZ.h"
 #endif
 
 //extern TSystem *gSystem;
 
 Int_t RunHLTITS(Int_t nev=1,Int_t run=0) {
 
-  //  gSystem->Load("libAliL3ITS.so");
+  //  gSystem->Load("libAliHLTITS.so");
 
   TStopwatch timer;
   timer.Start();
@@ -91,7 +91,7 @@ Int_t RunHLTITS(Int_t nev=1,Int_t run=0) {
    geom->ReadNewFile("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det");
 
    //An instance of the HLT ITS tracker
-   AliL3ITStracker itsTracker(geom);
+   AliHLTITStracker itsTracker(geom);
 
    TFile *ef=TFile::Open("AliESDs.root");
    if (!ef || !ef->IsOpen()) {cerr<<"Can't AliESDs.root !\n"; return 1;}
@@ -120,7 +120,7 @@ Int_t RunHLTITS(Int_t nev=1,Int_t run=0) {
      Double_t cvtx[3]={0.005,0.005,0.010};
      cout<<"MC vertex position: "<<v[2]<<endl;
 
-     AliL3ITSVertexerZ vertexer("null");
+     AliHLTITSVertexerZ vertexer("null");
      AliESDVertex* vertex = NULL;
      TStopwatch timer2;
      timer2.Start();
index cee7c14..b15f3c3 100644 (file)
@@ -106,7 +106,7 @@ $(ALIHLT_STATIC): $(STATICOBJS)
 $(DICT): $(HDRS)
        @echo "Generating dictionary..."
        rootcint -f $(DICT) -c $(CINTCXXFLAGS) $(INCLUDES) \
-                    $(DEFSTR) -include AliL3StandardIncludes.h $(HDRS)
+                    $(DEFSTR) -include AliHLTStandardIncludes.h $(HDRS)
 
 $(OBJDIR)/%.o: %.cxx 
        $(CXX) $(CXXFLAGS) $(DEFSTR) -c $(INCLUDES) -o $@ $<
index d60972d..9ff5f54 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Benchmark.h,v 1.6 2004/06/26 11:39:40 loizides 
+// Original: AliHLTBenchmark.h,v 1.6 2004/06/26 11:39:40 loizides 
 
 #ifndef AliHLTTPCBenchmarkH
 #define AliHLTTPCBenchmarkH
index e7922d3..68da982 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-//Original: AliL3ClustFinderNew.cxx,v 1.29 2005/06/14 10:55:21 cvetan 
+//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
index 10b69fc..6a85c13 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ClustFinderNew.h,v 1.13 2004/06/18 10:55:26 loizides 
+// Original: AliHLTClustFinderNew.h,v 1.13 2004/06/18 10:55:26 loizides 
 #ifndef AliHLTTPC_ClustFinderNew
 #define AliHLTTPC_ClustFinderNew
 
index 1620364..daaad6a 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ClustFinderNew.cxx,v 1.29 2005/06/14 10:55:21 cvetan Exp 
+// Original: AliHLTClustFinderNew.cxx,v 1.29 2005/06/14 10:55:21 cvetan Exp 
 
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
index c7494de..65e6584 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ClustFinderNew.h,v 1.13 2004/06/18 10:55:26 loizides 
+// Original: AliHLTClustFinderNew.h,v 1.13 2004/06/18 10:55:26 loizides 
 
 #ifndef AliHLTTPC_ClusterFinder
 #define AliHLTTPC_ClusterFinder
index 441233d..c97e8a0 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ConfMapFit.cxx,v 1.14 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTConfMapFit.cxx,v 1.14 2005/06/14 10:55:21 cvetan 
 
 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index b68a483..447848a 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ConfMapFit.h,v 1.5 2004/07/05 09:03:11 loizides 
+// Original: AliHLTConfMapFit.h,v 1.5 2004/07/05 09:03:11 loizides 
 
 #ifndef ALIHLTTPC_ConfMapFit
 #define ALIHLTTPC_ConfMapFit
index 3ed2a9c..91ae732 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ConfMapPoint.cxx,v 1.10 2005/06/23 17:46:55 hristov 
+// Original: AliHLTConfMapPoint.cxx,v 1.10 2005/06/23 17:46:55 hristov 
 
 // Author: Anders Vestbo <mailto:vestbo$fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index 99dcbfe..4e9d7e8 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ConfMapPoint.h,v 1.8 2005/06/23 17:46:55 hristov 
+// Original: AliHLTConfMapPoint.h,v 1.8 2005/06/23 17:46:55 hristov 
 
 #ifndef ALIHLTTPCConfMapPointH
 #define ALIHLTTPCConfMapPointH
index 27d07f2..3959ff9 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ConfMapTrack.cxx,v 1.16 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTConfMapTrack.cxx,v 1.16 2005/06/14 10:55:21 cvetan 
 
 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group 
index 19eb646..0f8d4fc 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ConfMapTrack.h,v 1.4 2004/06/16 11:25:06 loizides 
+// Original: AliHLTConfMapTrack.h,v 1.4 2004/06/16 11:25:06 loizides 
 
 #ifndef ALIHLTTPC_ConfMapTrack
 #define ALIHLTTPC_ConfMapTrack
index 736e040..a47ecfc 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ConfMapper.cxx,v 1.26 2005/06/14 10:55:21 cvetan Exp $
+// Original: AliHLTConfMapper.cxx,v 1.26 2005/06/14 10:55:21 cvetan Exp $
 
 /** \class AliHLTTPCConfMapper
 <pre>
index da0f392..8f04c73 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ConfMapper.h,v 1.11 2004/07/05 09:03:11 loizides 
+// Original: AliHLTConfMapper.h,v 1.11 2004/07/05 09:03:11 loizides 
 
 #ifndef ALIHLTTPCCONFMAPPER_H
 #define ALIHLTTPCCONFMAPPER_H
index 6c733e4..b54cfb7 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3DataCompressorHelper.cxx,v 1.5 2004/06/15 10:26:57 hristov Exp $
+// Original: AliHLTDataCompressorHelper.cxx,v 1.5 2004/06/15 10:26:57 hristov Exp $
 
 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index 3adf716..d079a3b 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3DataCompressorHelper.h,v 1.4 2004/06/15 10:26:57 hristov Exp $
+// Original: AliHLTDataCompressorHelper.h,v 1.4 2004/06/15 10:26:57 hristov Exp $
 
 #ifndef AliHLTTPC_DataCompressorHelper
 #define AliHLTTPC_DataCompressorHelper
index d7700aa..0f2a99f 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3DigitData.h,v 1.5 2004/05/12 11:51:27 loizides 
+// Original: AliHLTDigitData.h,v 1.5 2004/05/12 11:51:27 loizides 
 
 #ifndef _ALIHLTTPCDIGITDATA_H_
 #define _ALIHLTTPCDIGITDATA_H_
index 3ae48ae..cbb70c9 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3FileHandler.cxx,v 1.49 2005/06/23 17:46:55 hristov 
+// 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 
index 2a200d3..02f009a 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3FileHandler.h,v 1.19 2004/06/11 16:06:33 loizides 
+// Original: AliHLTFileHandler.h,v 1.19 2004/06/11 16:06:33 loizides 
 
 #ifndef ALIHLTTPCFILEHANDLER_H
 #define ALIHLTTPCFILEHANDLER_H
index 5658949..b697aa8 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Fitter.cxx,v 1.14 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTFitter.cxx,v 1.14 2005/06/14 10:55:21 cvetan 
 
 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group 
index dab28a6..bcc93e5 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Fitter.h,v 1.7 2004/07/05 09:02:18 loizides 
+// Original: AliHLTFitter.h,v 1.7 2004/07/05 09:02:18 loizides 
 
 #ifndef ALIHLTTPCFITTER_H
 #define ALIHLTTPCFITTER_H
index cbe02e2..817f33d 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3GlobalMerger.cxx,v 1.13 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTGlobalMerger.cxx,v 1.13 2005/06/14 10:55:21 cvetan 
 
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group 
index 03bfdb7..a9c9323 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3GlobalMerger.h,v 1.6 2004/02/02 15:00:34 loizides 
+// Original: AliHLTGlobalMerger.h,v 1.6 2004/02/02 15:00:34 loizides 
 
 #ifndef ALIHLTTPC_GLOBALMERGER_H
 #define ALIHLTTPC_GLOBALMERGER_H
index dcc9b15..9a8f4db 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3InterMerger.cxx,v 1.8 2005/06/14 10:55:21 cvetan
+// Original: AliHLTInterMerger.cxx,v 1.8 2005/06/14 10:55:21 cvetan
 
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index 897fabf..7a6bea3 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3InterMerger.h,v 1.4 2004/02/02 15:00:34 loizides Exp $
+// Original: AliHLTInterMerger.h,v 1.4 2004/02/02 15:00:34 loizides Exp $
 
 #ifndef ALIHLTTPCINTERMERGER_H
 #define ALIHLTTPCINTERMERGER_H
index ceba38c..d6b73fd 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-// Original: AliL3Log.cxx,v 1.1 2004/05/14 09:37:22 loizides 
+// Original: AliHLTLog.cxx,v 1.1 2004/05/14 09:37:22 loizides 
 
 #ifndef use_logging
 
index 05aadcb..1535302 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Log.h,v 1.2 2004/06/11 16:06:33 loizides Exp $
+// Original: AliHLTLog.h,v 1.2 2004/06/11 16:06:33 loizides Exp $
 
 #ifndef ALIHLTTPCLOG_H
 #define ALIHLTTPCLOG_H
index e951370..b06dded 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Logging.h,v 1.11 2004/10/09 11:28:31 loizides 
+// Original: AliHLTLogging.h,v 1.11 2004/10/09 11:28:31 loizides 
 
 #ifndef ALIHLTTPCLOGGING_H
 #define ALIHLTTPCLOGGING_H
index 4a4d8b5..f631238 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3MemHandler.cxx,v 1.52 2005/06/14 10:55:21 cvetan 
+// 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 
index d9bc0d5..407cbb2 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3MemHandler.h,v 1.30 2004/10/06 08:51:20 cvetan 
+// Original: AliHLTMemHandler.h,v 1.30 2004/10/06 08:51:20 cvetan 
 #ifndef ALIHLTTPC_MEMHANDLER_H
 #define ALIHLTTPC_MEMHANDLER_H
 
index cfab694..7f4bcaf 100644 (file)
@@ -1,5 +1,5 @@
 //$Id$
-// Original: AliL3Merger.cxx,v 1.16 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTMerger.cxx,v 1.16 2005/06/14 10:55:21 cvetan 
 
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy Uli 
index a74ea79..ba03ef3 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Merger.h,v 1.8 2004/06/11 16:06:33 loizides 
+// Original: AliHLTMerger.h,v 1.8 2004/06/11 16:06:33 loizides 
 #ifndef ALIHLTTPCMERGER_H
 #define ALIHLTTPCMERGER_H
 //#define PI 3.14159265358979312
index 374f827..35dcb30 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ModelTrack.cxx,v 1.18 2005/02/14 11:50:11 hristov 
+// Original: AliHLTModelTrack.cxx,v 1.18 2005/02/14 11:50:11 hristov 
 // Author: Anders Vestbo <mailto:vestbo$fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
 //_____________________________________________________________
index 9169bc6..ec87706 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3ModelTrack.h,v 1.13 2004/06/15 10:26:57 hristov 
+// Original: AliHLTModelTrack.h,v 1.13 2004/06/15 10:26:57 hristov 
 
 #ifndef AliHLTTPCModel_Track
 #define AliHLTTPCModel_Track
index 7256943..0b4562f 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Models.h,v 1.11 2004/05/17 16:37:19 hristov 
+// Original: AliHLTModels.h,v 1.11 2004/05/17 16:37:19 hristov 
 
 #ifndef AliHLTTPCModels_H
 #define AliHLTTPCModels_H
index a32f13b..75ff853 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3RootTypes.h,v 1.12 2004/06/15 14:02:38 loizides 
+// Original: AliHLTRootTypes.h,v 1.12 2004/06/15 14:02:38 loizides 
 #ifndef ALIHLTTPCROOTTYPES_H
 #define ALIHLTTPCROOTTYPES_H
 
index eb97c44..8b6b1d0 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3SpacePointData.h,v 1.4 2003/07/27 21:02:09 loizides 
+// Original: AliHLTSpacePointData.h,v 1.4 2003/07/27 21:02:09 loizides 
 
 #ifndef SPACEPOINTDATA_H
 #define SPACEPOINTDATA_H
index 11a4fcf..ddea52d 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Track.cxx,v 1.32 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTTrack.cxx,v 1.32 2005/06/14 10:55:21 cvetan 
 
 // Author: Anders Vestbo <mailto:vestbo$fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index 40b8ac5..bc766a8 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Track.h,v 1.18 2005/03/31 04:48:58 cvetan 
+// Original: AliHLTTrack.h,v 1.18 2005/03/31 04:48:58 cvetan 
 #ifndef ALIHLTTPCTRACK_H
 #define ALIHLTTPCTRACK_H
 
index 06aa48a..4e8d79a 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3TrackArray.cxx,v 1.21 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTTrackArray.cxx,v 1.21 2005/06/14 10:55:21 cvetan 
 
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index d90d0d5..8d5a5e1 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3TrackArray.h,v 1.7 2004/06/11 16:06:33 loizides 
+// Original: AliHLTTrackArray.h,v 1.7 2004/06/11 16:06:33 loizides 
 #ifndef ALIHLTTPCTRACKARRAY_H
 #define ALIHLTTPCTRACKARRAY_H
 
index 3971f41..d395e68 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3TrackMerger.cxx,v 1.12 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTTrackMerger.cxx,v 1.12 2005/06/14 10:55:21 cvetan 
 
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index 7706ea3..1f97955 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3TrackMerger.h,v 1.6 2005/04/19 04:29:01 cvetan 
+// Original: AliHLTTrackMerger.h,v 1.6 2005/04/19 04:29:01 cvetan 
 #ifndef ALIHLTTPCTRACKMERGER_H
 #define ALIHLTTPCTRACKMERGER_H
 
index db5d878..87c610a 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3TrackSegmentData.h,v 1.7 2005/03/31 04:48:59 cvetan 
+// Original: AliHLTTrackSegmentData.h,v 1.7 2005/03/31 04:48:59 cvetan 
 #ifndef _ALIHLTTPCTRACKSEGMENTDATA_H_
 #define _ALIHLTTPCTRACKSEGMENTDATA_H_
 
index 534aaf4..5c98b12 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Transform.cxx,v 1.53 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTTransform.cxx,v 1.53 2005/06/14 10:55:21 cvetan 
 
 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>, Constantin Loizides <mailto:loizides@ikf.uni-frankfurt.de>
 //*-- Copyright &copy ALICE HLT Group
index dbcd62a..d7ecd2c 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Transform.h,v 1.37 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTTransform.h,v 1.37 2005/06/14 10:55:21 cvetan 
 
 #ifndef ALIHLTTPCTRANSFORM_H
 #define ALIHLTTPCTRANSFORM_H
index 0d67473..9da7168 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Vertex.cxx,v 1.5 2004/07/02 11:41:18 loizides Exp $
+// Original: AliHLTVertex.cxx,v 1.5 2004/07/02 11:41:18 loizides Exp $
 
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index 05f73b1..d4ac331 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Vertex.h,v 1.4 2004/07/02 11:41:18 loizides 
+// Original: AliHLTVertex.h,v 1.4 2004/07/02 11:41:18 loizides 
 
 #ifndef ALIHLTTPCVERTEX_H
 #define ALIHLTTPCVERTEX_H
index 9f08be1..a5e38eb 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3VertexArray.cxx,v 1.7 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTVertexArray.cxx,v 1.7 2005/06/14 10:55:21 cvetan 
 
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index 1ba1d38..8860e5e 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3VertexArray.h,v 1.4 2004/06/11 16:06:33 loizides 
+// Original: AliHLTVertexArray.h,v 1.4 2004/06/11 16:06:33 loizides 
 
 #ifndef AliHLTTPCVERTEXARRAY_H
 #define AliHLTTPCVERTEXARRAY_H
index 2411101..80a3872 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3VertexData.h,v 1.2 2003/07/27 21:02:09 loizides 
+// Original: AliHLTVertexData.h,v 1.2 2003/07/27 21:02:09 loizides 
 
 #ifndef VERTEXDATA_H
 #define VERTEXDATA_H
index 977433d..28eeaa6 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3VertexFinder.cxx,v 1.9 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTVertexFinder.cxx,v 1.9 2005/06/14 10:55:21 cvetan 
 
 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
index 6d61723..9174d06 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3VertexFinder.h,v 1.7 2004/06/18 10:55:26 loizides 
+// Original: AliHLTVertexFinder.h,v 1.7 2004/06/18 10:55:26 loizides 
 
 #ifndef AliHLTTPCVERTEXFINDER_H
 #define AliHLTTPCVERTEXFINDER_H
index 3e87898..27de97d 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-// Original: AliL3Display.cxx,v 1.26 2005/06/14 10:55:21 cvetan 
+// Original: AliHLTDisplay.cxx,v 1.26 2005/06/14 10:55:21 cvetan 
 
 /** \class AliHLTTPCDisplay
 <pre>
index 376ea8c..ec0189c 100644 (file)
@@ -1,6 +1,6 @@
 // XEmacs -*-C++-*-
 // @(#) $Id$
-// Original: AliL3Display.h,v 1.14 2004/06/30 08:30:14 loizides 
+// Original: AliHLTDisplay.h,v 1.14 2004/06/30 08:30:14 loizides 
 
 #ifndef ALIHLTTPCDISPLAY_H
 #define ALIHLTTPCDISPLAY_H
index c8c50a9..e2d4edc 100755 (executable)
@@ -5,9 +5,9 @@
 export CVS_RSH=ssh
 export CVSROOT=$USER@kjekspc1.fi.uib.no:/cvs/hltcvs
 #export CVSIGNORE="lib src hough comp exa programs misc trigger sim 
-#AliL3CompCint.h AliL3CompCint.cxx AliL3HoughCint.h 
-#AliL3HoughCint.cxx AliL3Cint.cxx AliL3Cint.h lib_ROOT lib_ALIROOT
-#AliL3MiscCint.cxx AliL3MiscCint.h"
+#AliHLTCompCint.h AliHLTCompCint.cxx AliHLTHoughCint.h 
+#AliHLTHoughCint.cxx AliHLTCint.cxx AliHLTCint.h lib_ROOT lib_ALIROOT
+#AliHLTMiscCint.cxx AliHLTMiscCint.h"
 
 export ALIHLT_USEPACKAGE=ALIROOT
 #export ALIHLT_USEPACKAGE=ROOT
similarity index 74%
rename from HLT/comp/AliL3ClusterFitter.cxx
rename to HLT/comp/AliHLTClusterFitter.cxx
index a18846d..3dd1e41 100644 (file)
@@ -2,39 +2,39 @@
 
 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
 //*-- Copyright &copy ALICE HLT Group
-/** /class AliL3ClusterFitter
+/** /class AliHLTClusterFitter
 //<pre>
 //_____________________________________________________________
 //
-//  AliL3ClusterFitter
+//  AliHLTClusterFitter
 //
 </pre>
 */
 
 
-#include "AliL3StandardIncludes.h"
+#include "AliHLTStandardIncludes.h"
 
-#include "AliL3ClusterFitter.h"
-#include "AliL3FitUtilities.h"
-#include "AliL3DigitData.h"
-#include "AliL3ModelTrack.h"
-#include "AliL3TrackArray.h"
-#include "AliL3MemHandler.h"
-#include "AliL3HoughTrack.h"
-#include "AliL3SpacePointData.h"
+#include "AliHLTClusterFitter.h"
+#include "AliHLTFitUtilities.h"
+#include "AliHLTDigitData.h"
+#include "AliHLTModelTrack.h"
+#include "AliHLTTrackArray.h"
+#include "AliHLTMemHandler.h"
+#include "AliHLTHoughTrack.h"
+#include "AliHLTSpacePointData.h"
 
 #if __GNUC__ >= 3
 using namespace std;
 #endif
 
-ClassImp(AliL3ClusterFitter)
+ClassImp(AliHLTClusterFitter)
 
-Int_t AliL3ClusterFitter::fgBadFitError=0;
-Int_t AliL3ClusterFitter::fgFitError=0;
-Int_t AliL3ClusterFitter::fgResultError=0;
-Int_t AliL3ClusterFitter::fgFitRangeError=0;
+Int_t AliHLTClusterFitter::fgBadFitError=0;
+Int_t AliHLTClusterFitter::fgFitError=0;
+Int_t AliHLTClusterFitter::fgResultError=0;
+Int_t AliHLTClusterFitter::fgFitRangeError=0;
 
-AliL3ClusterFitter::AliL3ClusterFitter()
+AliHLTClusterFitter::AliHLTClusterFitter()
 {
   // default constructor
   plane=0;
@@ -56,7 +56,7 @@ AliL3ClusterFitter::AliL3ClusterFitter()
   fEvent=0;
 }
 
-AliL3ClusterFitter::AliL3ClusterFitter(Char_t *path)
+AliHLTClusterFitter::AliHLTClusterFitter(Char_t *path)
 {
   // constructor
   strcpy(fPath,path);
@@ -79,7 +79,7 @@ AliL3ClusterFitter::AliL3ClusterFitter(Char_t *path)
   fEvent=0;
 }
 
-AliL3ClusterFitter::~AliL3ClusterFitter()
+AliHLTClusterFitter::~AliHLTClusterFitter()
 {
   // destructor
   if(fSeeds)
@@ -88,27 +88,27 @@ AliL3ClusterFitter::~AliL3ClusterFitter()
     delete [] fClusters;
 }
 
-void AliL3ClusterFitter::Init(Int_t slice,Int_t patch,Int_t *rowrange,AliL3TrackArray *tracks)
+void AliHLTClusterFitter::Init(Int_t slice,Int_t patch,Int_t *rowrange,AliHLTTrackArray *tracks)
 {
   //Assuming tracklets found by the line transform
 
   fSlice=slice;
   fPatch=patch;
   
-  if(rowrange[0] > AliL3Transform::GetLastRow(patch) || rowrange[1] < AliL3Transform::GetFirstRow(patch))
-    cerr<<"AliL3ClusterFitter::Init : Wrong rows "<<rowrange[0]<<" "<<rowrange[1]<<endl;
+  if(rowrange[0] > AliHLTTransform::GetLastRow(patch) || rowrange[1] < AliHLTTransform::GetFirstRow(patch))
+    cerr<<"AliHLTClusterFitter::Init : Wrong rows "<<rowrange[0]<<" "<<rowrange[1]<<endl;
   fRowMin=rowrange[0];
   fRowMax=rowrange[1];
 
   if(fRowMin < 0)
     fRowMin = 0;
-  if(fRowMax > AliL3Transform::GetLastRow(fPatch))
-    fRowMax = AliL3Transform::GetLastRow(fPatch);
+  if(fRowMax > AliHLTTransform::GetLastRow(fPatch))
+    fRowMax = AliHLTTransform::GetLastRow(fPatch);
   
   fFitted=fFailed=0;
   
-  Int_t ntimes = AliL3Transform::GetNTimeBins()+1;
-  Int_t npads = AliL3Transform::GetNPads(AliL3Transform::GetLastRow(fPatch))+1;//Max num of pads.
+  Int_t ntimes = AliHLTTransform::GetNTimeBins()+1;
+  Int_t npads = AliHLTTransform::GetNPads(AliHLTTransform::GetLastRow(fPatch))+1;//Max num of pads.
   Int_t bounds = ntimes*npads;
   if(fRow)
     delete [] fRow;
@@ -116,13 +116,13 @@ void AliL3ClusterFitter::Init(Int_t slice,Int_t patch,Int_t *rowrange,AliL3Track
   if(fTracks)
     delete fTracks;
   
-  fTracks = new AliL3TrackArray("AliL3ModelTrack");
+  fTracks = new AliHLTTrackArray("AliHLTModelTrack");
   
   for(Int_t i=0; i<tracks->GetNTracks(); i++)
     {
-      AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->GetCheckedTrack(i);
+      AliHLTHoughTrack *track = (AliHLTHoughTrack*)tracks->GetCheckedTrack(i);
       if(!track) continue;
-      AliL3ModelTrack *mtrack = (AliL3ModelTrack*)fTracks->NextTrack();
+      AliHLTModelTrack *mtrack = (AliHLTModelTrack*)fTracks->NextTrack();
       mtrack->Init(slice,patch);
       mtrack->SetTgl(track->GetTgl());
       mtrack->SetRowRange(rowrange[0],rowrange[1]);
@@ -130,13 +130,13 @@ void AliL3ClusterFitter::Init(Int_t slice,Int_t patch,Int_t *rowrange,AliL3Track
        {
          Float_t hit[3];
          track->GetLineCrossingPoint(j,hit);
-         hit[0] += AliL3Transform::Row2X(track->GetFirstRow());
+         hit[0] += AliHLTTransform::Row2X(track->GetFirstRow());
          Float_t r = sqrt(hit[0]*hit[0] + hit[1]*hit[1]);
          hit[2] = r*track->GetTgl();
          Int_t se,ro;
-         AliL3Transform::Slice2Sector(slice,j,se,ro);
-         AliL3Transform::Local2Raw(hit,se,ro);
-         if(hit[1]<0 || hit[1]>=AliL3Transform::GetNPads(j) || hit[2]<0 || hit[2]>=AliL3Transform::GetNTimeBins())
+         AliHLTTransform::Slice2Sector(slice,j,se,ro);
+         AliHLTTransform::Local2Raw(hit,se,ro);
+         if(hit[1]<0 || hit[1]>=AliHLTTransform::GetNPads(j) || hit[2]<0 || hit[2]>=AliHLTTransform::GetNTimeBins())
            {
              mtrack->SetPadHit(j,-1);
              mtrack->SetTimeHit(j,-1);
@@ -144,8 +144,8 @@ void AliL3ClusterFitter::Init(Int_t slice,Int_t patch,Int_t *rowrange,AliL3Track
            }
          mtrack->SetPadHit(j,hit[1]);
          mtrack->SetTimeHit(j,hit[2]);
-         mtrack->SetCrossingAngleLUT(j,fabs(track->GetPsiLine() - AliL3Transform::Pi()/2));
-         //if(mtrack->GetCrossingAngleLUT(j) > AliL3Transform::Deg2Rad(20))
+         mtrack->SetCrossingAngleLUT(j,fabs(track->GetPsiLine() - AliHLTTransform::Pi()/2));
+         //if(mtrack->GetCrossingAngleLUT(j) > AliHLTTransform::Deg2Rad(20))
          //  cout<<"Angle "<<mtrack->GetCrossingAngleLUT(j)<<" psiline "<<track->GetPsiLine()*180/3.1415<<endl;
          mtrack->CalculateClusterWidths(j);
        }
@@ -153,42 +153,42 @@ void AliL3ClusterFitter::Init(Int_t slice,Int_t patch,Int_t *rowrange,AliL3Track
   //  cout<<"Copied "<<fTracks->GetNTracks()<<" tracks "<<endl;
 }
 
-void AliL3ClusterFitter::Init(Int_t slice,Int_t patch)
+void AliHLTClusterFitter::Init(Int_t slice,Int_t patch)
 {
   // Initialization
   fSlice=slice;
   fPatch=patch;
   
-  fRowMin=AliL3Transform::GetFirstRow(patch);
-  fRowMax=AliL3Transform::GetLastRow(patch);
+  fRowMin=AliHLTTransform::GetFirstRow(patch);
+  fRowMax=AliHLTTransform::GetLastRow(patch);
   
   fFitted=fFailed=0;
   
-  Int_t ntimes = AliL3Transform::GetNTimeBins()+1;
-  Int_t npads = AliL3Transform::GetNPads(AliL3Transform::GetLastRow(fPatch))+1;//Max num of pads.
+  Int_t ntimes = AliHLTTransform::GetNTimeBins()+1;
+  Int_t npads = AliHLTTransform::GetNPads(AliHLTTransform::GetLastRow(fPatch))+1;//Max num of pads.
   Int_t bounds = ntimes*npads;
   if(fRow)
     delete [] fRow;
   fRow = new Digit[bounds];
   if(fTracks)
     delete fTracks;
-  fTracks = new AliL3TrackArray("AliL3ModelTrack");  
+  fTracks = new AliHLTTrackArray("AliHLTModelTrack");  
 
 }
 
-void AliL3ClusterFitter::LoadLocalSegments()
+void AliHLTClusterFitter::LoadLocalSegments()
 {
   // loads local segments
   Char_t filename[1024];
   sprintf(filename,"%s/hough/tracks_ho_%d_%d_%d.raw",fPath,fEvent,fSlice,fPatch);
-  AliL3MemHandler mem;
+  AliHLTMemHandler mem;
   mem.SetBinaryInput(filename);
   mem.Binary2TrackArray(fTracks);
   mem.CloseBinaryInput();
   
   for(Int_t i=0; i<fTracks->GetNTracks(); i++)
     {
-      AliL3ModelTrack *track = (AliL3ModelTrack*)fTracks->GetCheckedTrack(i);
+      AliHLTModelTrack *track = (AliHLTModelTrack*)fTracks->GetCheckedTrack(i);
       if(!track) continue;
 
       track->CalculateHelix();
@@ -204,11 +204,11 @@ void AliL3ClusterFitter::LoadLocalSegments()
            continue;
          
          Int_t sector,row;
-         AliL3Transform::Slice2Sector(fSlice,j,sector,row);
-         AliL3Transform::Local2Raw(xyzCross,sector,row);
+         AliHLTTransform::Slice2Sector(fSlice,j,sector,row);
+         AliHLTTransform::Local2Raw(xyzCross,sector,row);
          
-         if(xyzCross[1] < 0 || xyzCross[1] >= AliL3Transform::GetNPads(j) ||
-            xyzCross[2] < 0 || xyzCross[2] >= AliL3Transform::GetNTimeBins()) //track goes out of range
+         if(xyzCross[1] < 0 || xyzCross[1] >= AliHLTTransform::GetNPads(j) ||
+            xyzCross[2] < 0 || xyzCross[2] >= AliHLTTransform::GetNTimeBins()) //track goes out of range
            continue;
          
          track->SetPadHit(j,xyzCross[1]);
@@ -223,7 +223,7 @@ void AliL3ClusterFitter::LoadLocalSegments()
     }
 }
 
-void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,Float_t zvertex)
+void AliHLTClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,Float_t zvertex)
 {
   //Function assumes _global_ tracks written to a single file.
   cout<<"Loading the seeds"<<endl;
@@ -235,14 +235,14 @@ void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,
   else
     sprintf(fname,"%s/hough/tracks_%d.raw",fPath,fEvent);
   
-  cout<<"AliL3ClusterFitter::LoadSeeds : Loading input tracks from "<<fname<<endl;
+  cout<<"AliHLTClusterFitter::LoadSeeds : Loading input tracks from "<<fname<<endl;
   
-  AliL3MemHandler tfile;
+  AliHLTMemHandler tfile;
   tfile.SetBinaryInput(fname);
   
   if(fSeeds)
     delete fSeeds;
-  fSeeds = new AliL3TrackArray("AliL3ModelTrack");
+  fSeeds = new AliHLTTrackArray("AliHLTModelTrack");
 
   tfile.Binary2TrackArray(fSeeds);
   tfile.CloseBinaryInput();
@@ -253,12 +253,12 @@ void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,
   Int_t clustercount=0;
   for(Int_t i=0; i<fSeeds->GetNTracks(); i++)
     {
-      AliL3ModelTrack *track = (AliL3ModelTrack*)fSeeds->GetCheckedTrack(i);
+      AliHLTModelTrack *track = (AliHLTModelTrack*)fSeeds->GetCheckedTrack(i);
       if(!track) continue;
 
       if(!offline)
        {
-         if(i==0) cerr<<"AliL3ClusterFitter::LoadSeeds : Cutting on pt of 4 GeV!!"<<endl;
+         if(i==0) cerr<<"AliHLTClusterFitter::LoadSeeds : Cutting on pt of 4 GeV!!"<<endl;
          if(track->GetPt() > 4.) 
            {
              fSeeds->Remove(i);
@@ -289,8 +289,8 @@ void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,
          
          //Calculate the crossing point between track and padrow
          Float_t angle = 0; //Perpendicular to padrow in local coordinates
-         AliL3Transform::Local2GlobalAngle(&angle,slice);
-         if(!track->CalculateReferencePoint(angle,AliL3Transform::Row2X(j)))
+         AliHLTTransform::Local2GlobalAngle(&angle,slice);
+         if(!track->CalculateReferencePoint(angle,AliHLTTransform::Row2X(j)))
            {
              //cerr<<"No crossing in slice "<<slice<<" padrow "<<j<<endl;
              continue;
@@ -301,10 +301,10 @@ void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,
          xyzCross[2] += zvertex;
          
          Int_t sector,row;
-         AliL3Transform::Slice2Sector(slice,j,sector,row);
-         AliL3Transform::Global2Raw(xyzCross,sector,row);
+         AliHLTTransform::Slice2Sector(slice,j,sector,row);
+         AliHLTTransform::Global2Raw(xyzCross,sector,row);
          //cout<<"Examining slice "<<slice<<" row "<<j<<" pad "<<xyzCross[1]<<" time "<<xyzCross[2]<<endl;
-         if(xyzCross[1] < 0 || xyzCross[1] >= AliL3Transform::GetNPads(j)) //Track leaves the slice
+         if(xyzCross[1] < 0 || xyzCross[1] >= AliHLTTransform::GetNPads(j)) //Track leaves the slice
            {
            newslice:
              
@@ -335,8 +335,8 @@ void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,
                }
              //cout<<"Track leaving, trying slice "<<slice<<endl;
              angle=0;
-             AliL3Transform::Local2GlobalAngle(&angle,slice);
-             if(!track->CalculateReferencePoint(angle,AliL3Transform::Row2X(j)))
+             AliHLTTransform::Local2GlobalAngle(&angle,slice);
+             if(!track->CalculateReferencePoint(angle,AliHLTTransform::Row2X(j)))
                {
                  cerr<<"No crossing in slice "<<slice<<" padrow "<<j<<endl;
                  continue;
@@ -348,9 +348,9 @@ void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,
              xyzCross[2] = track->GetPointZ();
              xyzCross[2] += zvertex;
              Int_t sector,row;
-             AliL3Transform::Slice2Sector(slice,j,sector,row);
-             AliL3Transform::Global2Raw(xyzCross,sector,row);
-             if(xyzCross[1] < 0 || xyzCross[1] >= AliL3Transform::GetNPads(j)) //track is in the borderline
+             AliHLTTransform::Slice2Sector(slice,j,sector,row);
+             AliHLTTransform::Global2Raw(xyzCross,sector,row);
+             if(xyzCross[1] < 0 || xyzCross[1] >= AliHLTTransform::GetNPads(j)) //track is in the borderline
                {
                  if(xyzCross[1] > 0 && lastcross > 0 || xyzCross[1] < 0 && lastcross < 0)
                    goto newslice;
@@ -362,10 +362,10 @@ void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,
                }
            }
          
-         if(xyzCross[2] < 0 || xyzCross[2] >= AliL3Transform::GetNTimeBins())//track goes out of range
+         if(xyzCross[2] < 0 || xyzCross[2] >= AliHLTTransform::GetNTimeBins())//track goes out of range
            continue;
          
-         if(xyzCross[1] < 0 || xyzCross[1] >= AliL3Transform::GetNPads(j))
+         if(xyzCross[1] < 0 || xyzCross[1] >= AliHLTTransform::GetNPads(j))
            {
              cerr<<"Slice "<<slice<<" padrow "<<j<<" pad "<<xyzCross[1]<<" time "<<xyzCross[2]<<endl;
              track->Print();
@@ -375,7 +375,7 @@ void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,
          track->SetPadHit(j,xyzCross[1]);
          track->SetTimeHit(j,xyzCross[2]);
          angle=0;
-         AliL3Transform::Local2GlobalAngle(&angle,slice);
+         AliHLTTransform::Local2GlobalAngle(&angle,slice);
          Float_t crossingangle = track->GetCrossingAngle(j,slice);
          track->SetCrossingAngleLUT(j,crossingangle);
          
@@ -392,56 +392,56 @@ void AliL3ClusterFitter::LoadSeeds(Int_t *rowrange,Bool_t offline,Int_t eventnr,
   cout<<"Loaded "<<fSeeds->GetNTracks()<<" seeds and "<<clustercount<<" clusters"<<endl;
 }
 
-void AliL3ClusterFitter::FindClusters()
+void AliHLTClusterFitter::FindClusters()
 {
   // finds clusters
   if(!fTracks)
     {
-      cerr<<"AliL3ClusterFitter::Process : No tracks"<<endl;
+      cerr<<"AliHLTClusterFitter::Process : No tracks"<<endl;
       return;
     }
   if(!fRowData)
     {
-      cerr<<"AliL3ClusterFitter::Process : No data "<<endl;
+      cerr<<"AliHLTClusterFitter::Process : No data "<<endl;
       return;
     }
   
-  AliL3DigitRowData *rowPt = fRowData;
-  AliL3DigitData *digPt=0;
+  AliHLTDigitRowData *rowPt = fRowData;
+  AliHLTDigitData *digPt=0;
 
   Int_t pad,time;
   Short_t charge;
   
   if(fRowMin < 0)
     {
-      fRowMin = AliL3Transform::GetFirstRow(fPatch);
-      fRowMax = AliL3Transform::GetLastRow(fPatch);
+      fRowMin = AliHLTTransform::GetFirstRow(fPatch);
+      fRowMax = AliHLTTransform::GetLastRow(fPatch);
     }
-  for(Int_t i=AliL3Transform::GetFirstRow(fPatch); i<=AliL3Transform::GetLastRow(fPatch); i++)
+  for(Int_t i=AliHLTTransform::GetFirstRow(fPatch); i<=AliHLTTransform::GetLastRow(fPatch); i++)
     {
       if((Int_t)rowPt->fRow < fRowMin)
        {
-         AliL3MemHandler::UpdateRowPointer(rowPt);
+         AliHLTMemHandler::UpdateRowPointer(rowPt);
          continue;
        }
       else if((Int_t)rowPt->fRow > fRowMax)
        break;
       else if((Int_t)rowPt->fRow != i)
        {
-         cerr<<"AliL3ClusterFitter::FindClusters : Mismatching row numbering "<<i<<" "<<rowPt->fRow<<endl;
+         cerr<<"AliHLTClusterFitter::FindClusters : Mismatching row numbering "<<i<<" "<<rowPt->fRow<<endl;
          exit(5);
        }
       fCurrentPadRow = i;
-      memset((void*)fRow,0,(AliL3Transform::GetNTimeBins()+1)*(AliL3Transform::GetNPads(i)+1)*sizeof(Digit));
-      digPt = (AliL3DigitData*)rowPt->fDigitData;
+      memset((void*)fRow,0,(AliHLTTransform::GetNTimeBins()+1)*(AliHLTTransform::GetNPads(i)+1)*sizeof(Digit));
+      digPt = (AliHLTDigitData*)rowPt->fDigitData;
 
       for(UInt_t j=0; j<rowPt->fNDigit; j++)
        {
          pad = digPt[j].fPad;
          time = digPt[j].fTime;
          charge = digPt[j].fCharge;
-         fRow[(AliL3Transform::GetNTimeBins()+1)*pad+time].fCharge = charge;
-         fRow[(AliL3Transform::GetNTimeBins()+1)*pad+time].fUsed = kFALSE;
+         fRow[(AliHLTTransform::GetNTimeBins()+1)*pad+time].fCharge = charge;
+         fRow[(AliHLTTransform::GetNTimeBins()+1)*pad+time].fUsed = kFALSE;
          //cout<<"Row "<<i<<" pad "<<pad<<" time "<<time<<" charge "<<charge<<endl;
        }
       
@@ -462,14 +462,14 @@ void AliL3ClusterFitter::FindClusters()
          
          for(Int_t k=0; k<fProcessTracks->GetNTracks(); k++)
            {
-             AliL3ModelTrack *track = (AliL3ModelTrack*)fProcessTracks->GetCheckedTrack(k);
+             AliHLTModelTrack *track = (AliHLTModelTrack*)fProcessTracks->GetCheckedTrack(k);
              if(!track) continue;
              
              if(fSeeding)
                if(track->GetClusterModel(i)->fSlice != fSlice) continue;
              
-             if(track->GetPadHit(i) < 0 || track->GetPadHit(i) > AliL3Transform::GetNPads(i)-1 ||
-                track->GetTimeHit(i) < 0 || track->GetTimeHit(i) > AliL3Transform::GetNTimeBins()-1)
+             if(track->GetPadHit(i) < 0 || track->GetPadHit(i) > AliHLTTransform::GetNPads(i)-1 ||
+                track->GetTimeHit(i) < 0 || track->GetTimeHit(i) > AliHLTTransform::GetNTimeBins()-1)
                {
                  track->SetCluster(i,0,0,0,0,0,0);
                  continue;
@@ -479,7 +479,7 @@ void AliL3ClusterFitter::FindClusters()
                fFailed++;
            }
        }
-      AliL3MemHandler::UpdateRowPointer(rowPt);
+      AliHLTMemHandler::UpdateRowPointer(rowPt);
     }
   
   fSeeding = kTRUE;
@@ -496,11 +496,11 @@ void AliL3ClusterFitter::FindClusters()
 
 }
 
-Bool_t AliL3ClusterFitter::CheckCluster(Int_t trackindex)
+Bool_t AliHLTClusterFitter::CheckCluster(Int_t trackindex)
 {
   //Check if this is a single or overlapping cluster
   
-  AliL3ModelTrack *track = (AliL3ModelTrack*)fProcessTracks->GetCheckedTrack(trackindex);
+  AliHLTModelTrack *track = (AliHLTModelTrack*)fProcessTracks->GetCheckedTrack(trackindex);
   
   Int_t row = fCurrentPadRow;
   
@@ -518,7 +518,7 @@ Bool_t AliL3ClusterFitter::CheckCluster(Int_t trackindex)
       if(fDebug)
        cout<<"Failed to fit cluster at row "<<row<<" pad "<<(Int_t)rint(track->GetPadHit(row))<<" time "
            <<(Int_t)rint(track->GetTimeHit(row))<<" hitcharge "
-           <<fRow[(AliL3Transform::GetNTimeBins()+1)*(Int_t)rint(track->GetPadHit(row))+(Int_t)rint(track->GetTimeHit(row))].fCharge<<endl;
+           <<fRow[(AliHLTTransform::GetNTimeBins()+1)*(Int_t)rint(track->GetPadHit(row))+(Int_t)rint(track->GetTimeHit(row))].fCharge<<endl;
       fgFitRangeError++;
       return kFALSE;
     }
@@ -527,7 +527,7 @@ Bool_t AliL3ClusterFitter::CheckCluster(Int_t trackindex)
 
   for(Int_t t=trackindex+1; t<fProcessTracks->GetNTracks(); t++)
     {
-      AliL3ModelTrack *tr = (AliL3ModelTrack*)fProcessTracks->GetCheckedTrack(t);
+      AliHLTModelTrack *tr = (AliHLTModelTrack*)fProcessTracks->GetCheckedTrack(t);
       if(!tr) continue;
       if(fSeeding)
        if(tr->GetClusterModel(row)->fSlice != fSlice) continue;
@@ -572,16 +572,16 @@ Bool_t AliL3ClusterFitter::CheckCluster(Int_t trackindex)
   return kTRUE;
 }
 
-Bool_t AliL3ClusterFitter::SetFitRange(AliL3ModelTrack *track,Int_t *padrange,Int_t *timerange)
+Bool_t AliHLTClusterFitter::SetFitRange(AliHLTModelTrack *track,Int_t *padrange,Int_t *timerange)
 {
   // sets the fit range
   Int_t row = fCurrentPadRow;
-  Int_t nt = AliL3Transform::GetNTimeBins()+1;
+  Int_t nt = AliHLTTransform::GetNTimeBins()+1;
   
   Int_t nsearchbins=0;
-  if(row < AliL3Transform::GetNRowLow())
+  if(row < AliHLTTransform::GetNRowLow())
     nsearchbins=25;
-  else if(row < AliL3Transform::GetNRowLow() + AliL3Transform::GetNRowUp1())
+  else if(row < AliHLTTransform::GetNRowLow() + AliHLTTransform::GetNRowUp1())
     nsearchbins=25;
   else
     nsearchbins=25;
@@ -648,7 +648,7 @@ Bool_t AliL3ClusterFitter::SetFitRange(AliL3ModelTrack *track,Int_t *padrange,In
                  j=timemax;
                  while(abs(timemax-j) < zw)
                    {
-                     if(i<0 || i>=AliL3Transform::GetNPads(row) || j<0 || j>=AliL3Transform::GetNTimeBins()) break;
+                     if(i<0 || i>=AliHLTTransform::GetNPads(row) || j<0 || j>=AliHLTTransform::GetNTimeBins()) break;
                      if(fRow[nt*i+j].fCharge)
                        {
                          if(i < padrange[0]) padrange[0]=i;
@@ -672,7 +672,7 @@ Bool_t AliL3ClusterFitter::SetFitRange(AliL3ModelTrack *track,Int_t *padrange,In
        {
        for(Int_t j=timemax-zw; j<=timemax+zw; j++)
        {
-       if(i<0 || i>=AliL3Transform::GetNPads(row) || j<0 || j>=AliL3Transform::GetNTimeBins()) continue;
+       if(i<0 || i>=AliHLTTransform::GetNPads(row) || j<0 || j>=AliHLTTransform::GetNTimeBins()) continue;
        if(fRow[nt*i+j].fCharge)
        {
        if(i < padrange[0]) padrange[0]=i;
@@ -691,13 +691,13 @@ Bool_t AliL3ClusterFitter::SetFitRange(AliL3ModelTrack *track,Int_t *padrange,In
   return kFALSE;
 }
 
-Bool_t AliL3ClusterFitter::IsMaximum(Int_t pad,Int_t time)
+Bool_t AliHLTClusterFitter::IsMaximum(Int_t pad,Int_t time)
 {
   // checks the maximum
-  if(pad<0 || pad >= AliL3Transform::GetNPads(fCurrentPadRow) ||
-     time<0 || time >= AliL3Transform::GetNTimeBins())
+  if(pad<0 || pad >= AliHLTTransform::GetNPads(fCurrentPadRow) ||
+     time<0 || time >= AliHLTTransform::GetNTimeBins())
     return kFALSE;
-  Int_t nt = AliL3Transform::GetNTimeBins()+1;
+  Int_t nt = AliHLTTransform::GetNTimeBins()+1;
   if(fRow[nt*pad+time].fUsed == kTRUE) return kFALSE; //Peak has been assigned before
   Int_t charge = fRow[nt*pad+time].fCharge;
   if(charge == 1024 || charge==0) return kFALSE;
@@ -718,13 +718,13 @@ Bool_t AliL3ClusterFitter::IsMaximum(Int_t pad,Int_t time)
   return kTRUE;
 }
 
-void AliL3ClusterFitter::CalculateWeightedMean(AliL3ModelTrack *track,Int_t *padrange,Int_t *timerange)
+void AliHLTClusterFitter::CalculateWeightedMean(AliHLTModelTrack *track,Int_t *padrange,Int_t *timerange)
 {
   // calculates weighted mean
   Float_t sum=0;
   Int_t npads=0;
   Float_t pad=0,time=0;
-  Int_t nt = AliL3Transform::GetNTimeBins()+1;
+  Int_t nt = AliHLTTransform::GetNTimeBins()+1;
   for(Int_t i=padrange[0]; i<=padrange[1]; i++)
     {
       Int_t lsum=0;
@@ -747,15 +747,15 @@ void AliL3ClusterFitter::CalculateWeightedMean(AliL3ModelTrack *track,Int_t *pad
     track->SetCluster(fCurrentPadRow,0,0,0,0,0,0);
 }
 
-void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_t *timerange)
+void AliHLTClusterFitter::FitClusters(AliHLTModelTrack *track,Int_t *padrange,Int_t *timerange)
 {
   //Handle single and overlapping clusters
   
   /*
   if( (Int_t)rint(track->GetClusterModel(fCurrentPadRow)->fDPad) <= 1 || 
-      (Int_t)rint(track->GetClusterModel(fCurrentPadRow)->fDPad) >= AliL3Transform::GetNPads(fCurrentPadRow)-2 ||
+      (Int_t)rint(track->GetClusterModel(fCurrentPadRow)->fDPad) >= AliHLTTransform::GetNPads(fCurrentPadRow)-2 ||
       (Int_t)rint(track->GetClusterModel(fCurrentPadRow)->fDTime) <= 1 ||
-      (Int_t)rint(track->GetClusterModel(fCurrentPadRow)->fDTime) >= AliL3Transform::GetNTimeBins()-2)
+      (Int_t)rint(track->GetClusterModel(fCurrentPadRow)->fDTime) >= AliHLTTransform::GetNTimeBins()-2)
     {
       CalculateWeightedMean(track,padrange,timerange);
       return;
@@ -765,7 +765,7 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
   Int_t maxTracks = FIT_MAXPAR/NUM_PARS;
   if(track->GetNOverlaps(fCurrentPadRow) > maxTracks)
     {
-      cerr<<"AliL3ClusterFitter::FitOverlappingClusters : Too many overlapping tracks"<<endl;
+      cerr<<"AliHLTClusterFitter::FitOverlappingClusters : Too many overlapping tracks"<<endl;
       return;
     }
   Int_t *overlaps = track->GetOverlaps(fCurrentPadRow);
@@ -776,11 +776,11 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
   Int_t k=-1;
   while(k < track->GetNOverlaps(fCurrentPadRow))
     {
-      AliL3ModelTrack *tr=0;
+      AliHLTModelTrack *tr=0;
       if(k==-1)
        tr = track;
       else
-       tr = (AliL3ModelTrack*)fProcessTracks->GetCheckedTrack(overlaps[k]);
+       tr = (AliHLTModelTrack*)fProcessTracks->GetCheckedTrack(overlaps[k]);
       k++;
       if(!tr) continue;
       if(!tr->IsSet(fCurrentPadRow) && !tr->IsPresent(fCurrentPadRow))//cluster has not been set and is not present
@@ -815,11 +815,11 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
   //Fill the overlapping tracks:
   while(k < track->GetNOverlaps(fCurrentPadRow))
     {
-      AliL3ModelTrack *tr=0;
+      AliHLTModelTrack *tr=0;
       if(k==-1)
        tr = track;
       else
-       tr = (AliL3ModelTrack*)fProcessTracks->GetCheckedTrack(overlaps[k]);
+       tr = (AliHLTModelTrack*)fProcessTracks->GetCheckedTrack(overlaps[k]);
       k++;
       if(!tr) continue;
       
@@ -829,7 +829,7 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
       //The local maxima is temporary stored in the cluster model:
       Int_t hitpad = (Int_t)rint(tr->GetClusterModel(fCurrentPadRow)->fDPad);  
       Int_t hittime = (Int_t)rint(tr->GetClusterModel(fCurrentPadRow)->fDTime);
-      Int_t charge = fRow[(AliL3Transform::GetNTimeBins()+1)*hitpad + hittime].fCharge;
+      Int_t charge = fRow[(AliHLTTransform::GetNTimeBins()+1)*hitpad + hittime].fCharge;
       
       if(fDebug)
        cout<<"Fitting track cluster, pad "<<tr->GetPadHit(fCurrentPadRow)<<" time "
@@ -864,7 +864,7 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
        {
          if(!tr->IsPresent(fCurrentPadRow))
            {
-             cerr<<"AliL3ClusterFitter::FindClusters : Cluster not present; there is a bug here"<<endl;
+             cerr<<"AliHLTClusterFitter::FindClusters : Cluster not present; there is a bug here"<<endl;
              exit(5);
            }
          Int_t charge;
@@ -913,7 +913,7 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
       Int_t timeNum=0;
       for(Int_t j=timerange[0]; j<=timerange[1]; j++)
        {
-         Int_t charge = fRow[(AliL3Transform::GetNTimeBins()+1)*i + j].fCharge;
+         Int_t charge = fRow[(AliHLTTransform::GetNTimeBins()+1)*i + j].fCharge;
          
          if(charge <= 0) continue;
 
@@ -983,11 +983,11 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
   nOverlaps=0;
   while(k < track->GetNOverlaps(fCurrentPadRow))
     {
-      AliL3ModelTrack *tr=0;
+      AliHLTModelTrack *tr=0;
       if(k==-1)
        tr = track;
       else
-       tr = (AliL3ModelTrack*)fProcessTracks->GetCheckedTrack(overlaps[k]);
+       tr = (AliHLTModelTrack*)fProcessTracks->GetCheckedTrack(overlaps[k]);
       k++;
       if(!tr) continue;
       if(!tr->IsPresent(fCurrentPadRow))
@@ -995,9 +995,9 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
          if(tr->IsSet(fCurrentPadRow)) continue;//This cluster has been set before
          
          Int_t lpatch;
-         if(fCurrentPadRow < AliL3Transform::GetNRowLow())
+         if(fCurrentPadRow < AliHLTTransform::GetNRowLow())
            lpatch=0;
-         else if(fCurrentPadRow < AliL3Transform::GetNRowLow() + AliL3Transform::GetNRowUp1())
+         else if(fCurrentPadRow < AliHLTTransform::GetNRowLow() + AliHLTTransform::GetNRowUp1())
            lpatch=1;
          else 
            lpatch=2;
@@ -1005,14 +1005,14 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
          //if(chisqF < fChiSqMax[(Int_t)overlapping])//cluster fit is good enough
          if(chisqF < fChiSqMax[lpatch])//cluster fit is good enough
            {
-             totCharge = (Int_t)(2*AliL3Transform::Pi() * a[nOverlaps*NUM_PARS+1] * a[nOverlaps*NUM_PARS+3] * a[nOverlaps*NUM_PARS+5]);
+             totCharge = (Int_t)(2*AliHLTTransform::Pi() * a[nOverlaps*NUM_PARS+1] * a[nOverlaps*NUM_PARS+3] * a[nOverlaps*NUM_PARS+5]);
              Float_t fpad = a[nOverlaps*NUM_PARS+2];
              Float_t ftime = a[nOverlaps*NUM_PARS+4];
-             if(totCharge < 0 || fpad < -1 || fpad > AliL3Transform::GetNPads(fCurrentPadRow) || 
-                ftime < -1 || ftime > AliL3Transform::GetNTimeBins())
+             if(totCharge < 0 || fpad < -1 || fpad > AliHLTTransform::GetNPads(fCurrentPadRow) || 
+                ftime < -1 || ftime > AliHLTTransform::GetNTimeBins())
                {
                  if(fDebug)
-                   cout<<"AliL3ClusterFitter::Fatal result(s) in fit; in slice "<<fSlice<<" row "<<fCurrentPadRow
+                   cout<<"AliHLTClusterFitter::Fatal result(s) in fit; in slice "<<fSlice<<" row "<<fCurrentPadRow
                        <<"; pad "<<fpad<<" time "<<ftime<<" charge "<<totCharge<<" xywidth "<<a[nOverlaps*NUM_PARS+3]
                        <<" zwidth "<<a[nOverlaps*NUM_PARS+5]<<" peakcharge "<<a[nOverlaps*NUM_PARS+1]<<endl;
                  tr->SetCluster(fCurrentPadRow,0,0,0,0,0,0);
@@ -1037,7 +1037,7 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
              //Set the digits to used:
              for(Int_t i=padrange[0]; i<=padrange[1]; i++)
              for(Int_t j=timerange[0]; j<=timerange[1]; j++)
-             fRow[(AliL3Transform::GetNTimeBins()+1)*i + j].fUsed = kTRUE;
+             fRow[(AliHLTTransform::GetNTimeBins()+1)*i + j].fUsed = kTRUE;
              */
              fFitted++;
            }
@@ -1056,7 +1056,7 @@ void AliL3ClusterFitter::FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_
   delete [] plane;
 }
 
-void AliL3ClusterFitter::SetClusterfitFalse(AliL3ModelTrack *track)
+void AliHLTClusterFitter::SetClusterfitFalse(AliHLTModelTrack *track)
 {
   //Cluster fit failed, so set the clusters to all the participating
   //tracks to zero.
@@ -1065,18 +1065,18 @@ void AliL3ClusterFitter::SetClusterfitFalse(AliL3ModelTrack *track)
   Int_t *overlaps = track->GetOverlaps(fCurrentPadRow);
   while(i < track->GetNOverlaps(fCurrentPadRow))
     {
-      AliL3ModelTrack *tr=0;
+      AliHLTModelTrack *tr=0;
       if(i==-1)
        tr = track;
       else
-       tr = (AliL3ModelTrack*)fProcessTracks->GetCheckedTrack(overlaps[i]);
+       tr = (AliHLTModelTrack*)fProcessTracks->GetCheckedTrack(overlaps[i]);
       i++;
       if(!tr) continue;
       
       //Set the digit data to unused, so it can be fitted to another bastard:
       Int_t hitpad = (Int_t)rint(tr->GetClusterModel(fCurrentPadRow)->fDPad);  
       Int_t hittime = (Int_t)rint(tr->GetClusterModel(fCurrentPadRow)->fDTime);
-      fRow[(AliL3Transform::GetNTimeBins()+1)*hitpad + hittime].fUsed = kFALSE;
+      fRow[(AliHLTTransform::GetNTimeBins()+1)*hitpad + hittime].fUsed = kFALSE;
       
       tr->SetCluster(fCurrentPadRow,0,0,0,0,0,0);
     }
@@ -1084,19 +1084,19 @@ void AliL3ClusterFitter::SetClusterfitFalse(AliL3ModelTrack *track)
 }
 
 
-void AliL3ClusterFitter::AddClusters()
+void AliHLTClusterFitter::AddClusters()
 {
   // adds clusters
   if(!fClusters)
     {
-      fClusters = new AliL3SpacePointData[fNMaxClusters];
+      fClusters = new AliHLTSpacePointData[fNMaxClusters];
       fNClusters=0;
     }
   
   if(fDebug)
     cout<<"Writing cluster in slice "<<fSlice<<" patch "<<fPatch<<endl;
   
-  AliL3TrackArray *tracks=0;
+  AliHLTTrackArray *tracks=0;
   if(fSeeding==kTRUE)
     tracks = fSeeds;
   else
@@ -1107,7 +1107,7 @@ void AliL3ClusterFitter::AddClusters()
   
   for(Int_t i=0; i<tracks->GetNTracks(); i++)
     {
-      AliL3ModelTrack *tr = (AliL3ModelTrack*)tracks->GetCheckedTrack(i);
+      AliHLTModelTrack *tr = (AliHLTModelTrack*)tracks->GetCheckedTrack(i);
       if(!tr) continue;
       
       UInt_t *hitids = tr->GetHitNumbers();
@@ -1124,8 +1124,8 @@ void AliL3ClusterFitter::AddClusters()
          tr->GetTime(i,time);
          tr->GetClusterCharge(i,charge);
 
-         if(pad < -1 || pad >= AliL3Transform::GetNPads(i) || 
-            time < -1 || time >= AliL3Transform::GetNTimeBins())
+         if(pad < -1 || pad >= AliHLTTransform::GetNPads(i) || 
+            time < -1 || time >= AliHLTTransform::GetNTimeBins())
            {
              continue;
 //           cout<<"slice "<<fSlice<<" row "<<i<<" pad "<<pad<<" time "<<time<<endl;
@@ -1139,13 +1139,13 @@ void AliL3ClusterFitter::AddClusters()
          tr->GetSigmaZ2(i,zwidth);
          Float_t xyz[3];
          Int_t sector,row;
-         AliL3Transform::Slice2Sector(fSlice,i,sector,row);
+         AliHLTTransform::Slice2Sector(fSlice,i,sector,row);
          
-         AliL3Transform::Raw2Local(xyz,sector,row,pad,time);
+         AliHLTTransform::Raw2Local(xyz,sector,row,pad,time);
          
          if(fNClusters >= fNMaxClusters)
            {
-             cerr<<"AliL3ClusterFitter::AddClusters : Too many clusters "<<fNClusters<<endl;
+             cerr<<"AliHLTClusterFitter::AddClusters : Too many clusters "<<fNClusters<<endl;
              exit(5);
            }
          
@@ -1154,15 +1154,15 @@ void AliL3ClusterFitter::AddClusters()
          fClusters[fNClusters].fZ = xyz[2];
          fClusters[fNClusters].fCharge = charge;
          fClusters[fNClusters].fPadRow = i;
-         Int_t pa = AliL3Transform::GetPatch(i);
+         Int_t pa = AliHLTTransform::GetPatch(i);
          if(xywidth==0 || zwidth==0)
-           cerr<<"AliL3ClusterFitter::AddClusters : Cluster with zero width"<<endl;
+           cerr<<"AliHLTClusterFitter::AddClusters : Cluster with zero width"<<endl;
          if(xywidth>0)
-           fClusters[fNClusters].fSigmaY2 = xywidth*pow(AliL3Transform::GetPadPitchWidth(pa),2);
+           fClusters[fNClusters].fSigmaY2 = xywidth*pow(AliHLTTransform::GetPadPitchWidth(pa),2);
          else
            fClusters[fNClusters].fSigmaY2 = 1;
          if(zwidth>0)
-           fClusters[fNClusters].fSigmaZ2 = zwidth*pow(AliL3Transform::GetZWidth(),2);
+           fClusters[fNClusters].fSigmaZ2 = zwidth*pow(AliHLTTransform::GetZWidth(),2);
          else
            fClusters[fNClusters].fSigmaZ2 = 1;
          Int_t pat=fPatch;
@@ -1170,9 +1170,9 @@ void AliL3ClusterFitter::AddClusters()
            pat=0;
          fClusters[fNClusters].fID = fNClusters + ((fSlice&0x7f)<<25)+((pat&0x7)<<22);
          
-         if(nhits >= AliL3Transform::GetNRows())
+         if(nhits >= AliHLTTransform::GetNRows())
            {
-             cerr<<"AliL3ClusterFitter::AddClusters : Cluster counter of out range "<<nhits<<endl;
+             cerr<<"AliHLTClusterFitter::AddClusters : Cluster counter of out range "<<nhits<<endl;
              exit(5);
            }
          hitids[nhits++] = fClusters[fNClusters].fID;
@@ -1183,12 +1183,12 @@ void AliL3ClusterFitter::AddClusters()
          Int_t ftime = (Int_t)rint(time);
          if(fpad < 0)
            fpad=0;
-         if(fpad >= AliL3Transform::GetNPads(i))
-           fpad = AliL3Transform::GetNPads(i)-1;
+         if(fpad >= AliHLTTransform::GetNPads(i))
+           fpad = AliHLTTransform::GetNPads(i)-1;
          if(ftime<0)
            ftime=0;
-         if(ftime >= AliL3Transform::GetNTimeBins())
-           ftime = AliL3Transform::GetNTimeBins()-1;
+         if(ftime >= AliHLTTransform::GetNTimeBins())
+           ftime = AliHLTTransform::GetNTimeBins()-1;
          GetTrackID(fpad,ftime,trackID);
          fClusters[fNClusters].fTrackID[0] = trackID[0];
          fClusters[fNClusters].fTrackID[1] = trackID[1];
@@ -1204,18 +1204,18 @@ void AliL3ClusterFitter::AddClusters()
     }
 }
 
-void AliL3ClusterFitter::WriteTracks(Int_t minHits)
+void AliHLTClusterFitter::WriteTracks(Int_t minHits)
 {
   // writes tracks
   if(!fSeeds)
     return;
   
-  AliL3TrackArray *fakes = new AliL3TrackArray();
+  AliHLTTrackArray *fakes = new AliHLTTrackArray();
   
   Int_t clustercount=0;
   for(Int_t i=0; i<fSeeds->GetNTracks(); i++)
     {
-      AliL3ModelTrack *tr = (AliL3ModelTrack*)fSeeds->GetCheckedTrack(i);
+      AliHLTModelTrack *tr = (AliHLTModelTrack*)fSeeds->GetCheckedTrack(i);
       if(!tr) continue;
       if(tr->GetNHits() < minHits)
        {
@@ -1227,7 +1227,7 @@ void AliL3ClusterFitter::WriteTracks(Int_t minHits)
   
   cout<<"Writing "<<clustercount<<" clusters"<<endl;
   fSeeds->Compress();
-  AliL3MemHandler mem;
+  AliHLTMemHandler mem;
   Char_t filename[1024];
   sprintf(filename,"%s/fitter/tracks_%d.raw",fPath,fEvent);
   mem.SetBinaryOutput(filename);
@@ -1243,10 +1243,10 @@ void AliL3ClusterFitter::WriteTracks(Int_t minHits)
   delete fakes;
 }
 
-void AliL3ClusterFitter::WriteClusters(Bool_t global)
+void AliHLTClusterFitter::WriteClusters(Bool_t global)
 {
   // writes clusters
-  AliL3MemHandler mem;
+  AliHLTMemHandler mem;
   if(fDebug)
     cout<<"Write "<<fNClusters<<" clusters to file"<<endl;
   Char_t filename[1024];
similarity index 57%
rename from HLT/comp/AliL3ClusterFitter.h
rename to HLT/comp/AliHLTClusterFitter.h
index c6997b2..a087637 100644 (file)
@@ -1,23 +1,23 @@
 // @(#) $Id$
 
-#ifndef AliL3_ClusterFitter
-#define AliL3_ClusterFitter
+#ifndef AliHLT_ClusterFitter
+#define AliHLT_ClusterFitter
 
-#include "AliL3Modeller.h"
-#include "AliL3Transform.h"
+#include "AliHLTModeller.h"
+#include "AliHLTTransform.h"
 
-class AliL3ModelTrack;
-class AliL3TrackArray;
-class AliL3SpacePointData;
+class AliHLTModelTrack;
+class AliHLTTrackArray;
+class AliHLTSpacePointData;
 
-class AliL3ClusterFitter : public AliL3Modeller {
+class AliHLTClusterFitter : public AliHLTModeller {
   
  public:
-  AliL3ClusterFitter();
-  AliL3ClusterFitter(Char_t *path);
-  virtual ~AliL3ClusterFitter();
+  AliHLTClusterFitter();
+  AliHLTClusterFitter(Char_t *path);
+  virtual ~AliHLTClusterFitter();
   
-  void Init(Int_t slice,Int_t patch,Int_t *rowrange,AliL3TrackArray *tracks);
+  void Init(Int_t slice,Int_t patch,Int_t *rowrange,AliHLTTrackArray *tracks);
   void Init(Int_t slice,Int_t patch);
   void LoadSeeds(Int_t *rowrange,Bool_t offline=kTRUE,Int_t eventnr=0,Float_t zvertex=0.0);
   void LoadLocalSegments();
@@ -32,10 +32,10 @@ class AliL3ClusterFitter : public AliL3Modeller {
   void SetOuterWidthFactor(Float_t y,Float_t z) {fYOuterWidthFactor=y; fZOuterWidthFactor=z;}
   
   Float_t GetYWidthFactor() const
-    {return fCurrentPadRow < AliL3Transform::GetLastRow(1) ? fYInnerWidthFactor : fYOuterWidthFactor;}
+    {return fCurrentPadRow < AliHLTTransform::GetLastRow(1) ? fYInnerWidthFactor : fYOuterWidthFactor;}
   Float_t GetZWidthFactor() const 
-    {return fCurrentPadRow < AliL3Transform::GetLastRow(1) ? fZInnerWidthFactor : fZOuterWidthFactor;}
-  AliL3TrackArray *GetSeeds() {return fSeeds;}
+    {return fCurrentPadRow < AliHLTTransform::GetLastRow(1) ? fZInnerWidthFactor : fZOuterWidthFactor;}
+  AliHLTTrackArray *GetSeeds() {return fSeeds;}
   
  private:
   Int_t fNmaxOverlaps; // Max number of overlaps
@@ -56,19 +56,21 @@ class AliL3ClusterFitter : public AliL3Modeller {
   Int_t fNMaxClusters; // Max number of clusters
   Int_t fNClusters; // umver of clusters
   Int_t fEvent; // Current event
-  AliL3TrackArray *fSeeds; //! Array of seed
-  AliL3TrackArray *fProcessTracks; //! Array of processed tracks
-  AliL3SpacePointData *fClusters; //! Array of clusters
+  AliHLTTrackArray *fSeeds; //! Array of seed
+  AliHLTTrackArray *fProcessTracks; //! Array of processed tracks
+  AliHLTSpacePointData *fClusters; //! Array of clusters
   
-  void FitClusters(AliL3ModelTrack *track,Int_t *padrange,Int_t *timerange);
+  void FitClusters(AliHLTModelTrack *track,Int_t *padrange,Int_t *timerange);
   Bool_t CheckCluster(Int_t trackindex);
   Bool_t IsMaximum(Int_t pad,Int_t time);
-  Bool_t SetFitRange(AliL3ModelTrack *track,Int_t *padrange,Int_t *timerange);
-  void SetClusterfitFalse(AliL3ModelTrack *track);
-  void CalculateWeightedMean(AliL3ModelTrack *track,Int_t *padrange,Int_t *timerange);
+  Bool_t SetFitRange(AliHLTModelTrack *track,Int_t *padrange,Int_t *timerange);
+  void SetClusterfitFalse(AliHLTModelTrack *track);
+  void CalculateWeightedMean(AliHLTModelTrack *track,Int_t *padrange,Int_t *timerange);
   
-  ClassDef(AliL3ClusterFitter,1) 
+  ClassDef(AliHLTClusterFitter,1) 
 
 };
 
+typedef AliHLTClusterFitter AliL3ClusterFitter; // for backward compatibility
+
 #endif
diff --git a/HLT/comp/AliHLTCompLinkDef.h b/HLT/comp/AliHLTCompLinkDef.h
new file mode 100644 (file)
index 0000000..7451f23
--- /dev/null
@@ -0,0 +1,42 @@
+// @(#) $Id$
+
+#ifdef __CINT__
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ typedef AliL3Modeller; 
+#ifndef macosx
+#pragma link C++ typedef AliL3ModelTrack; 
+#endif
+#pragma link C++ typedef AliL3Compress; 
+#pragma link C++ typedef AliL3CompressAC; 
+#pragma link C++ typedef AliL3ClusterFitter; 
+#pragma link C++ typedef AliL3DataCompressor; 
+#pragma link C++ typedef AliL3ClusterModel; 
+#ifndef macosx
+#pragma link C++ typedef AliL3DataCompressorHelper; 
+#endif
+#ifdef use_aliroot
+#pragma link C++ typedef AliL3OfflineDataCompressor; 
+#endif
+
+#pragma link C++ class AliHLTModeller; 
+#ifndef macosx
+#pragma link C++ class AliHLTModelTrack; 
+#endif
+#pragma link C++ class AliHLTCompress; 
+#pragma link C++ class AliHLTCompressAC; 
+#pragma link C++ class AliHLTClusterFitter; 
+#pragma link C++ class AliHLTDataCompressor; 
+#pragma link C++ class AliHLTClusterModel; 
+#ifndef macosx
+#pragma link C++ class AliHLTDataCompressorHelper; 
+#endif
+#ifdef use_aliroot
+#pragma link C++ class AliHLTOfflineDataCompressor; 
+#endif
+
+#endif
+
similarity index 63%
rename from HLT/comp/AliL3Compress.cxx
rename to HLT/comp/AliHLTCompress.cxx
index 2bbf8b9..b949734 100644 (file)
@@ -4,24 +4,24 @@
 //*-- Copyright &copy ALICE HLT Group
 //_____________________________________________________________
 //
-//  AliL3Compress
+//  AliHLTCompress
 //
 // Class for compressing and uncompressing data.
 
-#include "AliL3StandardIncludes.h"
+#include "AliHLTStandardIncludes.h"
 
 #include "bitio.h"
-#include "AliL3RootTypes.h"
-#include "AliL3Models.h"
-#include "AliL3DigitData.h"
-#include "AliL3Logging.h"
-#include "AliL3TrackArray.h"
-#include "AliL3ModelTrack.h"
-#include "AliL3Transform.h"
-#include "AliL3MemHandler.h"
-#include "AliL3DataCompressorHelper.h"
-#include "AliL3DataCompressor.h"
-#include "AliL3SpacePointData.h"
+#include "AliHLTRootTypes.h"
+#include "AliHLTModels.h"
+#include "AliHLTDigitData.h"
+#include "AliHLTLogging.h"
+#include "AliHLTTrackArray.h"
+#include "AliHLTModelTrack.h"
+#include "AliHLTTransform.h"
+#include "AliHLTMemHandler.h"
+#include "AliHLTDataCompressorHelper.h"
+#include "AliHLTDataCompressor.h"
+#include "AliHLTSpacePointData.h"
 
 #if 0
 #ifdef use_root
 #include <TRandom.h>
 #endif
 #ifdef use_aliroot
-#include "AliL3FileHandler.h"
+#include "AliHLTFileHandler.h"
 #endif
 #endif
 
-#include "AliL3Compress.h"
+#include "AliHLTCompress.h"
 
 #if __GNUC__ >= 3
 using namespace std;
 #endif
 
 
-ClassImp(AliL3Compress)
+ClassImp(AliHLTCompress)
 
-AliL3Compress::AliL3Compress()
+AliHLTCompress::AliHLTCompress()
 {
   // default constructor
   fTracks=0;
@@ -53,7 +53,7 @@ AliL3Compress::AliL3Compress()
   fEvent=-1;
 }
 
-AliL3Compress::AliL3Compress(Int_t slice,Int_t patch,Char_t *path,Bool_t writeshape,Int_t event)
+AliHLTCompress::AliHLTCompress(Int_t slice,Int_t patch,Char_t *path,Bool_t writeshape,Int_t event)
 {
   // constructor
   fEvent=event;
@@ -64,14 +64,14 @@ AliL3Compress::AliL3Compress(Int_t slice,Int_t patch,Char_t *path,Bool_t writesh
   fWriteShape=writeshape;
 }
 
-AliL3Compress::~AliL3Compress()
+AliHLTCompress::~AliHLTCompress()
 {
   // destructor
   if(fTracks)
     delete fTracks;
 }
 
-Bool_t AliL3Compress::WriteFile(AliL3TrackArray *tracks,Char_t *filename)
+Bool_t AliHLTCompress::WriteFile(AliHLTTrackArray *tracks,Char_t *filename)
 {
   // writes file
   Char_t fname[1024];
@@ -85,17 +85,17 @@ Bool_t AliL3Compress::WriteFile(AliL3TrackArray *tracks,Char_t *filename)
   FILE *file = fopen(fname,"w");
   if(!file)
     {
-      cerr<<"AliL3Compress::WriteFile : Error opening file "<<fname<<endl;
+      cerr<<"AliHLTCompress::WriteFile : Error opening file "<<fname<<endl;
       return kFALSE;
     }
   Short_t ntracks = tracks->GetNTracks();
     
   Int_t count=0;
-  AliL3ClusterModel *clusters=0;
-  AliL3TrackModel *model=0;
+  AliHLTClusterModel *clusters=0;
+  AliHLTTrackModel *model=0;
   for(Int_t i=0; i<ntracks; i++)
     {
-      AliL3ModelTrack *track = (AliL3ModelTrack*)tracks->GetCheckedTrack(i);
+      AliHLTModelTrack *track = (AliHLTModelTrack*)tracks->GetCheckedTrack(i);
       if(!track) continue;
 
       //Do not save useless tracks or clusters:
@@ -106,9 +106,9 @@ Bool_t AliL3Compress::WriteFile(AliL3TrackArray *tracks,Char_t *filename)
       model = track->GetModel();
       //if(model->fNClusters==0) continue;
       clusters = track->GetClusters();
-      if(fwrite(model,sizeof(AliL3TrackModel),1,file)!=1) break;
-      //if(fwrite(clusters,model->fNClusters*sizeof(AliL3ClusterModel),1,file)!=1) break;
-      if(fwrite(clusters,AliL3Transform::GetNRows(fPatch)*sizeof(AliL3ClusterModel),1,file)!=1) break;
+      if(fwrite(model,sizeof(AliHLTTrackModel),1,file)!=1) break;
+      //if(fwrite(clusters,model->fNClusters*sizeof(AliHLTClusterModel),1,file)!=1) break;
+      if(fwrite(clusters,AliHLTTransform::GetNRows(fPatch)*sizeof(AliHLTClusterModel),1,file)!=1) break;
       count++;
       
     }
@@ -116,7 +116,7 @@ Bool_t AliL3Compress::WriteFile(AliL3TrackArray *tracks,Char_t *filename)
   return kTRUE;
 }
 
-Bool_t AliL3Compress::ReadFile(Char_t which,Char_t *filename)
+Bool_t AliHLTCompress::ReadFile(Char_t which,Char_t *filename)
 {
   //Read the trackfile.
 
@@ -141,7 +141,7 @@ Bool_t AliL3Compress::ReadFile(Char_t which,Char_t *filename)
        }
       else
        {
-         cerr<<"AliL3Compress::ReadFile() : Wrong option"<<endl;
+         cerr<<"AliHLTCompress::ReadFile() : Wrong option"<<endl;
          return kFALSE;
        }
     }
@@ -149,23 +149,23 @@ Bool_t AliL3Compress::ReadFile(Char_t which,Char_t *filename)
   FILE *file = fopen(fname,"r");
   if(!file)
     {
-      cerr<<"AliL3Compress::ReadFile : Cannot open file "<<fname<<endl;
+      cerr<<"AliHLTCompress::ReadFile : Cannot open file "<<fname<<endl;
       return kFALSE;
     }
 
   if(fTracks)
     delete fTracks;
-  fTracks = new AliL3TrackArray("AliL3ModelTrack");
+  fTracks = new AliHLTTrackArray("AliHLTModelTrack");
   
   while(!feof(file))
     {
-      AliL3ModelTrack *track = (AliL3ModelTrack*)fTracks->NextTrack();
+      AliHLTModelTrack *track = (AliHLTModelTrack*)fTracks->NextTrack();
       track->Init(fSlice,fPatch);
-      AliL3TrackModel *model = track->GetModel();
-      AliL3ClusterModel *clusters = track->GetClusters();
-      if(fread(model,sizeof(AliL3TrackModel),1,file)!=1) break;
-      //if(fread(clusters,model->fNClusters*sizeof(AliL3ClusterModel),1,file)!=1) break;
-      if(fread(clusters,AliL3Transform::GetNRows(fPatch)*sizeof(AliL3ClusterModel),1,file)!=1) break;
+      AliHLTTrackModel *model = track->GetModel();
+      AliHLTClusterModel *clusters = track->GetClusters();
+      if(fread(model,sizeof(AliHLTTrackModel),1,file)!=1) break;
+      //if(fread(clusters,model->fNClusters*sizeof(AliHLTClusterModel),1,file)!=1) break;
+      if(fread(clusters,AliHLTTransform::GetNRows(fPatch)*sizeof(AliHLTClusterModel),1,file)!=1) break;
       track->FillTrack();
     }
 
@@ -174,7 +174,7 @@ Bool_t AliL3Compress::ReadFile(Char_t which,Char_t *filename)
   return kTRUE;
 }
 
-Bool_t AliL3Compress::CompressFile()
+Bool_t AliHLTCompress::CompressFile()
 {
   // compresses file
   Char_t fname[100];
@@ -192,12 +192,12 @@ Bool_t AliL3Compress::CompressFile()
   FILE *input = fopen(fname,"r");
   if(!input)
     {
-      cerr<<"AliL3Compress::CompressFile() : Error opening file: "<<fname<<endl;
+      cerr<<"AliHLTCompress::CompressFile() : Error opening file: "<<fname<<endl;
       return kFALSE;
     }
 
-  AliL3TrackModel track;
-  AliL3ClusterModel cluster;
+  AliHLTTrackModel track;
+  AliHLTClusterModel cluster;
   Int_t temp;
   Int_t power;
   
@@ -205,24 +205,24 @@ Bool_t AliL3Compress::CompressFile()
   timeo=pado=chargeo=padshapeo=timeshapeo=0;
   while(!feof(input))
     {
-      if(fread(&track,sizeof(AliL3TrackModel),1,input)!=1) break;
+      if(fread(&track,sizeof(AliHLTTrackModel),1,input)!=1) break;
       
       if(output->mask != 0x80) //Write the current byte to file.
        {
-         //cerr<<"\nAliL3Compress::CompressFile() : Writing overhead bits!!!"<<endl;
+         //cerr<<"\nAliHLTCompress::CompressFile() : Writing overhead bits!!!"<<endl;
          if(putc(output->rack,output->file )!=output->rack)
-           cerr<<"AliL3Compress::ComressFile : Error writing to bitfile"<<endl;
+           cerr<<"AliHLTCompress::ComressFile : Error writing to bitfile"<<endl;
          output->mask=0x80;
          output->rack=0;
        }
       
       //Write track parameters:
-      fwrite(&track,sizeof(AliL3TrackModel),1,output->file);
+      fwrite(&track,sizeof(AliHLTTrackModel),1,output->file);
       
       Int_t origslice=-1,slice,clustercount=0;
-      for(Int_t i=0; i<AliL3Transform::GetNRows(fPatch); i++)
+      for(Int_t i=0; i<AliHLTTransform::GetNRows(fPatch); i++)
        {
-         if(fread(&cluster,sizeof(AliL3ClusterModel),1,input)!=1) break;
+         if(fread(&cluster,sizeof(AliHLTClusterModel),1,input)!=1) break;
          
          //Write empty flag:
          temp = (Int_t)cluster.fPresent;
@@ -231,7 +231,7 @@ Bool_t AliL3Compress::CompressFile()
          
          if(cluster.fSlice<0 || cluster.fSlice>35)
            {
-             cerr<<"AliL3DataCompress::CompressFile : Fucked up slice number :"<<cluster.fSlice<<endl;
+             cerr<<"AliHLTDataCompress::CompressFile : Fucked up slice number :"<<cluster.fSlice<<endl;
              exit(5);
            }
          
@@ -260,14 +260,14 @@ Bool_t AliL3Compress::CompressFile()
            OutputBit(output,0);
          else
            OutputBit(output,1);
-         power = 1<<(AliL3DataCompressorHelper::GetNTimeBits()-1);
+         power = 1<<(AliHLTDataCompressorHelper::GetNTimeBits()-1);
          if(abs(temp)>=power)
            {
              //cout<<abs(temp)<<" "<<power<<endl;
              timeo++;
              temp=power - 1;
            }
-         OutputBits(output,abs(temp),(AliL3DataCompressorHelper::GetNTimeBits()-1));
+         OutputBits(output,abs(temp),(AliHLTDataCompressorHelper::GetNTimeBits()-1));
          
          //Write pad information:
          temp = (Int_t)rint(cluster.fDPad);
@@ -275,23 +275,23 @@ Bool_t AliL3Compress::CompressFile()
            OutputBit(output,0);
          else
            OutputBit(output,1);
-         power = 1<<(AliL3DataCompressorHelper::GetNPadBits()-1);
+         power = 1<<(AliHLTDataCompressorHelper::GetNPadBits()-1);
          if(abs(temp)>=power)
            {
              pado++;
              temp=power - 1;
            }
-         OutputBits(output,abs(temp),(AliL3DataCompressorHelper::GetNPadBits()-1));
+         OutputBits(output,abs(temp),(AliHLTDataCompressorHelper::GetNPadBits()-1));
          
          //Write charge information:
          temp = (Int_t)cluster.fDCharge;
-         power = 1<<(AliL3DataCompressorHelper::GetNChargeBits());
+         power = 1<<(AliHLTDataCompressorHelper::GetNChargeBits());
          if(abs(temp)>=power)
            {
              chargeo++;
              temp=power - 1;
            }
-         OutputBits(output,abs(temp),(AliL3DataCompressorHelper::GetNChargeBits()));
+         OutputBits(output,abs(temp),(AliHLTDataCompressorHelper::GetNChargeBits()));
          
          if(fWriteShape)
            {
@@ -301,26 +301,26 @@ Bool_t AliL3Compress::CompressFile()
                OutputBit(output,0);
              else
                OutputBit(output,1);
-             power = 1<<(AliL3DataCompressorHelper::GetNShapeBits()-1);
+             power = 1<<(AliHLTDataCompressorHelper::GetNShapeBits()-1);
              if(abs(temp) >= power)
                {
                  padshapeo++;
                  temp = power - 1;
                }
-             OutputBits(output,abs(temp),(AliL3DataCompressorHelper::GetNShapeBits()-1));
+             OutputBits(output,abs(temp),(AliHLTDataCompressorHelper::GetNShapeBits()-1));
              
              temp = (Int_t)rint(cluster.fDSigmaZ);
              if(temp<0)
                OutputBit(output,0);
              else
                OutputBit(output,1);
-             power = 1<<(AliL3DataCompressorHelper::GetNShapeBits()-1);
+             power = 1<<(AliHLTDataCompressorHelper::GetNShapeBits()-1);
              if(abs(temp) >= power)
                {
                  timeshapeo++;
                  temp=power - 1;
                }
-             OutputBits(output,abs(temp),(AliL3DataCompressorHelper::GetNShapeBits()-1));
+             OutputBits(output,abs(temp),(AliHLTDataCompressorHelper::GetNShapeBits()-1));
            }
          
          clustercount++;
@@ -341,7 +341,7 @@ Bool_t AliL3Compress::CompressFile()
   return kTRUE;
 }
 
-Bool_t AliL3Compress::ExpandFile()
+Bool_t AliHLTCompress::ExpandFile()
 {
   // expands file
   Char_t fname[100];
@@ -358,26 +358,26 @@ Bool_t AliL3Compress::ExpandFile()
   FILE *output = fopen(fname,"w");
   if(!output)
     {
-      cerr<<"AliL3Compress::ExpandFile() : Error opening file: "<<fname<<endl;
+      cerr<<"AliHLTCompress::ExpandFile() : Error opening file: "<<fname<<endl;
       return kFALSE;
     }
 
-  AliL3TrackModel trackmodel;
-  AliL3ClusterModel *clusters=0;
+  AliHLTTrackModel trackmodel;
+  AliHLTClusterModel *clusters=0;
   Int_t count=0;
   
-  clusters = new AliL3ClusterModel[(AliL3Transform::GetNRows(fPatch))];
+  clusters = new AliHLTClusterModel[(AliHLTTransform::GetNRows(fPatch))];
   while(!feof(input->file))
     {
       input->mask=0x80;//make sure we read a new byte from file.
       
       //Read and write track:
-      if(fread(&trackmodel,sizeof(AliL3TrackModel),1,input->file)!=1) break;
-      fwrite(&trackmodel,sizeof(AliL3TrackModel),1,output);
+      if(fread(&trackmodel,sizeof(AliHLTTrackModel),1,input->file)!=1) break;
+      fwrite(&trackmodel,sizeof(AliHLTTrackModel),1,output);
 
-      memset(clusters,0,AliL3Transform::GetNRows(fPatch)*sizeof(AliL3ClusterModel));
+      memset(clusters,0,AliHLTTransform::GetNRows(fPatch)*sizeof(AliHLTClusterModel));
       Int_t origslice=-1,clustercount=0;
-      for(Int_t i=0; i<AliL3Transform::GetNRows(fPatch); i++)
+      for(Int_t i=0; i<AliHLTTransform::GetNRows(fPatch); i++)
        {
          Int_t temp,sign;
          
@@ -412,33 +412,33 @@ Bool_t AliL3Compress::ExpandFile()
          
          //Read time information:
          sign=InputBit(input);
-         temp = InputBits(input,(AliL3DataCompressorHelper::GetNTimeBits()-1));
+         temp = InputBits(input,(AliHLTDataCompressorHelper::GetNTimeBits()-1));
          if(!sign)
            temp*=-1;
          clusters[i].fDTime = temp;
          
          //Read pad information:
          sign=InputBit(input);
-         temp = InputBits(input,(AliL3DataCompressorHelper::GetNPadBits()-1));
+         temp = InputBits(input,(AliHLTDataCompressorHelper::GetNPadBits()-1));
          if(!sign)
            temp*=-1;
          clusters[i].fDPad = temp;
          
          //Read charge information:
-         temp=InputBits(input,(AliL3DataCompressorHelper::GetNChargeBits()));
+         temp=InputBits(input,(AliHLTDataCompressorHelper::GetNChargeBits()));
          clusters[i].fDCharge = temp;
          
          if(fWriteShape)
            {
              //Read shape information:
              sign = InputBit(input);
-             temp = InputBits(input,(AliL3DataCompressorHelper::GetNShapeBits()-1));
+             temp = InputBits(input,(AliHLTDataCompressorHelper::GetNShapeBits()-1));
              if(!sign)
                temp*=-1;
              clusters[i].fDSigmaY = temp;
              
              sign = InputBit(input);
-             temp = InputBits(input,(AliL3DataCompressorHelper::GetNShapeBits()-1));
+             temp = InputBits(input,(AliHLTDataCompressorHelper::GetNShapeBits()-1));
              if(!sign)
                temp*=-1;
              clusters[i].fDSigmaZ = temp;
@@ -446,8 +446,8 @@ Bool_t AliL3Compress::ExpandFile()
          clustercount++;
        }
       count++;
-      //fwrite(clusters,(trackmodel.fNClusters)*sizeof(AliL3ClusterModel),1,output);
-      fwrite(clusters,AliL3Transform::GetNRows(fPatch)*sizeof(AliL3ClusterModel),1,output);
+      //fwrite(clusters,(trackmodel.fNClusters)*sizeof(AliHLTClusterModel),1,output);
+      fwrite(clusters,AliHLTTransform::GetNRows(fPatch)*sizeof(AliHLTClusterModel),1,output);
     }
   
   delete [] clusters;
@@ -456,12 +456,12 @@ Bool_t AliL3Compress::ExpandFile()
   return kTRUE;
 }
 
-void AliL3Compress::CompressRemaining(AliL3SpacePointData *clusters[36][6],UInt_t nclusters[36][6])
+void AliHLTCompress::CompressRemaining(AliHLTSpacePointData *clusters[36][6],UInt_t nclusters[36][6])
 {
   //Write the remaining clusters in a compressed format.
 
   Char_t filename[1024];
-  Int_t nrows = AliL3Transform::GetNRows();
+  Int_t nrows = AliHLTTransform::GetNRows();
   Int_t *npoints = new Int_t[nrows];
   for(Int_t slice=0; slice<=35; slice++)
     {
@@ -471,10 +471,10 @@ void AliL3Compress::CompressRemaining(AliL3SpacePointData *clusters[36][6],UInt_
          BIT_FILE *output = OpenOutputBitFile(filename);
          if(!output)
            {
-             cerr<<"AliL3Compress::CompressRemaining : Cannot open file "<<filename<<endl;
+             cerr<<"AliHLTCompress::CompressRemaining : Cannot open file "<<filename<<endl;
              exit(5);
            }
-         AliL3SpacePointData *cl = clusters[slice][patch];
+         AliHLTSpacePointData *cl = clusters[slice][patch];
          memset(npoints,0,nrows*sizeof(Int_t));
          
          UInt_t i;
@@ -503,7 +503,7 @@ void AliL3Compress::CompressRemaining(AliL3SpacePointData *clusters[36][6],UInt_
                  OutputBits(output,padrow,8);//Write padrow #
                  if(npoints[padrow] >= 1<<10)
                    {
-                     cerr<<"AliL3Compress::CompressRemaining : Too many remaining clusters "<<npoints[padrow]<<endl;
+                     cerr<<"AliHLTCompress::CompressRemaining : Too many remaining clusters "<<npoints[padrow]<<endl;
                      exit(5);
                    }
                  OutputBits(output,npoints[padrow],10);//Write number of clusters on this padrow
@@ -512,48 +512,48 @@ void AliL3Compress::CompressRemaining(AliL3SpacePointData *clusters[36][6],UInt_
              
              Float_t xyz[3] = {cl[i].fX,cl[i].fY,cl[i].fZ};
              Int_t sector,row,buff;
-             AliL3Transform::Slice2Sector(slice,padrow,sector,row);
-             AliL3Transform::Global2Raw(xyz,sector,row);
+             AliHLTTransform::Slice2Sector(slice,padrow,sector,row);
+             AliHLTTransform::Global2Raw(xyz,sector,row);
              
-             Float_t padw = sqrt(cl[i].fSigmaY2) / AliL3Transform::GetPadPitchWidth(AliL3Transform::GetPatch(padrow));
-             Float_t timew = sqrt(cl[i].fSigmaZ2) / AliL3Transform::GetZWidth();
+             Float_t padw = sqrt(cl[i].fSigmaY2) / AliHLTTransform::GetPadPitchWidth(AliHLTTransform::GetPatch(padrow));
+             Float_t timew = sqrt(cl[i].fSigmaZ2) / AliHLTTransform::GetZWidth();
              
              //Check for saturation in the widths.
              //Basically only store a certain number of decimals here, and cut the widths which is higher:
-             if(padw >= (1<<AliL3DataCompressorHelper::GetNShapeBitsRemaining()) / AliL3DataCompressorHelper::GetPadPrecisionFactor())
-               padw = (1<<AliL3DataCompressorHelper::GetNShapeBitsRemaining()) / AliL3DataCompressorHelper::GetPadPrecisionFactor() - 1/AliL3DataCompressorHelper::GetPadPrecisionFactor();
-             if(timew >= (1<<AliL3DataCompressorHelper::GetNShapeBitsRemaining()) / AliL3DataCompressorHelper::GetTimePrecisionFactor())
-               timew = (1<<AliL3DataCompressorHelper::GetNShapeBitsRemaining()) / AliL3DataCompressorHelper::GetTimePrecisionFactor() - 1/AliL3DataCompressorHelper::GetTimePrecisionFactor();;
+             if(padw >= (1<<AliHLTDataCompressorHelper::GetNShapeBitsRemaining()) / AliHLTDataCompressorHelper::GetPadPrecisionFactor())
+               padw = (1<<AliHLTDataCompressorHelper::GetNShapeBitsRemaining()) / AliHLTDataCompressorHelper::GetPadPrecisionFactor() - 1/AliHLTDataCompressorHelper::GetPadPrecisionFactor();
+             if(timew >= (1<<AliHLTDataCompressorHelper::GetNShapeBitsRemaining()) / AliHLTDataCompressorHelper::GetTimePrecisionFactor())
+               timew = (1<<AliHLTDataCompressorHelper::GetNShapeBitsRemaining()) / AliHLTDataCompressorHelper::GetTimePrecisionFactor() - 1/AliHLTDataCompressorHelper::GetTimePrecisionFactor();;
              
              //Write pad
-             buff = (Int_t)rint(xyz[1]*AliL3DataCompressorHelper::GetPadPrecisionFactor());
+             buff = (Int_t)rint(xyz[1]*AliHLTDataCompressorHelper::GetPadPrecisionFactor());
              if(buff<0)
                {
-                 cerr<<"AliL3Compress:CompressRemaining : Wrong pad value "<<buff<<endl;
+                 cerr<<"AliHLTCompress:CompressRemaining : Wrong pad value "<<buff<<endl;
                  exit(5);
                }
-             OutputBits(output,buff,AliL3DataCompressorHelper::GetNPadBitsRemaining());
+             OutputBits(output,buff,AliHLTDataCompressorHelper::GetNPadBitsRemaining());
              
              //Write time
-             buff = (Int_t)rint(xyz[2]*AliL3DataCompressorHelper::GetTimePrecisionFactor());
+             buff = (Int_t)rint(xyz[2]*AliHLTDataCompressorHelper::GetTimePrecisionFactor());
              if(buff<0)
                {
-                 cerr<<"AliL3Compress:CompressRemaining : Wrong time value "<<buff<<endl;
+                 cerr<<"AliHLTCompress:CompressRemaining : Wrong time value "<<buff<<endl;
                  exit(5);
                }
-             OutputBits(output,buff,AliL3DataCompressorHelper::GetNTimeBitsRemaining());
+             OutputBits(output,buff,AliHLTDataCompressorHelper::GetNTimeBitsRemaining());
              
              //Write widths
-             buff = (Int_t)rint(padw*AliL3DataCompressorHelper::GetPadPrecisionFactor());
-             OutputBits(output,buff,AliL3DataCompressorHelper::GetNShapeBitsRemaining());
-             buff = (Int_t)rint(timew*AliL3DataCompressorHelper::GetTimePrecisionFactor());
-             OutputBits(output,buff,AliL3DataCompressorHelper::GetNShapeBitsRemaining());
+             buff = (Int_t)rint(padw*AliHLTDataCompressorHelper::GetPadPrecisionFactor());
+             OutputBits(output,buff,AliHLTDataCompressorHelper::GetNShapeBitsRemaining());
+             buff = (Int_t)rint(timew*AliHLTDataCompressorHelper::GetTimePrecisionFactor());
+             OutputBits(output,buff,AliHLTDataCompressorHelper::GetNShapeBitsRemaining());
              
              //Write charge 
              buff = cl[i].fCharge;
-             if(buff >= 1<<(AliL3DataCompressorHelper::GetNChargeBits()))
-               buff = (1<<(AliL3DataCompressorHelper::GetNChargeBits()))-1;
-             OutputBits(output,buff,AliL3DataCompressorHelper::GetNChargeBits());
+             if(buff >= 1<<(AliHLTDataCompressorHelper::GetNChargeBits()))
+               buff = (1<<(AliHLTDataCompressorHelper::GetNChargeBits()))-1;
+             OutputBits(output,buff,AliHLTDataCompressorHelper::GetNChargeBits());
            }
          
          CloseOutputBitFile(output);
@@ -563,7 +563,7 @@ void AliL3Compress::CompressRemaining(AliL3SpacePointData *clusters[36][6],UInt_
   delete [] npoints;
 }
 
-void AliL3Compress::ExpandRemaining(TempCluster **clusters,Int_t *ncl, Int_t /*maxpoints*/)
+void AliHLTCompress::ExpandRemaining(TempCluster **clusters,Int_t *ncl, Int_t /*maxpoints*/)
 {
   //Expand the remaining clusters stored using function CompressRemaining
   
@@ -595,21 +595,21 @@ void AliL3Compress::ExpandRemaining(TempCluster **clusters,Int_t *ncl, Int_t /*m
                  clusters[slice][ncl[slice]].fPadrow = padrow;
 
                  //Read pad
-                 buff = InputBits(input,AliL3DataCompressorHelper::GetNPadBitsRemaining());
-                 clusters[slice][ncl[slice]].fPad = (Float_t)buff/AliL3DataCompressorHelper::GetPadPrecisionFactor();
+                 buff = InputBits(input,AliHLTDataCompressorHelper::GetNPadBitsRemaining());
+                 clusters[slice][ncl[slice]].fPad = (Float_t)buff/AliHLTDataCompressorHelper::GetPadPrecisionFactor();
                  
                  //Read time
-                 buff = InputBits(input,AliL3DataCompressorHelper::GetNTimeBitsRemaining());
-                 clusters[slice][ncl[slice]].fTime = (Float_t)buff/AliL3DataCompressorHelper::GetTimePrecisionFactor();
+                 buff = InputBits(input,AliHLTDataCompressorHelper::GetNTimeBitsRemaining());
+                 clusters[slice][ncl[slice]].fTime = (Float_t)buff/AliHLTDataCompressorHelper::GetTimePrecisionFactor();
                  
                  //Read widths 
-                 buff = InputBits(input,AliL3DataCompressorHelper::GetNShapeBitsRemaining());
-                 clusters[slice][ncl[slice]].fSigmaY2 = pow((Float_t)buff/AliL3DataCompressorHelper::GetPadPrecisionFactor(),2);
-                 buff = InputBits(input,AliL3DataCompressorHelper::GetNShapeBitsRemaining());
-                 clusters[slice][ncl[slice]].fSigmaZ2 = pow((Float_t)buff/AliL3DataCompressorHelper::GetPadPrecisionFactor(),2);
+                 buff = InputBits(input,AliHLTDataCompressorHelper::GetNShapeBitsRemaining());
+                 clusters[slice][ncl[slice]].fSigmaY2 = pow((Float_t)buff/AliHLTDataCompressorHelper::GetPadPrecisionFactor(),2);
+                 buff = InputBits(input,AliHLTDataCompressorHelper::GetNShapeBitsRemaining());
+                 clusters[slice][ncl[slice]].fSigmaZ2 = pow((Float_t)buff/AliHLTDataCompressorHelper::GetPadPrecisionFactor(),2);
                  
                  //Read charge
-                 buff = InputBits(input,AliL3DataCompressorHelper::GetNChargeBits());
+                 buff = InputBits(input,AliHLTDataCompressorHelper::GetNChargeBits());
                  clusters[slice][ncl[slice]].fCharge = buff;
                  
                  ncl[slice]++;
@@ -621,10 +621,10 @@ void AliL3Compress::ExpandRemaining(TempCluster **clusters,Int_t *ncl, Int_t /*m
     }
 }
 
-void AliL3Compress::PrintCompRatio(ofstream *outfile)
+void AliHLTCompress::PrintCompRatio(ofstream *outfile)
 {
   // prints the compression ratio
-  AliL3MemHandler *mem = new AliL3MemHandler();
+  AliHLTMemHandler *mem = new AliHLTMemHandler();
   Char_t fname[1024];
   UInt_t remainSize=0,digitSize=0;
   for(Int_t i=0; i<36; i++)
@@ -655,13 +655,13 @@ void AliL3Compress::PrintCompRatio(ofstream *outfile)
   
   if(digitSize==0)
     {
-      cerr<<"AliL3Compress::PrintCompRatio : Zero digit size, not able to obtain comp. ratios!"<<endl;
+      cerr<<"AliHLTCompress::PrintCompRatio : Zero digit size, not able to obtain comp. ratios!"<<endl;
       return;
     }
   
   Float_t compratio = (Float_t)(compressSize + remainSize)/(Float_t)digitSize;
   Float_t entropy[3];
-  Int_t trackSize = GetEntropy(entropy[0],entropy[1],entropy[2])*sizeof(AliL3TrackModel);
+  Int_t trackSize = GetEntropy(entropy[0],entropy[1],entropy[2])*sizeof(AliHLTTrackModel);
   if(outfile)
     {
       ofstream &out = *outfile;
@@ -680,7 +680,7 @@ void AliL3Compress::PrintCompRatio(ofstream *outfile)
   cout<<"Entropy of residuals : "<<entropy[0]<<" "<<entropy[1]<<endl;
 }
 
-Int_t AliL3Compress::GetEntropy(Float_t &padEntropy,Float_t &timeEntropy,Float_t &chargeEntropy)
+Int_t AliHLTCompress::GetEntropy(Float_t &padEntropy,Float_t &timeEntropy,Float_t &chargeEntropy)
 {
   //Calculate the entropy of the quantized residuals in both directions
   
@@ -697,9 +697,9 @@ Int_t AliL3Compress::GetEntropy(Float_t &padEntropy,Float_t &timeEntropy,Float_t
 
   for(Int_t i=0; i<fTracks->GetNTracks(); i++)
     {
-      AliL3ModelTrack *track = (AliL3ModelTrack*)fTracks->GetCheckedTrack(i);
+      AliHLTModelTrack *track = (AliHLTModelTrack*)fTracks->GetCheckedTrack(i);
       if(!track) continue;
-      for(Int_t padrow=0; padrow<AliL3Transform::GetNRows(); padrow++)
+      for(Int_t padrow=0; padrow<AliHLTTransform::GetNRows(); padrow++)
        {
          if(!track->IsPresent(padrow)) continue;
          Int_t dpad = abs((Int_t)rint(track->GetClusterModel(padrow)->fDPad));
@@ -707,7 +707,7 @@ Int_t AliL3Compress::GetEntropy(Float_t &padEntropy,Float_t &timeEntropy,Float_t
          Int_t dcharge = (Int_t)track->GetClusterModel(padrow)->fDCharge;
          if(dpad >= knmax || dtime >= knmax || dcharge >= knmax)
            {
-             cerr<<"AliL3Compress::GetEntropy : Quantization out of range: "<<dpad<<" "<<dtime<<" "<<dcharge<<endl;
+             cerr<<"AliHLTCompress::GetEntropy : Quantization out of range: "<<dpad<<" "<<dtime<<" "<<dcharge<<endl;
              break;
            }
          pads[dpad]++;
diff --git a/HLT/comp/AliHLTCompress.h b/HLT/comp/AliHLTCompress.h
new file mode 100644 (file)
index 0000000..92cae5d
--- /dev/null
@@ -0,0 +1,43 @@
+// @(#) $Id$
+
+#ifndef AliHLT_Compress
+#define AliHLT_Compress
+
+#include "AliHLTRootTypes.h"
+#include "AliHLTStandardIncludes.h"
+#include "AliHLTDataCompressor.h"
+
+class AliHLTCompress {
+  
+ public:
+  AliHLTCompress();
+  AliHLTCompress(Int_t slice,Int_t patch,Char_t *path="./",Bool_t writeshape=kFALSE,Int_t event=-1);
+  virtual ~AliHLTCompress();
+  
+  Bool_t WriteFile(AliHLTTrackArray *tracks,Char_t *filename=0);
+  Bool_t ReadFile(Char_t which,Char_t *filename=0);
+  virtual Bool_t CompressFile();
+  virtual Bool_t ExpandFile();
+  void CompressRemaining(AliHLTSpacePointData *points[36][6],UInt_t npoints[36][6]);
+  void ExpandRemaining(TempCluster **clusters,Int_t *ncl,Int_t maxclusters);
+  virtual void PrintCompRatio(STDOF *outfile=0);
+  Int_t GetEntropy(Float_t &padEntropy,Float_t &timeEntropy,Float_t &chargeEntropy);
+  
+  AliHLTTrackArray *GetTracks() {return fTracks;}
+  
+ protected:
+  AliHLTTrackArray *fTracks; //! Array of tracks
+  Int_t fSlice; // Slice
+  Int_t fPatch; // Patch
+  Char_t fPath[100]; // Path to the files
+  Bool_t fWriteShape; // Flag to write the shape
+  Int_t fEvent; // Current event
+
+  
+  ClassDef(AliHLTCompress,1) 
+
+};
+
+typedef AliHLTCompress AliL3Compress; // for backward compatibility
+
+#endif
similarity index 76%
rename from HLT/comp/AliL3CompressAC.cxx
rename to HLT/comp/AliHLTCompressAC.cxx
index 368bc2a..6fb57ac 100644 (file)
@@ -4,7 +4,7 @@
 //*-- Copyright &copy ALICE HLT Group
 //_____________________________________________________________
 //
-//  AliL3CompressAC
+//  AliHLTCompressAC
 //
 // Compression class which performs Arithmetic Coding of the quantized residuals.
 // The implemented algorithm is inspired by the examples in The Data Compression Book 
 using namespace std;
 #endif
 
-#include "AliL3StandardIncludes.h"
-#include "AliL3TrackArray.h"
-#include "AliL3ModelTrack.h"
-#include "AliL3Transform.h"
-#include "AliL3MemHandler.h"
-#include "AliL3Compress.h"
-#include "AliL3DataCompressorHelper.h"
-#include "AliL3CompressAC.h"
+#include "AliHLTStandardIncludes.h"
+#include "AliHLTTrackArray.h"
+#include "AliHLTModelTrack.h"
+#include "AliHLTTransform.h"
+#include "AliHLTMemHandler.h"
+#include "AliHLTCompress.h"
+#include "AliHLTDataCompressorHelper.h"
+#include "AliHLTCompressAC.h"
 
 
-ClassImp(AliL3CompressAC)
+ClassImp(AliHLTCompressAC)
 
-AliL3CompressAC::AliL3CompressAC()
+AliHLTCompressAC::AliHLTCompressAC()
 {
   // default constructor
   fCount=0;
@@ -39,8 +39,8 @@ AliL3CompressAC::AliL3CompressAC()
   fCode=0;
 }
 
-AliL3CompressAC::AliL3CompressAC(Int_t slice,Int_t patch,Char_t *path,Bool_t writeshape,Int_t event) :
-  AliL3Compress(slice,patch,path,writeshape,event)
+AliHLTCompressAC::AliHLTCompressAC(Int_t slice,Int_t patch,Char_t *path,Bool_t writeshape,Int_t event) :
+  AliHLTCompress(slice,patch,path,writeshape,event)
 {
   // constructor
   fCount=0;
@@ -53,13 +53,13 @@ AliL3CompressAC::AliL3CompressAC(Int_t slice,Int_t patch,Char_t *path,Bool_t wri
   fCode=0;
 }
 
-AliL3CompressAC::~AliL3CompressAC()
+AliHLTCompressAC::~AliHLTCompressAC()
 {
   // destructor
   ClearArrays();
 }
 
-void AliL3CompressAC::ClearArrays()
+void AliHLTCompressAC::ClearArrays()
 {
   // cleans all arrays
   fMax=0;
@@ -69,7 +69,7 @@ void AliL3CompressAC::ClearArrays()
     delete [] fTotals;
 }
 
-void AliL3CompressAC::BuildModel(BIT_FILE *output)
+void AliHLTCompressAC::BuildModel(BIT_FILE *output)
 {
   //Build the model from the input data, i.e. probability distributions of the quantized residuals.
   
@@ -80,18 +80,18 @@ void AliL3CompressAC::BuildModel(BIT_FILE *output)
   UInt_t * temp = new UInt_t[nmax];
   memset(&temp[0],0,nmax*sizeof(UInt_t));
 
-  AliL3TrackArray *tracks = GetTracks();
+  AliHLTTrackArray *tracks = GetTracks();
   for(Int_t t=0; t<tracks->GetNTracks(); t++)
     {
-      AliL3ModelTrack *track = (AliL3ModelTrack*)tracks->GetCheckedTrack(t);
+      AliHLTModelTrack *track = (AliHLTModelTrack*)tracks->GetCheckedTrack(t);
       if(!track) continue;
-      for(Int_t padrow=0; padrow<AliL3Transform::GetNRows(); padrow++)
+      for(Int_t padrow=0; padrow<AliHLTTransform::GetNRows(); padrow++)
        {
          if(!track->IsPresent(padrow)) continue;
          qres = abs((Int_t)rint(track->GetClusterModel(padrow)->fDPad));
          if(qres >= nmax)
            {
-             cerr<<"AliL3CompressAC::BuildModel() : Residual values seems way too big!"<<endl;
+             cerr<<"AliHLTCompressAC::BuildModel() : Residual values seems way too big!"<<endl;
              continue;
            }
          if(qres > fMax)
@@ -143,7 +143,7 @@ void AliL3CompressAC::BuildModel(BIT_FILE *output)
   delete [] temp;
 }
 
-void AliL3CompressAC::RebuildModel(BIT_FILE *input)
+void AliHLTCompressAC::RebuildModel(BIT_FILE *input)
 {
   //Rebuild the model from the counts written to the beginning of the compressed file.
   
@@ -154,11 +154,11 @@ void AliL3CompressAC::RebuildModel(BIT_FILE *input)
   FillTotals();
 }
 
-void AliL3CompressAC::FillTotals()
+void AliHLTCompressAC::FillTotals()
 {
   //Fill the array of totals, which is actually the model being used during encoding/decoding.
   if(fMax == 0)
-    cerr<<"AliL3CompressAC::FillTotals : max value is zero!"<<endl;
+    cerr<<"AliHLTCompressAC::FillTotals : max value is zero!"<<endl;
 
   fTotals = new UInt_t[fMax+3];//up to max, and one reserved for endofstream symbol
   
@@ -171,7 +171,7 @@ void AliL3CompressAC::FillTotals()
   fTotals[fMax+2] = fTotals[fMax+1]+1;//Used for the scale
 }
 
-void AliL3CompressAC::PrintTotals() const
+void AliHLTCompressAC::PrintTotals() const
 {
   // prints totals
   cout<<"Totals:"<<endl;
@@ -181,7 +181,7 @@ void AliL3CompressAC::PrintTotals() const
     }
 }
 
-void AliL3CompressAC::InitEncoder()
+void AliHLTCompressAC::InitEncoder()
 {
   // inits the encoder
   fLow = 0;
@@ -189,7 +189,7 @@ void AliL3CompressAC::InitEncoder()
   fUnderflowBits=0;
 }
 
-void AliL3CompressAC::InitDecoder(BIT_FILE *input)
+void AliHLTCompressAC::InitDecoder(BIT_FILE *input)
 {
   // inits the decoder
   fCode=0;
@@ -202,7 +202,7 @@ void AliL3CompressAC::InitDecoder(BIT_FILE *input)
   fHigh = 0xffff;
 }
 
-void AliL3CompressAC::ConvertIntToSymbol(Int_t value)
+void AliHLTCompressAC::ConvertIntToSymbol(Int_t value)
 {
   // converst integer to symbol
   UInt_t range = fHigh - fLow + 1;
@@ -210,7 +210,7 @@ void AliL3CompressAC::ConvertIntToSymbol(Int_t value)
   fLow = fLow + (UShort_t)((range*fTotals[value])/fTotals[fMax+2]);
 }
 
-UInt_t AliL3CompressAC::ConvertSymbolToInt()
+UInt_t AliHLTCompressAC::ConvertSymbolToInt()
 {
   // converts symbol to integer
   UInt_t range = (UInt_t)(fHigh-fLow) + 1;
@@ -222,7 +222,7 @@ UInt_t AliL3CompressAC::ConvertSymbolToInt()
   return j;
 }
 
-void AliL3CompressAC::EncodeSymbol(BIT_FILE *output)
+void AliHLTCompressAC::EncodeSymbol(BIT_FILE *output)
 {
   // encodes symbol
   while(1)
@@ -250,7 +250,7 @@ void AliL3CompressAC::EncodeSymbol(BIT_FILE *output)
     }
 }
 
-void AliL3CompressAC::RemoveSymbolFromStream(BIT_FILE *input,Int_t j)
+void AliHLTCompressAC::RemoveSymbolFromStream(BIT_FILE *input,Int_t j)
 {
   // remves symbol fro stream
   UInt_t range = (UInt_t)(fHigh-fLow)+1;
@@ -276,7 +276,7 @@ void AliL3CompressAC::RemoveSymbolFromStream(BIT_FILE *input,Int_t j)
     }
 }
 
-void AliL3CompressAC::FlushEncoder(BIT_FILE *output)
+void AliHLTCompressAC::FlushEncoder(BIT_FILE *output)
 {
   //Flush the encoder:
   OutputBit(output,fLow & 0x4000);
@@ -287,7 +287,7 @@ void AliL3CompressAC::FlushEncoder(BIT_FILE *output)
 }
 
 
-Bool_t AliL3CompressAC::CompressFile()
+Bool_t AliHLTCompressAC::CompressFile()
 {
   // comresses file
   Char_t fname[100];
@@ -305,24 +305,24 @@ Bool_t AliL3CompressAC::CompressFile()
   FILE *input = fopen(fname,"r");
   if(!input)
     {
-      cerr<<"AliL3CompressAC::CompressFileAC() : Error opening file: "<<fname<<endl;
+      cerr<<"AliHLTCompressAC::CompressFileAC() : Error opening file: "<<fname<<endl;
       return kFALSE;
     }
   
   BuildModel(output);
 
-  AliL3TrackModel track;
+  AliHLTTrackModel track;
   Int_t temp,power,i,j;
   
   fseek(input,0,SEEK_END);
   UInt_t size = ftell(input);
   rewind(input);
-  Int_t trackcount = size/(sizeof(AliL3TrackModel) + sizeof(AliL3ClusterModel)*AliL3Transform::GetNRows(fPatch));
+  Int_t trackcount = size/(sizeof(AliHLTTrackModel) + sizeof(AliHLTClusterModel)*AliHLTTransform::GetNRows(fPatch));
   
   //Write the number of tracks in the beginning of stream.
   fwrite(&trackcount,sizeof(Int_t),1,output->file);
   
-  AliL3ClusterModel **clusters = new AliL3ClusterModel*[trackcount];
+  AliHLTClusterModel **clusters = new AliHLTClusterModel*[trackcount];
   Int_t *clustercount = new Int_t[trackcount];
   i=0;
   
@@ -330,19 +330,19 @@ Bool_t AliL3CompressAC::CompressFile()
   //Store the clusters in memory for later encoding and storing.
   while(!feof(input))
     {
-      if(fread(&track,sizeof(AliL3TrackModel),1,input)!=1) break;
-      fwrite(&track,sizeof(AliL3TrackModel),1,output->file);
+      if(fread(&track,sizeof(AliHLTTrackModel),1,input)!=1) break;
+      fwrite(&track,sizeof(AliHLTTrackModel),1,output->file);
       
-      clusters[i] = new AliL3ClusterModel[AliL3Transform::GetNRows()];
+      clusters[i] = new AliHLTClusterModel[AliHLTTransform::GetNRows()];
       clustercount[i]=0;
       
       //Read in the clusters:
-      fread(clusters[i],sizeof(AliL3ClusterModel),AliL3Transform::GetNRows(fPatch),input);
+      fread(clusters[i],sizeof(AliHLTClusterModel),AliHLTTransform::GetNRows(fPatch),input);
       i++;
     }
   if(i != trackcount)
     {
-      cerr<<"AliL3CompressAC::CompressFile : Mismatching file size and trackcount "<<i<<" "<<trackcount<<endl;
+      cerr<<"AliHLTCompressAC::CompressFile : Mismatching file size and trackcount "<<i<<" "<<trackcount<<endl;
       exit(5);
     }
   fclose(input);
@@ -351,7 +351,7 @@ Bool_t AliL3CompressAC::CompressFile()
   for(i=0; i<trackcount; i++)
     {
       Int_t origslice=-1,slice;
-      for(j=0; j<AliL3Transform::GetNRows(fPatch); j++)
+      for(j=0; j<AliHLTTransform::GetNRows(fPatch); j++)
        {
          temp = (Int_t)clusters[i][j].fPresent;
          OutputBit(output,temp);
@@ -359,7 +359,7 @@ Bool_t AliL3CompressAC::CompressFile()
          
          if(clusters[i][j].fSlice<0 || clusters[i][j].fSlice>35)
            {
-             cerr<<"AliL3DataCompress::CompressFile : Fucked up slice number :"<<clusters[i][j].fSlice<<endl;
+             cerr<<"AliHLTDataCompress::CompressFile : Fucked up slice number :"<<clusters[i][j].fSlice<<endl;
              exit(5);
            }
          
@@ -399,12 +399,12 @@ Bool_t AliL3CompressAC::CompressFile()
          
          //Write charge information:
          temp = (Int_t)clusters[i][j].fDCharge;
-         power = 1<<(AliL3DataCompressorHelper::GetNChargeBits());
+         power = 1<<(AliHLTDataCompressorHelper::GetNChargeBits());
          if(abs(temp)>=power)
            {
              temp=power - 1;
            }
-         OutputBits(output,abs(temp),(AliL3DataCompressorHelper::GetNChargeBits()));
+         OutputBits(output,abs(temp),(AliHLTDataCompressorHelper::GetNChargeBits()));
 
          //Write sign information of the residuals:
          temp = (Int_t)rint(clusters[i][j].fDTime);
@@ -426,24 +426,24 @@ Bool_t AliL3CompressAC::CompressFile()
                OutputBit(output,0);
              else
                OutputBit(output,1);
-             power = 1<<(AliL3DataCompressorHelper::GetNShapeBits()-1);
+             power = 1<<(AliHLTDataCompressorHelper::GetNShapeBits()-1);
              if(abs(temp) >= power)
                {
                  temp = power - 1;
                }
-             OutputBits(output,abs(temp),(AliL3DataCompressorHelper::GetNShapeBits()-1));
+             OutputBits(output,abs(temp),(AliHLTDataCompressorHelper::GetNShapeBits()-1));
              
              temp = (Int_t)rint(clusters[i][j].fDSigmaZ);
              if(temp<0)
                OutputBit(output,0);
              else
                OutputBit(output,1);
-             power = 1<<(AliL3DataCompressorHelper::GetNShapeBits()-1);
+             power = 1<<(AliHLTDataCompressorHelper::GetNShapeBits()-1);
              if(abs(temp) >= power)
                {
                  temp=power - 1;
                }
-             OutputBits(output,abs(temp),(AliL3DataCompressorHelper::GetNShapeBits()-1));
+             OutputBits(output,abs(temp),(AliHLTDataCompressorHelper::GetNShapeBits()-1));
            }
          clustercount[i]++;
        }
@@ -458,7 +458,7 @@ Bool_t AliL3CompressAC::CompressFile()
     {
       Int_t counter=0;
       
-      for(j=0; j<AliL3Transform::GetNRows(fPatch); j++)
+      for(j=0; j<AliHLTTransform::GetNRows(fPatch); j++)
        {
          if(!clusters[i][j].fPresent) continue;
          temp = abs((Int_t)rint(clusters[i][j].fDTime));
@@ -472,7 +472,7 @@ Bool_t AliL3CompressAC::CompressFile()
        }
       if(counter != clustercount[i])
        {
-         cerr<<"AliL3CompressAC::CompressFile : Mismatching clustercount "<<counter<<" "<<clustercount[i]<<endl;
+         cerr<<"AliHLTCompressAC::CompressFile : Mismatching clustercount "<<counter<<" "<<clustercount[i]<<endl;
          exit(5);
        }
 
@@ -494,7 +494,7 @@ Bool_t AliL3CompressAC::CompressFile()
   return kTRUE;
 }
 
-Bool_t AliL3CompressAC::ExpandFile()
+Bool_t AliHLTCompressAC::ExpandFile()
 {
   // expands file
   Char_t fname[100];
@@ -511,7 +511,7 @@ Bool_t AliL3CompressAC::ExpandFile()
   FILE *output = fopen(fname,"w");
   if(!output)
     {
-      cerr<<"AliL3Compress::ExpandFile() : Error opening file: "<<fname<<endl;
+      cerr<<"AliHLTCompress::ExpandFile() : Error opening file: "<<fname<<endl;
       return kFALSE;
     }
   
@@ -520,21 +520,21 @@ Bool_t AliL3CompressAC::ExpandFile()
   int trackcount,i,j;
   fread(&trackcount,sizeof(Int_t),1,input->file);
 
-  AliL3TrackModel *trackmodels = new AliL3TrackModel[trackcount];
-  AliL3ClusterModel **clusters = new AliL3ClusterModel*[trackcount];
+  AliHLTTrackModel *trackmodels = new AliHLTTrackModel[trackcount];
+  AliHLTClusterModel **clusters = new AliHLTClusterModel*[trackcount];
   Int_t *clustercount = new Int_t[trackcount];
 
-  fread(trackmodels,sizeof(AliL3TrackModel),trackcount,input->file);
+  fread(trackmodels,sizeof(AliHLTTrackModel),trackcount,input->file);
   
   for(i=0; i<trackcount; i++)
     {
-      clusters[i] = new AliL3ClusterModel[AliL3Transform::GetNRows(fPatch)];
+      clusters[i] = new AliHLTClusterModel[AliHLTTransform::GetNRows(fPatch)];
       clustercount[i]=0;
 
       //Read the fixed size variables:
       Int_t origslice=-1;
       Int_t temp,sign;
-      for(j=0; j<AliL3Transform::GetNRows(fPatch); j++)
+      for(j=0; j<AliHLTTransform::GetNRows(fPatch); j++)
        {
          //Read empty flag:
          temp = InputBit(input);
@@ -580,7 +580,7 @@ Bool_t AliL3CompressAC::ExpandFile()
                    }
                  if(origslice < 0 || origslice > 35)
                    {
-                     cerr<<"AliL3CompressAC::ExpandFile : Bad slice number "<<temp<<endl;
+                     cerr<<"AliHLTCompressAC::ExpandFile : Bad slice number "<<temp<<endl;
                      exit(5);
                    }
                  clusters[i][j].fSlice = origslice;
@@ -588,7 +588,7 @@ Bool_t AliL3CompressAC::ExpandFile()
            }
          
          //Read charge information:
-         temp=InputBits(input,(AliL3DataCompressorHelper::GetNChargeBits()));
+         temp=InputBits(input,(AliHLTDataCompressorHelper::GetNChargeBits()));
          clusters[i][j].fDCharge = temp;
          
          //Read sign information of the residuals:
@@ -607,13 +607,13 @@ Bool_t AliL3CompressAC::ExpandFile()
          if(fWriteShape)
            {
              sign = InputBit(input);
-             temp = InputBits(input,(AliL3DataCompressorHelper::GetNShapeBits()-1));
+             temp = InputBits(input,(AliHLTDataCompressorHelper::GetNShapeBits()-1));
              if(!sign)
                temp*=-1;
              clusters[i][j].fDSigmaY = temp;
              
              sign = InputBit(input);
-             temp = InputBits(input,(AliL3DataCompressorHelper::GetNShapeBits()-1));
+             temp = InputBits(input,(AliHLTDataCompressorHelper::GetNShapeBits()-1));
              if(!sign)
                temp*=-1;
              clusters[i][j].fDSigmaZ = temp;
@@ -628,7 +628,7 @@ Bool_t AliL3CompressAC::ExpandFile()
   for(i=0; i<trackcount; i++)
     {
       Int_t count=0;
-      for(j=0; j<AliL3Transform::GetNRows(fPatch); j++)
+      for(j=0; j<AliHLTTransform::GetNRows(fPatch); j++)
        {
          if(!clusters[i][j].fPresent) continue;
            
@@ -644,7 +644,7 @@ Bool_t AliL3CompressAC::ExpandFile()
 
       if(count != clustercount[i])
        {
-         cerr<<"AliL3CompressAC::ExpandFile : Mismatching clustercount "<<count<<" "<<clustercount[i]<<endl;
+         cerr<<"AliHLTCompressAC::ExpandFile : Mismatching clustercount "<<count<<" "<<clustercount[i]<<endl;
          exit(5);
        }
     }
@@ -652,15 +652,15 @@ Bool_t AliL3CompressAC::ExpandFile()
   //Now there should be a endofstream indicator, if not something went wrong during encoding/decoding.
   temp = ConvertSymbolToInt();
   if((UShort_t)temp != fMax + 1)
-    cerr<<"AliL3CompressAC::ExpandFile : Missing the endofstream indicator!"<<endl;
+    cerr<<"AliHLTCompressAC::ExpandFile : Missing the endofstream indicator!"<<endl;
   
   CloseInputBitFile(input);
 
   //Write everything to the uncompressed outfile:
   for(i=0; i<trackcount; i++)
     {
-      fwrite(&trackmodels[i],sizeof(AliL3TrackModel),1,output);
-      fwrite(clusters[i],AliL3Transform::GetNRows(fPatch)*sizeof(AliL3ClusterModel),1,output);
+      fwrite(&trackmodels[i],sizeof(AliHLTTrackModel),1,output);
+      fwrite(clusters[i],AliHLTTransform::GetNRows(fPatch)*sizeof(AliHLTClusterModel),1,output);
     }
   
   fclose(output);
@@ -674,10 +674,10 @@ Bool_t AliL3CompressAC::ExpandFile()
   return kTRUE;
 }
 
-void AliL3CompressAC::PrintCompRatio(ofstream *outfile)
+void AliHLTCompressAC::PrintCompRatio(ofstream *outfile)
 {
   // pristc compression ratio
-  AliL3MemHandler *mem = new AliL3MemHandler();
+  AliHLTMemHandler *mem = new AliHLTMemHandler();
   Char_t fname[1024];
   UInt_t remainSize=0,digitSize=0;
   for(Int_t i=0; i<36; i++)
@@ -708,13 +708,13 @@ void AliL3CompressAC::PrintCompRatio(ofstream *outfile)
   
   if(digitSize==0)
     {
-      cerr<<"AliL3Compress::PrintCompRatio : Zero digit size, not able to obtain comp. ratios!"<<endl;
+      cerr<<"AliHLTCompress::PrintCompRatio : Zero digit size, not able to obtain comp. ratios!"<<endl;
       return;
     }
   
   Float_t compratio = (Float_t)(compressSize + remainSize)/(Float_t)digitSize;
   Float_t entropy[3];
-  Int_t trackSize = GetEntropy(entropy[0],entropy[1],entropy[2])*sizeof(AliL3TrackModel);
+  Int_t trackSize = GetEntropy(entropy[0],entropy[1],entropy[2])*sizeof(AliHLTTrackModel);
   if(outfile)
     {
       ofstream &out = *outfile;
similarity index 72%
rename from HLT/comp/AliL3CompressAC.h
rename to HLT/comp/AliHLTCompressAC.h
index 71e6f1d..8c507b6 100644 (file)
@@ -1,17 +1,17 @@
 // @(#) $Id$
 
-#ifndef AliL3_CompressAC
-#define AliL3_CompressAC
+#ifndef AliHLT_CompressAC
+#define AliHLT_CompressAC
 
-#include "AliL3Compress.h"
+#include "AliHLTCompress.h"
 #include "bitio.h"
 
-class AliL3CompressAC : public AliL3Compress {
+class AliHLTCompressAC : public AliHLTCompress {
   
  public:
-  AliL3CompressAC();
-  AliL3CompressAC(Int_t slice,Int_t patch,Char_t *path="./",Bool_t writeshape=kFALSE,Int_t event=-1);
-  virtual ~AliL3CompressAC();
+  AliHLTCompressAC();
+  AliHLTCompressAC(Int_t slice,Int_t patch,Char_t *path="./",Bool_t writeshape=kFALSE,Int_t event=-1);
+  virtual ~AliHLTCompressAC();
   
   Bool_t CompressFile();
   Bool_t ExpandFile();
@@ -43,8 +43,10 @@ class AliL3CompressAC : public AliL3Compress {
   void RemoveSymbolFromStream(BIT_FILE *input,Int_t j);  
   void FlushEncoder(BIT_FILE *output);
   
-  ClassDef(AliL3CompressAC,1) 
+  ClassDef(AliHLTCompressAC,1) 
 
 };
 
+typedef AliHLTCompressAC AliL3CompressAC; // for backward compatibility
+
 #endif
similarity index 68%
rename from HLT/comp/AliL3DataCompressor.cxx
rename to HLT/comp/AliHLTDataCompressor.cxx
index cebd9e8..c507f58 100644 (file)
@@ -4,27 +4,27 @@
 //*-- Copyright &copy ALICE HLT Group
 //_____________________________________________________________
 //
-//  AliL3DataCompression
+//  AliHLTDataCompression
 //
 // Interface class; binary <-> AliROOT handling of TPC data compression classes.
 //
 
 
-#include "AliL3StandardIncludes.h"
+#include "AliHLTStandardIncludes.h"
 
-#include "AliL3Logging.h"
-#include "AliL3RootTypes.h"
-#include "AliL3Transform.h"
-#include "AliL3MemHandler.h"
-#include "AliL3SpacePointData.h"
-#include "AliL3CompressAC.h"
-#include "AliL3TrackArray.h"
-#include "AliL3ModelTrack.h"
-#include "AliL3Benchmark.h"
-#include "AliL3ClusterFitter.h"
+#include "AliHLTLogging.h"
+#include "AliHLTRootTypes.h"
+#include "AliHLTTransform.h"
+#include "AliHLTMemHandler.h"
+#include "AliHLTSpacePointData.h"
+#include "AliHLTCompressAC.h"
+#include "AliHLTTrackArray.h"
+#include "AliHLTModelTrack.h"
+#include "AliHLTBenchmark.h"
+#include "AliHLTClusterFitter.h"
 
 #ifdef use_aliroot
-#include "AliL3FileHandler.h"
+#include "AliHLTFileHandler.h"
 #include <AliTPCcluster.h>
 #include <AliTPCParamSR.h>
 #include <AliTPCDigitsArray.h>
@@ -43,8 +43,8 @@
 #include <TH2F.h>
 #endif
 
-#include "AliL3DataCompressorHelper.h"
-#include "AliL3DataCompressor.h"
+#include "AliHLTDataCompressorHelper.h"
+#include "AliHLTDataCompressor.h"
 #include <math.h>
 
 #if __GNUC__ == 3
@@ -52,9 +52,9 @@ using namespace std;
 #endif
 
 
-ClassImp(AliL3DataCompressor)
+ClassImp(AliHLTDataCompressor)
 
-AliL3DataCompressor::AliL3DataCompressor()
+AliHLTDataCompressor::AliHLTDataCompressor()
 {
   // default constructor
   fBenchmark=0;
@@ -67,14 +67,14 @@ AliL3DataCompressor::AliL3DataCompressor()
   fCompRatioFile=0;
   fNusedClusters=0;
   fNunusedClusters=0;
-  memset(fClusters,0,36*6*sizeof(AliL3SpacePointData*));
+  memset(fClusters,0,36*6*sizeof(AliHLTSpacePointData*));
 }
 
-AliL3DataCompressor::AliL3DataCompressor(Char_t *path,Bool_t keep,Bool_t writeshape)
+AliHLTDataCompressor::AliHLTDataCompressor(Char_t *path,Bool_t keep,Bool_t writeshape)
 {
   // constructor
   strcpy(fPath,path);
-  fBenchmark = new AliL3Benchmark();
+  fBenchmark = new AliHLTBenchmark();
   fInputTracks=0;
   fKeepRemaining=keep;
   fWriteClusterShape = writeshape;
@@ -83,7 +83,7 @@ AliL3DataCompressor::AliL3DataCompressor(Char_t *path,Bool_t keep,Bool_t writesh
   fNusedClusters=0;
   fNunusedClusters=0;
   fNoCompression=kFALSE;
-  memset(fClusters,0,36*6*sizeof(AliL3SpacePointData*));
+  memset(fClusters,0,36*6*sizeof(AliHLTSpacePointData*));
 #ifdef use_root
   Char_t name[1024];
   sprintf(name,"rm -f %s/comp/*",path);//Clean the directory
@@ -92,7 +92,7 @@ AliL3DataCompressor::AliL3DataCompressor(Char_t *path,Bool_t keep,Bool_t writesh
   OpenOutputFile();
 }
 
-AliL3DataCompressor::~AliL3DataCompressor()
+AliHLTDataCompressor::~AliHLTDataCompressor()
 {
   // destructor
   if(fInputTracks)
@@ -109,17 +109,17 @@ AliL3DataCompressor::~AliL3DataCompressor()
   CloseOutputFile();
 }
 
-void AliL3DataCompressor::DoBench(Char_t *fname)
+void AliHLTDataCompressor::DoBench(Char_t *fname)
 {
   // does benchmarking
   fBenchmark->Analyze(fname);
 }
 
-void AliL3DataCompressor::OpenOutputFile()
+void AliHLTDataCompressor::OpenOutputFile()
 {
   // opens the output file
 #ifndef use_aliroot
-   LOG(AliL3Log::kError,"AliL3DataCompressor::OpenOutputFile","Version")
+   LOG(AliHLTLog::kError,"AliHLTDataCompressor::OpenOutputFile","Version")
      <<"You have to compile with use_aliroot flag in order to use this function"<<ENDLOG;
 #else
   Char_t filename[1024];
@@ -133,7 +133,7 @@ void AliL3DataCompressor::OpenOutputFile()
 
   sprintf(filename,"%s/alirunfile.root",fPath);
   TFile *f = TFile::Open(filename);
-  AliTPCParam *param = (AliTPCParam*)f->Get(AliL3Transform::GetParamName());
+  AliTPCParam *param = (AliTPCParam*)f->Get(AliHLTTransform::GetParamName());
   sprintf(filename,"%s/comp/AliTPCclusters.root",fPath);
   fOutputFile = TFile::Open(filename,"RECREATE");
   param->Write(param->GetTitle());
@@ -141,7 +141,7 @@ void AliL3DataCompressor::OpenOutputFile()
 #endif
 }
 
-void AliL3DataCompressor::CloseOutputFile()
+void AliHLTDataCompressor::CloseOutputFile()
 {
   // closes the output file
   if(fCompRatioFile)
@@ -162,12 +162,12 @@ void AliL3DataCompressor::CloseOutputFile()
   fOutputFile=0;
 }
 
-void AliL3DataCompressor::LoadData(Int_t event,Bool_t sp)
+void AliHLTDataCompressor::LoadData(Int_t event,Bool_t sp)
 {
   // Loads data
   fSinglePatch=sp;
   fEvent=event;
-  AliL3MemHandler *clusterfile[36][6];
+  AliHLTMemHandler *clusterfile[36][6];
   Char_t fname[1024];
   for(Int_t s=0; s<=35; s++)
     {
@@ -176,14 +176,14 @@ void AliL3DataCompressor::LoadData(Int_t event,Bool_t sp)
          if(fClusters[s][p])
            delete fClusters[s][p];
          fClusters[s][p] = 0;
-         clusterfile[s][p] = new AliL3MemHandler();
+         clusterfile[s][p] = new AliHLTMemHandler();
          if(fSinglePatch)
            sprintf(fname,"%s/cf/points_%d_%d_%d.raw",fPath,fEvent,s,-1);
          else
            sprintf(fname,"%s/cf/points_%d_%d_%d.raw",fPath,fEvent,s,p);
          clusterfile[s][p]->SetBinaryInput(fname);
          
-         fClusters[s][p] = (AliL3SpacePointData*)clusterfile[s][p]->Allocate();
+         fClusters[s][p] = (AliHLTSpacePointData*)clusterfile[s][p]->Allocate();
          clusterfile[s][p]->Binary2Memory(fNcl[s][p],fClusters[s][p]);
          clusterfile[s][p]->CloseBinaryInput();
          
@@ -194,29 +194,29 @@ void AliL3DataCompressor::LoadData(Int_t event,Bool_t sp)
   
   //cout<<endl<<"Reading from offlinecf"<<endl<<endl;
   sprintf(fname,"%s/cf/tracks_%d.raw",fPath,fEvent);
-  AliL3MemHandler *tfile = new AliL3MemHandler();
+  AliHLTMemHandler *tfile = new AliHLTMemHandler();
   tfile->SetBinaryInput(fname);
   
   if(fInputTracks)
     delete fInputTracks;
-  fInputTracks = new AliL3TrackArray();
+  fInputTracks = new AliHLTTrackArray();
   tfile->Binary2TrackArray(fInputTracks);
   tfile->CloseBinaryInput();
   delete tfile;
 }
 
-void AliL3DataCompressor::FillData(Int_t minHits,Bool_t expand)
+void AliHLTDataCompressor::FillData(Int_t minHits,Bool_t expand)
 {
   
   //Fill the track data into track and cluster structures, and write to file.
   //Preparation for compressing it.
   
   cout<<"Filling data; "<<fInputTracks->GetNTracks()<<" tracks"<<endl;
-  AliL3TrackArray *comptracks = new AliL3TrackArray("AliL3ModelTrack");
+  AliHLTTrackArray *comptracks = new AliHLTTrackArray("AliHLTModelTrack");
   fInputTracks->QSort();
   for(Int_t i=0; i<fInputTracks->GetNTracks(); i++)
     {
-      AliL3Track *intrack = fInputTracks->GetCheckedTrack(i);
+      AliHLTTrack *intrack = fInputTracks->GetCheckedTrack(i);
       if(!intrack) continue;
 
       if(intrack->GetNHits()<minHits) break;
@@ -224,7 +224,7 @@ void AliL3DataCompressor::FillData(Int_t minHits,Bool_t expand)
       
       intrack->CalculateHelix();
       
-      AliL3ModelTrack *outtrack = (AliL3ModelTrack*)comptracks->NextTrack();
+      AliHLTModelTrack *outtrack = (AliHLTModelTrack*)comptracks->NextTrack();
       outtrack->SetNHits(intrack->GetNHits());
       outtrack->SetRowRange(intrack->GetFirstRow(),intrack->GetLastRow());
       outtrack->SetFirstPoint(intrack->GetFirstPointX(),intrack->GetFirstPointY(),intrack->GetFirstPointZ());
@@ -247,16 +247,16 @@ void AliL3DataCompressor::FillData(Int_t minHits,Bool_t expand)
          UInt_t pos = id&0x3fffff;          
 
          //UInt_t size;
-         AliL3SpacePointData *points = fClusters[slice][patch];//->GetDataPointer(size);
+         AliHLTSpacePointData *points = fClusters[slice][patch];//->GetDataPointer(size);
          Float_t xyz[3] = {points[pos].fX,points[pos].fY,points[pos].fZ};
          Int_t padrow = points[pos].fPadRow;
 
          //Calculate the crossing point between track and padrow
          Float_t angle = 0; //Perpendicular to padrow in local coordinates
-         AliL3Transform::Local2GlobalAngle(&angle,slice);
-         if(!intrack->CalculateReferencePoint(angle,AliL3Transform::Row2X(padrow)))
+         AliHLTTransform::Local2GlobalAngle(&angle,slice);
+         if(!intrack->CalculateReferencePoint(angle,AliHLTTransform::Row2X(padrow)))
            {
-             cerr<<"AliL3DataCompressor::FillData : Error in crossing point calc on slice "<<slice<<" row "<<padrow<<endl;
+             cerr<<"AliHLTDataCompressor::FillData : Error in crossing point calc on slice "<<slice<<" row "<<padrow<<endl;
              break;
              //outtrack->Print(kFALSE);
              //exit(5);
@@ -265,9 +265,9 @@ void AliL3DataCompressor::FillData(Int_t minHits,Bool_t expand)
          Float_t xyzCross[3] = {intrack->GetPointX(),intrack->GetPointY(),intrack->GetPointZ()};
 
          Int_t sector,row;
-         AliL3Transform::Slice2Sector(slice,padrow,sector,row);
-         AliL3Transform::Global2Raw(xyzCross,sector,row);
-         AliL3Transform::Global2Raw(xyz,sector,row);
+         AliHLTTransform::Slice2Sector(slice,padrow,sector,row);
+         AliHLTTransform::Global2Raw(xyzCross,sector,row);
+         AliHLTTransform::Global2Raw(xyz,sector,row);
          
          outtrack->SetPadHit(padrow,xyzCross[1]);
          outtrack->SetTimeHit(padrow,xyzCross[2]);
@@ -277,34 +277,34 @@ void AliL3DataCompressor::FillData(Int_t minHits,Bool_t expand)
 
          if(fWriteClusterShape)
            {
-             Int_t patch = AliL3Transform::GetPatch(padrow);
-             Float_t sigmaY2 = points[pos].fSigmaY2 / pow(AliL3Transform::GetPadPitchWidth(patch),2);
-             Float_t sigmaZ2 = points[pos].fSigmaZ2 / pow(AliL3Transform::GetZWidth(),2);
+             Int_t patch = AliHLTTransform::GetPatch(padrow);
+             Float_t sigmaY2 = points[pos].fSigmaY2 / pow(AliHLTTransform::GetPadPitchWidth(patch),2);
+             Float_t sigmaZ2 = points[pos].fSigmaZ2 / pow(AliHLTTransform::GetZWidth(),2);
              outtrack->SetCluster(padrow,xyz[1],xyz[2],points[pos].fCharge,sigmaY2,sigmaZ2,3);
            }
          else
            outtrack->SetCluster(padrow,xyz[1],xyz[2],points[pos].fCharge,0,0,3);
          
-         //IMPORTANT: Set the slice in which cluster is, you need it in AliL3ModelTrack::FillTrack!
+         //IMPORTANT: Set the slice in which cluster is, you need it in AliHLTModelTrack::FillTrack!
          outtrack->GetClusterModel(padrow)->fSlice=slice;
          points[pos].fCharge = 0;//Mark this cluster as used.
          fNusedClusters++;
        }
       if(!expand)
-       outtrack->SetNClusters(AliL3Transform::GetNRows(-1));
+       outtrack->SetNClusters(AliHLTTransform::GetNRows(-1));
     }
   if(expand)
     ExpandTrackData(comptracks);
   
   cout<<"Writing "<<comptracks->GetNTracks()<<" tracks to file"<<endl;
-  AliL3Compress *comp = new AliL3Compress(-1,-1,fPath,fWriteClusterShape,fEvent);
+  AliHLTCompress *comp = new AliHLTCompress(-1,-1,fPath,fWriteClusterShape,fEvent);
   comp->WriteFile(comptracks);
   delete comp;
   delete comptracks;
   
 }
 
-void AliL3DataCompressor::ExpandTrackData(AliL3TrackArray *tracks)
+void AliHLTDataCompressor::ExpandTrackData(AliHLTTrackArray *tracks)
 {
   //Loop over tracks and try to assign unused clusters.
   //Only clusters which are closer than the max. residual are taken.
@@ -312,15 +312,15 @@ void AliL3DataCompressor::ExpandTrackData(AliL3TrackArray *tracks)
   cout<<"Expanding "<<tracks->GetNTracks()<<" tracks"<<endl;
   for(Int_t i=0; i<tracks->GetNTracks(); i++)
     {
-      AliL3ModelTrack *track = (AliL3ModelTrack*)tracks->GetCheckedTrack(i);
+      AliHLTModelTrack *track = (AliHLTModelTrack*)tracks->GetCheckedTrack(i);
       if(!track) continue;
-      if(track->GetNHits() == AliL3Transform::GetNRows()) continue;
+      if(track->GetNHits() == AliHLTTransform::GetNRows()) continue;
       
       Int_t nhits = track->GetNHits();
       //cout<<"Expanding track with "<<nhits<<" clusters"<<endl;
       
       Int_t lastSlice=-1;
-      for(Int_t padrow=AliL3Transform::GetNRows()-1; padrow>=0; padrow--)
+      for(Int_t padrow=AliHLTTransform::GetNRows()-1; padrow>=0; padrow--)
        {
          if(track->IsPresent(padrow))
            {
@@ -348,31 +348,31 @@ void AliL3DataCompressor::ExpandTrackData(AliL3TrackArray *tracks)
              continue;
          
          //UInt_t size;
-         AliL3SpacePointData *points = fClusters[lastSlice][0];//->GetDataPointer(size);
+         AliHLTSpacePointData *points = fClusters[lastSlice][0];//->GetDataPointer(size);
          
          Float_t angle = 0;
-         AliL3Transform::Local2GlobalAngle(&angle,lastSlice);
-         if(!track->CalculateReferencePoint(angle,AliL3Transform::Row2X(padrow)))
+         AliHLTTransform::Local2GlobalAngle(&angle,lastSlice);
+         if(!track->CalculateReferencePoint(angle,AliHLTTransform::Row2X(padrow)))
            continue;
          Float_t xyzCross[3] = {track->GetPointX(),track->GetPointY(),track->GetPointZ()};
-         AliL3Transform::Global2LocHLT(xyzCross,lastSlice);
+         AliHLTTransform::Global2LocHLT(xyzCross,lastSlice);
          Float_t mindist = 123456789;
-         AliL3SpacePointData *closest=0;
+         AliHLTSpacePointData *closest=0;
          for(UInt_t j=0; j<fNcl[lastSlice][0]; j++)
            {
              if(points[j].fCharge == 0) continue;// || points[j].fPadRow != padrow) continue;
              if(points[j].fPadRow < padrow) continue;
              if(points[j].fPadRow > padrow) break;
              Float_t xyz[3] = {points[j].fX,points[j].fY,points[j].fZ};
-             AliL3Transform::Global2LocHLT(xyz,lastSlice);
+             AliHLTTransform::Global2LocHLT(xyz,lastSlice);
              
              //Check for overflow:
-             Int_t temp = (Int_t)rint((xyzCross[1]-xyz[1])/AliL3DataCompressorHelper::GetXYResidualStep(padrow));
-             if( abs(temp) > 1<<(AliL3DataCompressorHelper::GetNPadBits()-1))
+             Int_t temp = (Int_t)rint((xyzCross[1]-xyz[1])/AliHLTDataCompressorHelper::GetXYResidualStep(padrow));
+             if( abs(temp) > 1<<(AliHLTDataCompressorHelper::GetNPadBits()-1))
                continue;
              
-             temp = (Int_t)rint((xyzCross[2]-xyz[2])/AliL3DataCompressorHelper::GetZResidualStep(padrow));
-             if( abs(temp) > 1<<(AliL3DataCompressorHelper::GetNTimeBits()-1))
+             temp = (Int_t)rint((xyzCross[2]-xyz[2])/AliHLTDataCompressorHelper::GetZResidualStep(padrow));
+             if( abs(temp) > 1<<(AliHLTDataCompressorHelper::GetNTimeBits()-1))
                continue;
              
              Float_t dist = sqrt( pow(xyzCross[1]-xyz[1],2) + pow(xyzCross[2]-xyz[2],2) );
@@ -386,9 +386,9 @@ void AliL3DataCompressor::ExpandTrackData(AliL3TrackArray *tracks)
            {
              Int_t sector,row;
              Float_t xyz[3] = {closest->fX,closest->fY,closest->fZ};
-             AliL3Transform::Slice2Sector(lastSlice,padrow,sector,row);
-             AliL3Transform::Local2Raw(xyzCross,sector,row);
-             AliL3Transform::Global2Raw(xyz,sector,row);
+             AliHLTTransform::Slice2Sector(lastSlice,padrow,sector,row);
+             AliHLTTransform::Local2Raw(xyzCross,sector,row);
+             AliHLTTransform::Global2Raw(xyz,sector,row);
              
              track->SetPadHit(padrow,xyzCross[1]);
              track->SetTimeHit(padrow,xyzCross[2]);
@@ -398,21 +398,21 @@ void AliL3DataCompressor::ExpandTrackData(AliL3TrackArray *tracks)
                  Float_t angle = track->GetCrossingAngle(padrow,lastSlice);
                  track->SetCrossingAngleLUT(padrow,angle);
                  track->CalculateClusterWidths(padrow,kTRUE);
-                 Int_t patch = AliL3Transform::GetPatch(padrow);
-                 Float_t sigmaY2 = closest->fSigmaY2 / pow(AliL3Transform::GetPadPitchWidth(patch),2);
-                 Float_t sigmaZ2 = closest->fSigmaZ2 / pow(AliL3Transform::GetZWidth(),2);
+                 Int_t patch = AliHLTTransform::GetPatch(padrow);
+                 Float_t sigmaY2 = closest->fSigmaY2 / pow(AliHLTTransform::GetPadPitchWidth(patch),2);
+                 Float_t sigmaZ2 = closest->fSigmaZ2 / pow(AliHLTTransform::GetZWidth(),2);
                  track->SetCluster(padrow,xyz[1],xyz[2],closest->fCharge,sigmaY2,sigmaZ2,3);
                }
              else
                track->SetCluster(padrow,xyz[1],xyz[2],closest->fCharge,0,0,3);
              nhits++;
              
-             //IMPORTANT: Set the slice in which cluster is, you need it in AliL3ModelTrack::FillTrack!
+             //IMPORTANT: Set the slice in which cluster is, you need it in AliHLTModelTrack::FillTrack!
              track->GetClusterModel(padrow)->fSlice=lastSlice;
              closest->fCharge = 0;//Mark this cluster as used.
            }
        }
-      track->SetNClusters(AliL3Transform::GetNRows());
+      track->SetNClusters(AliHLTTransform::GetNRows());
       //cout<<"Track was assigned "<<nhits<<" clusters"<<endl;
     }
   
@@ -420,14 +420,14 @@ void AliL3DataCompressor::ExpandTrackData(AliL3TrackArray *tracks)
 
 
 
-void AliL3DataCompressor::DetermineMinBits()
+void AliHLTDataCompressor::DetermineMinBits()
 {
   //Make a pass through the modelled data (after FillData has been done) to determine
   //how many bits is needed to encode the residuals _without_ overflows.
   
-  AliL3Compress *comp = new AliL3Compress(-1,-1,fPath,fWriteClusterShape,fEvent);
+  AliHLTCompress *comp = new AliHLTCompress(-1,-1,fPath,fWriteClusterShape,fEvent);
   comp->ReadFile('m');
-  AliL3TrackArray *tracks = comp->GetTracks();
+  AliHLTTrackArray *tracks = comp->GetTracks();
   if(tracks->GetNTracks()==0)
     {
       delete comp;
@@ -438,16 +438,16 @@ void AliL3DataCompressor::DetermineMinBits()
   Int_t dpad,dtime,charge,dsigmaY,dsigmaZ,npadbits,ntimebits,nchargebits,nshapebits=0;
   for(Int_t i=0; i<tracks->GetNTracks(); i++)
     {
-      AliL3ModelTrack *track = (AliL3ModelTrack*)tracks->GetCheckedTrack(i);
+      AliHLTModelTrack *track = (AliHLTModelTrack*)tracks->GetCheckedTrack(i);
       if(!track) continue;
-      for(Int_t padrow=0; padrow<AliL3Transform::GetNRows(); padrow++)
+      for(Int_t padrow=0; padrow<AliHLTTransform::GetNRows(); padrow++)
        {
          if(!track->IsPresent(padrow)) continue;
-         dpad = AliL3DataCompressorHelper::Abs(AliL3DataCompressorHelper::Nint(track->GetClusterModel(padrow)->fDPad));
-         dtime = AliL3DataCompressorHelper::Abs(AliL3DataCompressorHelper::Nint(track->GetClusterModel(padrow)->fDTime));
-         charge = AliL3DataCompressorHelper::Abs((Int_t)track->GetClusterModel(padrow)->fDCharge);
-         dsigmaY = AliL3DataCompressorHelper::Abs(AliL3DataCompressorHelper::Nint(track->GetClusterModel(padrow)->fDSigmaY));
-         dsigmaZ = AliL3DataCompressorHelper::Abs(AliL3DataCompressorHelper::Nint(track->GetClusterModel(padrow)->fDSigmaZ));
+         dpad = AliHLTDataCompressorHelper::Abs(AliHLTDataCompressorHelper::Nint(track->GetClusterModel(padrow)->fDPad));
+         dtime = AliHLTDataCompressorHelper::Abs(AliHLTDataCompressorHelper::Nint(track->GetClusterModel(padrow)->fDTime));
+         charge = AliHLTDataCompressorHelper::Abs((Int_t)track->GetClusterModel(padrow)->fDCharge);
+         dsigmaY = AliHLTDataCompressorHelper::Abs(AliHLTDataCompressorHelper::Nint(track->GetClusterModel(padrow)->fDSigmaY));
+         dsigmaZ = AliHLTDataCompressorHelper::Abs(AliHLTDataCompressorHelper::Nint(track->GetClusterModel(padrow)->fDSigmaZ));
          if(dpad > maxpad)
            maxpad=dpad;
          if(dtime > maxtime)
@@ -467,12 +467,12 @@ void AliL3DataCompressor::DetermineMinBits()
   if(fWriteClusterShape)
     nshapebits = (Int_t)ceil(log(Double_t(maxsigma))/log(2.)) + 1;
   
-  nchargebits = AliL3DataCompressorHelper::GetNChargeBits();
+  nchargebits = AliHLTDataCompressorHelper::GetNChargeBits();
   cout<<"Updating bitnumbers; pad "<<npadbits<<" time "<<ntimebits<<" charge "<<nchargebits<<" shape "<<nshapebits<<endl;
-  AliL3DataCompressorHelper::SetBitNumbers(npadbits,ntimebits,nchargebits,nshapebits);
+  AliHLTDataCompressorHelper::SetBitNumbers(npadbits,ntimebits,nchargebits,nshapebits);
 }
 
-void AliL3DataCompressor::WriteRemaining(Bool_t select)
+void AliHLTDataCompressor::WriteRemaining(Bool_t select)
 {
   //Write remaining clusters (not assigned to any tracks) to file
 
@@ -485,13 +485,13 @@ void AliL3DataCompressor::WriteRemaining(Bool_t select)
   
   if(!fSinglePatch)
     {
-      cerr<<"AliL3Compressor::WriteRemaining : You have to modify this function when not running singlepatch"<<endl;
+      cerr<<"AliHLTCompressor::WriteRemaining : You have to modify this function when not running singlepatch"<<endl;
       return;
     }
   if(!fNoCompression)
     {
       cout<<"Compressing remaining clusters "<<endl;
-      AliL3Compress *comp = new AliL3Compress(-1,-1,fPath,fWriteClusterShape,fEvent);
+      AliHLTCompress *comp = new AliHLTCompress(-1,-1,fPath,fWriteClusterShape,fEvent);
       comp->CompressRemaining(fClusters,fNcl);
       delete comp;
       return;
@@ -499,7 +499,7 @@ void AliL3DataCompressor::WriteRemaining(Bool_t select)
   else
     {
       cout<<"Writing remaining clusters"<<endl;
-      Int_t nrows = AliL3Transform::GetNRows();
+      Int_t nrows = AliHLTTransform::GetNRows();
       Int_t *npoints = new Int_t[nrows];
       Char_t filename[1024];
       for(Int_t i=0; i<=35; i++)
@@ -510,11 +510,11 @@ void AliL3DataCompressor::WriteRemaining(Bool_t select)
              FILE *outfile = fopen(filename,"w");
              if(!outfile)
                {
-                 cerr<<"AliL3DataCompressor::WriteRemaining : Cannot open file "<<filename<<endl;
+                 cerr<<"AliHLTDataCompressor::WriteRemaining : Cannot open file "<<filename<<endl;
                  exit(5);
                }
 
-             AliL3SpacePointData *points = fClusters[i][patch];
+             AliHLTSpacePointData *points = fClusters[i][patch];
          
              memset(npoints,0,nrows*sizeof(Int_t));
          
@@ -525,7 +525,7 @@ void AliL3DataCompressor::WriteRemaining(Bool_t select)
                }
              Int_t size =0;
              Byte_t *data = 0;
-             AliL3RemainingRow *tempPt=0;
+             AliHLTRemainingRow *tempPt=0;
          
              Int_t lastRow = -2;
              Int_t localcounter=0;
@@ -541,12 +541,12 @@ void AliL3DataCompressor::WriteRemaining(Bool_t select)
                        {
                          if(!tempPt)
                            {
-                             cerr<<"AliL3DataCompressor::WriteRemaining : Zero row pointer "<<endl;
+                             cerr<<"AliHLTDataCompressor::WriteRemaining : Zero row pointer "<<endl;
                              exit(5);
                            }
                          if(localcounter != tempPt->fNClusters)
                            {
-                             cerr<<"AliL3DataCompressor::WriteRemaining : Mismatching clustercounter "<<localcounter<<" "
+                             cerr<<"AliHLTDataCompressor::WriteRemaining : Mismatching clustercounter "<<localcounter<<" "
                                  <<(Int_t)tempPt->fNClusters<<endl;
                              exit(5);
                            }
@@ -555,9 +555,9 @@ void AliL3DataCompressor::WriteRemaining(Bool_t select)
                        }
                      if(data)
                        delete [] data;
-                     size = sizeof(AliL3RemainingRow) + npoints[padrow]*sizeof(AliL3RemainingCluster);
+                     size = sizeof(AliHLTRemainingRow) + npoints[padrow]*sizeof(AliHLTRemainingCluster);
                      data = new Byte_t[size];
-                     tempPt = (AliL3RemainingRow*)data;
+                     tempPt = (AliHLTRemainingRow*)data;
                  
                      localcounter=0;
                      tempPt->fPadRow = padrow;
@@ -566,18 +566,18 @@ void AliL3DataCompressor::WriteRemaining(Bool_t select)
                    }
                  if(localcounter >= npoints[padrow])
                    {
-                     cerr<<"AliL3DataCompressor::WriteRemaining : Cluster counter out of range: "
+                     cerr<<"AliHLTDataCompressor::WriteRemaining : Cluster counter out of range: "
                          <<localcounter<<" "<<npoints[padrow]<<endl;
                      exit(5);
                    }
              
                  Float_t xyz[3] = {points[j].fX,points[j].fY,points[j].fZ};
                  Int_t sector,row;
-                 AliL3Transform::Slice2Sector(i,padrow,sector,row);
-                 AliL3Transform::Global2Raw(xyz,sector,row);
+                 AliHLTTransform::Slice2Sector(i,padrow,sector,row);
+                 AliHLTTransform::Global2Raw(xyz,sector,row);
                  
-                 Float_t padw = points[j].fSigmaY2 / pow(AliL3Transform::GetPadPitchWidth(AliL3Transform::GetPatch(padrow)),2);
-                 Float_t timew = points[j].fSigmaZ2 / pow(AliL3Transform::GetZWidth(),2);
+                 Float_t padw = points[j].fSigmaY2 / pow(AliHLTTransform::GetPadPitchWidth(AliHLTTransform::GetPatch(padrow)),2);
+                 Float_t timew = points[j].fSigmaZ2 / pow(AliHLTTransform::GetZWidth(),2);
                  tempPt->fClusters[localcounter].fPad = xyz[1];
                  tempPt->fClusters[localcounter].fTime = xyz[2];
                  tempPt->fClusters[localcounter].fCharge = points[j].fCharge;
@@ -598,7 +598,7 @@ void AliL3DataCompressor::WriteRemaining(Bool_t select)
     }  
 }
 
-void AliL3DataCompressor::SelectRemainingClusters()
+void AliHLTDataCompressor::SelectRemainingClusters()
 {
   //Select which remaining clusters to write in addition to the compressed data.
   //In particular one can here make sure that "important" clusters are not missed:
@@ -613,20 +613,20 @@ void AliL3DataCompressor::SelectRemainingClusters()
   //intact.....
   
   cout<<"Cleaning up clusters"<<endl;
-  Int_t nrows = AliL3Transform::GetNRows();
+  Int_t nrows = AliHLTTransform::GetNRows();
   Int_t gap=(Int_t)(0.125*nrows), shift=(Int_t)(0.5*gap);
   
   for(Int_t slice=0; slice<36; slice++)
     {
-      AliL3SpacePointData *points = fClusters[slice][0];
+      AliHLTSpacePointData *points = fClusters[slice][0];
       for(UInt_t i=0; i<fNcl[slice][0]; i++)
        {
          if(points[i].fCharge == 0) continue; //Already removed
          Int_t padrow = (Int_t)points[i].fPadRow;
          
          //Check the widths (errors) of the cluster, and remove big bastards:
-         Float_t padw = sqrt(points[i].fSigmaY2) / AliL3Transform::GetPadPitchWidth(AliL3Transform::GetPatch(padrow));
-         Float_t timew = sqrt(points[i].fSigmaZ2) / AliL3Transform::GetZWidth();
+         Float_t padw = sqrt(points[i].fSigmaY2) / AliHLTTransform::GetPadPitchWidth(AliHLTTransform::GetPatch(padrow));
+         Float_t timew = sqrt(points[i].fSigmaZ2) / AliHLTTransform::GetZWidth();
          if(padw >= 2.55 || timew >= 2.55)//Because we use 1 byte to store
            {
              points[i].fCharge = 0;
@@ -635,15 +635,15 @@ void AliL3DataCompressor::SelectRemainingClusters()
 
          Float_t xyz[3] = {points[i].fX,points[i].fY,points[i].fZ};
          Int_t sector,row;
-         AliL3Transform::Slice2Sector(slice,padrow,sector,row);
-         AliL3Transform::Global2Raw(xyz,sector,row);
+         AliHLTTransform::Slice2Sector(slice,padrow,sector,row);
+         AliHLTTransform::Global2Raw(xyz,sector,row);
          
          if(padrow >= nrows-1-gap-shift) continue;//save all the clusters in this region
          
          //if(padrow >= nrows-1-shift) continue;
 
          //Save the clusters at the borders:
-         //if(xyz[1] < 3 || xyz[1] >= AliL3Transform::GetNPads(padrow)-4)
+         //if(xyz[1] < 3 || xyz[1] >= AliHLTTransform::GetNPads(padrow)-4)
          // continue;
 
          //Save clusters on padrows used for offline seeding:
@@ -658,28 +658,28 @@ void AliL3DataCompressor::SelectRemainingClusters()
   
 }
 
-void AliL3DataCompressor::CompressAndExpand(Bool_t arithmeticCoding)
+void AliHLTDataCompressor::CompressAndExpand(Bool_t arithmeticCoding)
 {
   //Read tracks/clusters from file, compress data and uncompress it. Write compression rates to file.
   if(fNoCompression)
     return;
   
   cout<<"Compressing and expanding data"<<endl;
-  AliL3Compress *comp = 0;
+  AliHLTCompress *comp = 0;
   if(arithmeticCoding)
-    comp = new AliL3CompressAC(-1,-1,fPath,fWriteClusterShape,fEvent);
+    comp = new AliHLTCompressAC(-1,-1,fPath,fWriteClusterShape,fEvent);
   else
-    comp = new AliL3Compress(-1,-1,fPath,fWriteClusterShape,fEvent);
+    comp = new AliHLTCompress(-1,-1,fPath,fWriteClusterShape,fEvent);
   comp->CompressFile();
   comp->ExpandFile();
   comp->PrintCompRatio(fCompRatioFile);
   delete comp;
   
   ofstream &out = *fCompRatioFile;
-  out<<AliL3DataCompressorHelper::GetNPadBits()<<' '<<AliL3DataCompressorHelper::GetNTimeBits()<<' '
-     <<AliL3DataCompressorHelper::GetNChargeBits()<<' '<<AliL3DataCompressorHelper::GetNShapeBits()<<' '
-     <<AliL3DataCompressorHelper::GetNPadBitsRemaining()<<' '<<AliL3DataCompressorHelper::GetNTimeBitsRemaining()<<' '
-     <<AliL3DataCompressorHelper::GetNShapeBitsRemaining()<<endl;
+  out<<AliHLTDataCompressorHelper::GetNPadBits()<<' '<<AliHLTDataCompressorHelper::GetNTimeBits()<<' '
+     <<AliHLTDataCompressorHelper::GetNChargeBits()<<' '<<AliHLTDataCompressorHelper::GetNShapeBits()<<' '
+     <<AliHLTDataCompressorHelper::GetNPadBitsRemaining()<<' '<<AliHLTDataCompressorHelper::GetNTimeBitsRemaining()<<' '
+     <<AliHLTDataCompressorHelper::GetNShapeBitsRemaining()<<endl;
   /*
   //Write the ratio between used and unused clusters to comp file:
   out<<fNusedClusters<<' '<<fNunusedClusters<<endl;
@@ -687,14 +687,14 @@ void AliL3DataCompressor::CompressAndExpand(Bool_t arithmeticCoding)
 }
 
 
-void AliL3DataCompressor::RestoreData(Bool_t remainingOnly)
+void AliHLTDataCompressor::RestoreData(Bool_t remainingOnly)
 {
   //Restore the uncompressed data together with the remaining clusters,
   //and write to a final cluster file which serves as an input to the
   //final offline tracker.
   
 #ifndef use_aliroot
-   LOG(AliL3Log::kError,"AliL3DataCompressor::RestoreData","Version")
+   LOG(AliHLTLog::kError,"AliHLTDataCompressor::RestoreData","Version")
      <<"You have to compile with use_aliroot flag in order to use this function"<<ENDLOG;
 #else
 
@@ -719,16 +719,16 @@ void AliL3DataCompressor::RestoreData(Bool_t remainingOnly)
   sprintf(filename,"%s/digitfile.root",fPath);
   TFile *rootfile = TFile::Open(filename);
   rootfile->cd();
-  AliTPCParam *param = (AliTPCParam*)rootfile->Get(AliL3Transform::GetParamName());
+  AliTPCParam *param = (AliTPCParam*)rootfile->Get(AliHLTTransform::GetParamName());
 
   AliTPCDigitsArray *darray = new AliTPCDigitsArray();
   darray->Setup(param);
   darray->SetClass("AliSimDigits");
-  sprintf(filename,"TreeD_%s_%d",AliL3Transform::GetParamName(),fEvent);
+  sprintf(filename,"TreeD_%s_%d",AliHLTTransform::GetParamName(),fEvent);
   Bool_t ok = darray->ConnectTree(filename);
   if(!ok)
     {
-      cerr<<"AliL3DataCompressor::RestoreData : Problems connecting tree"<<endl;
+      cerr<<"AliHLTDataCompressor::RestoreData : Problems connecting tree"<<endl;
       return;
     }
 
@@ -754,35 +754,35 @@ void AliL3DataCompressor::RestoreData(Bool_t remainingOnly)
 
       Int_t falseid=0;
       Int_t counter=0;
-      for(Int_t padrow=AliL3Transform::GetFirstRow(-1); padrow<=AliL3Transform::GetLastRow(-1); padrow++)
+      for(Int_t padrow=AliHLTTransform::GetFirstRow(-1); padrow<=AliHLTTransform::GetLastRow(-1); padrow++)
        {
          Int_t sec,row;
-         AliL3Transform::Slice2Sector(slice,padrow,sec,row);
+         AliHLTTransform::Slice2Sector(slice,padrow,sec,row);
          AliTPCClustersRow *clrow=carray->CreateRow(sec,row);
          AliSimDigits *digits = (AliSimDigits*)darray->LoadRow(sec,row);
          digits->ExpandBuffer();
          digits->ExpandTrackBuffer();
-         Int_t patch = AliL3Transform::GetPatch(padrow);
+         Int_t patch = AliHLTTransform::GetPatch(padrow);
          while(counter < ncl[slice] && clPt[counter]->fPadrow == padrow)
            {
              Float_t temp[3];
-             AliL3Transform::Raw2Local(temp,sec,row,clPt[counter]->fPad,clPt[counter]->fTime);
+             AliHLTTransform::Raw2Local(temp,sec,row,clPt[counter]->fPad,clPt[counter]->fTime);
              
              AliTPCcluster *c = new AliTPCcluster();
              c->SetY(temp[1]);
              c->SetZ(temp[2]);
              c->SetQ(clPt[counter]->fCharge);
              
-             c->SetSigmaY2(clPt[counter]->fSigmaY2*pow(AliL3Transform::GetPadPitchWidth(patch),2));
-             c->SetSigmaZ2(clPt[counter]->fSigmaZ2*pow(AliL3Transform::GetZWidth(),2));
-             Int_t pad = AliL3DataCompressorHelper::Nint(clPt[counter]->fPad);
-             Int_t time = AliL3DataCompressorHelper::Nint(clPt[counter]->fTime);
+             c->SetSigmaY2(clPt[counter]->fSigmaY2*pow(AliHLTTransform::GetPadPitchWidth(patch),2));
+             c->SetSigmaZ2(clPt[counter]->fSigmaZ2*pow(AliHLTTransform::GetZWidth(),2));
+             Int_t pad = AliHLTDataCompressorHelper::Nint(clPt[counter]->fPad);
+             Int_t time = AliHLTDataCompressorHelper::Nint(clPt[counter]->fTime);
              
              if(pad < 0)
                pad=0;
-             if(pad >= AliL3Transform::GetNPads(padrow))
-               pad = AliL3Transform::GetNPads(padrow)-1;
-             if(time < 0 || time >= AliL3Transform::GetNTimeBins())
+             if(pad >= AliHLTTransform::GetNPads(padrow))
+               pad = AliHLTTransform::GetNPads(padrow)-1;
+             if(time < 0 || time >= AliHLTTransform::GetNTimeBins())
                cerr<<"row "<<padrow<<" pad "<<pad<<" time "<<time<<endl;
              
              for(Int_t lab=0; lab<3; lab++)
@@ -797,7 +797,7 @@ void AliL3DataCompressor::RestoreData(Bool_t remainingOnly)
                  if(lab==0 && c->GetLabel(0) < 0)
                    {
                      falseid++;
-                     //AliL3Transform::Local2Global(temp,slice);
+                     //AliHLTTransform::Local2Global(temp,slice);
                      //cout<<"slice "<<slice<<" padrow "<<padrow<<" y "<<temp[1]<<" z "<<temp[2]<<" label "<<c->GetLabel(0)<<endl;
                    }
                }
@@ -833,10 +833,10 @@ void AliL3DataCompressor::RestoreData(Bool_t remainingOnly)
 #endif
 }
 
-void AliL3DataCompressor::ReadUncompressedData(TempCluster **clusters,Int_t *ncl,const Int_t kmaxpoints)
+void AliHLTDataCompressor::ReadUncompressedData(TempCluster **clusters,Int_t *ncl,const Int_t kmaxpoints)
 {
   // Reads uncompressed data  
-  AliL3Compress *comp = new AliL3Compress(-1,-1,fPath,fWriteClusterShape,fEvent);
+  AliHLTCompress *comp = new AliHLTCompress(-1,-1,fPath,fWriteClusterShape,fEvent);
   if(fNoCompression)
     {
       cout<<endl<<"Reading unmodified data, no compression has been done here!!!!"<<endl<<endl;
@@ -848,16 +848,16 @@ void AliL3DataCompressor::ReadUncompressedData(TempCluster **clusters,Int_t *ncl
       comp->ReadFile('u');
     }
   
-  AliL3TrackArray *tracks = comp->GetTracks();
+  AliHLTTrackArray *tracks = comp->GetTracks();
   
   //Float_t totcounter=0,pcounter=0,tcounter=0;
   Int_t charge;
   Float_t pad,time,sigmaY2,sigmaZ2;
   for(Int_t i=0; i<tracks->GetNTracks(); i++)
     {
-      AliL3ModelTrack *track = (AliL3ModelTrack*)tracks->GetCheckedTrack(i);
+      AliHLTModelTrack *track = (AliHLTModelTrack*)tracks->GetCheckedTrack(i);
       if(!track) continue;
-      for(Int_t padrow=0; padrow < AliL3Transform::GetNRows(-1); padrow++)
+      for(Int_t padrow=0; padrow < AliHLTTransform::GetNRows(-1); padrow++)
        {
          if(!track->IsPresent(padrow)) continue;
          track->GetPad(padrow,pad);
@@ -867,16 +867,16 @@ void AliL3DataCompressor::ReadUncompressedData(TempCluster **clusters,Int_t *ncl
          track->GetSigmaZ2(padrow,sigmaZ2);
          Int_t slice = track->GetClusterModel(padrow)->fSlice;
          /*
-           if(pad < -1 || pad > AliL3Transform::GetNPads(padrow) || time < -1 || time > AliL3Transform::GetNTimeBins())
+           if(pad < -1 || pad > AliHLTTransform::GetNPads(padrow) || time < -1 || time > AliHLTTransform::GetNTimeBins())
            {
-           cerr<<"AliL3DataCompressor::ReadUncompressData : Wrong pad "<<pad<<" or time "<<time<<" on row "<<padrow<<" track index "<<i<<endl;
+           cerr<<"AliHLTDataCompressor::ReadUncompressData : Wrong pad "<<pad<<" or time "<<time<<" on row "<<padrow<<" track index "<<i<<endl;
            track->Print();
            exit(5);
            }
          */
          if(ncl[slice] >= kmaxpoints)
            {
-             cerr<<"AliL3DataCompressor::ReadUncompressedData : Too many clusters"<<endl;
+             cerr<<"AliHLTDataCompressor::ReadUncompressedData : Too many clusters"<<endl;
              exit(5);
            }
          clusters[slice][ncl[slice]].fPad = pad;
@@ -892,20 +892,20 @@ void AliL3DataCompressor::ReadUncompressedData(TempCluster **clusters,Int_t *ncl
   delete comp;
 }
 
-void AliL3DataCompressor::ReadRemaining(TempCluster **clusters,Int_t *ncl,const Int_t kmaxpoints)
+void AliHLTDataCompressor::ReadRemaining(TempCluster **clusters,Int_t *ncl,const Int_t kmaxpoints)
 {
   // reads remaining clusters  
   cout<<"Reading remaining clusters "<<endl;
   if(!fNoCompression)
     {
-      AliL3Compress *comp = new AliL3Compress(-1,-1,fPath,fWriteClusterShape,fEvent);
+      AliHLTCompress *comp = new AliHLTCompress(-1,-1,fPath,fWriteClusterShape,fEvent);
       comp->ExpandRemaining(clusters,ncl,kmaxpoints);
       delete comp;
       return;
     }
   else
     {
-      AliL3MemHandler mem;
+      AliHLTMemHandler mem;
       Char_t filename[1024];
       for(Int_t slice=0; slice<=35; slice++)
        {
@@ -914,45 +914,45 @@ void AliL3DataCompressor::ReadRemaining(TempCluster **clusters,Int_t *ncl,const
              sprintf(filename,"%s/comp/remains_%d_%d_%d.raw",fPath,fEvent,slice,-1);
          
              mem.SetBinaryInput(filename);
-             AliL3RemainingRow *tempPt = (AliL3RemainingRow*)mem.Allocate();
+             AliHLTRemainingRow *tempPt = (AliHLTRemainingRow*)mem.Allocate();
          
              Int_t nrows=0;
              FILE *infile = mem.GetFilePointer();
              while(!feof(infile))
                {
                  Byte_t *dPt = (Byte_t*)tempPt;
-                 if(fread(tempPt,sizeof(AliL3RemainingRow),1,infile)!=1) break;
+                 if(fread(tempPt,sizeof(AliHLTRemainingRow),1,infile)!=1) break;
              
-                 dPt += sizeof(AliL3RemainingRow);
+                 dPt += sizeof(AliHLTRemainingRow);
              
-                 Int_t size = sizeof(AliL3RemainingCluster)*tempPt->fNClusters;
+                 Int_t size = sizeof(AliHLTRemainingCluster)*tempPt->fNClusters;
              
                  fread(dPt,size,1,infile);
                  dPt += size;
-                 tempPt = (AliL3RemainingRow*)dPt;
+                 tempPt = (AliHLTRemainingRow*)dPt;
                  nrows++;
                }
          
              mem.CloseBinaryInput();
              UInt_t dummy;
-             tempPt = (AliL3RemainingRow*)mem.GetDataPointer(dummy);
+             tempPt = (AliHLTRemainingRow*)mem.GetDataPointer(dummy);
          
              for(Int_t i=0; i<nrows; i++)
                {
-                 AliL3RemainingCluster *points = tempPt->fClusters;
+                 AliHLTRemainingCluster *points = tempPt->fClusters;
                  Int_t padrow = (Int_t)tempPt->fPadRow;
                  //Int_t sector,row;
-                 //AliL3Transform::Slice2Sector(slice,padrow,sector,row);
+                 //AliHLTTransform::Slice2Sector(slice,padrow,sector,row);
                  //cout<<"Loading slice "<<slice<<" row "<<padrow<<" with "<<(Int_t)tempPt->fNClusters<<" clusters "<<endl;
                  for(Int_t j=0; j<tempPt->fNClusters; j++)
                    {
                  
-                     //Float_t xyz[3] = {AliL3Transform::Row2X(padrow),points[j].fY,points[j].fZ};
-                     //AliL3Transform::Local2Raw(xyz,sector,row);
+                     //Float_t xyz[3] = {AliHLTTransform::Row2X(padrow),points[j].fY,points[j].fZ};
+                     //AliHLTTransform::Local2Raw(xyz,sector,row);
                  
                      if(ncl[slice] >= kmaxpoints)
                        {
-                         cerr<<"AliL3DataCompressor::ReadRemaining : Too many clusters"<<endl;
+                         cerr<<"AliHLTDataCompressor::ReadRemaining : Too many clusters"<<endl;
                          exit(5);
                        }
                      //cout<<"slice "<<slice<<" padrow "<<padrow<<" pad "<<xyz[1]<<" time "<<xyz[2]<<endl;
@@ -966,9 +966,9 @@ void AliL3DataCompressor::ReadRemaining(TempCluster **clusters,Int_t *ncl,const
                      ncl[slice]++;
                    }
                  Byte_t *dPt = (Byte_t*)tempPt;
-                 Int_t size = sizeof(AliL3RemainingRow) + tempPt->fNClusters*sizeof(AliL3RemainingCluster);
+                 Int_t size = sizeof(AliHLTRemainingRow) + tempPt->fNClusters*sizeof(AliHLTRemainingCluster);
                  dPt += size;
-                 tempPt = (AliL3RemainingRow*)dPt;
+                 tempPt = (AliHLTRemainingRow*)dPt;
                }
          
              mem.Free();
@@ -977,7 +977,7 @@ void AliL3DataCompressor::ReadRemaining(TempCluster **clusters,Int_t *ncl,const
     }
 }
 
-void AliL3DataCompressor::QSort(TempCluster **a, Int_t first, Int_t last)
+void AliHLTDataCompressor::QSort(TempCluster **a, Int_t first, Int_t last)
 {
   // Implementation of quick sort
   static TempCluster *tmp;
@@ -1016,7 +1016,7 @@ void AliL3DataCompressor::QSort(TempCluster **a, Int_t first, Int_t last)
    }
 }
 
-Int_t AliL3DataCompressor::Compare(TempCluster *a,TempCluster *b)
+Int_t AliHLTDataCompressor::Compare(TempCluster *a,TempCluster *b)
 {
   // compares two clusters
   if(a->fPadrow < b->fPadrow) return -1;
similarity index 74%
rename from HLT/comp/AliL3DataCompressor.h
rename to HLT/comp/AliHLTDataCompressor.h
index a67bcf3..7effe6c 100644 (file)
@@ -1,14 +1,14 @@
 // @(#) $Id$
 
-#ifndef AliL3_DataCompressor
-#define AliL3_DataCompressor
+#ifndef AliHLT_DataCompressor
+#define AliHLT_DataCompressor
 
-#include "AliL3RootTypes.h"
+#include "AliHLTRootTypes.h"
 
-class AliL3SpacePointData;
-class AliL3Benchmark;
-class AliL3TrackArray;
-class AliL3Track;
+class AliHLTSpacePointData;
+class AliHLTBenchmark;
+class AliHLTTrackArray;
+class AliHLTTrack;
 
 #ifdef use_root
 class TH2F;
@@ -24,12 +24,12 @@ struct TempCluster {
   Int_t fPadrow; // Pad row
 };
 
-class AliL3DataCompressor {
+class AliHLTDataCompressor {
   
  public:
-  AliL3DataCompressor();
-  AliL3DataCompressor(Char_t *path,Bool_t keep,Bool_t writeshape);
-  virtual ~AliL3DataCompressor();
+  AliHLTDataCompressor();
+  AliHLTDataCompressor(Char_t *path,Bool_t keep,Bool_t writeshape);
+  virtual ~AliHLTDataCompressor();
   
   virtual void LoadData(Int_t event,Bool_t sp=kTRUE);
   virtual void FillData(Int_t minhits,Bool_t expand);
@@ -56,9 +56,9 @@ class AliL3DataCompressor {
   Bool_t fNoCompression; //Just process the data through the chain, but do not compress. (input=output). Mostly for debugging...
 
  private:
-  AliL3Benchmark *fBenchmark;    //! Benchmark
-  AliL3TrackArray *fInputTracks; //! Array of input tracks
-  AliL3SpacePointData *fClusters[36][6]; //! Array of pointers to clusters
+  AliHLTBenchmark *fBenchmark;    //! Benchmark
+  AliHLTTrackArray *fInputTracks; //! Array of input tracks
+  AliHLTSpacePointData *fClusters[36][6]; //! Array of pointers to clusters
   ofstream *fCompRatioFile;      //! Stream to write the ration between use and unused clusters
 #ifdef use_root
   TFile *fOutputFile;            //! Output file
@@ -68,7 +68,7 @@ class AliL3DataCompressor {
   UInt_t fNcl[36][6]; // Array containing numbers of clusters
    
   void SelectRemainingClusters();
-  void ExpandTrackData(AliL3TrackArray *tracks);
+  void ExpandTrackData(AliHLTTrackArray *tracks);
   void ReadUncompressedData(TempCluster **clusters,Int_t *ncl,const Int_t maxpoints);
   void ReadRemaining(TempCluster **clusters,Int_t *ncl,const Int_t maxpoints);
   void QSort(TempCluster **a, Int_t first, Int_t last);
@@ -76,8 +76,10 @@ class AliL3DataCompressor {
   void OpenOutputFile();
   void CloseOutputFile();
   
-  ClassDef(AliL3DataCompressor,1) 
+  ClassDef(AliHLTDataCompressor,1) 
 
 };
 
+typedef AliHLTDataCompressor AliL3DataCompressor; // for backward compatibility
+
 #endif
diff --git a/HLT/comp/AliHLTDataCompressorHelper.cxx b/HLT/comp/AliHLTDataCompressorHelper.cxx
new file mode 100644 (file)
index 0000000..8d80fe0
--- /dev/null
@@ -0,0 +1,170 @@
+// @(#) $Id$
+
+// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
+//*-- Copyright &copy ALICE HLT Group
+
+#include "AliHLTStandardIncludes.h"
+
+#include "AliHLTRootTypes.h"
+#include "AliHLTTransform.h"
+
+#include "AliHLTDataCompressorHelper.h"
+
+#if __GNUC__ >= 3
+using namespace std;
+#endif
+
+//_____________________________________________________________
+//
+//  AliHLTDataCompression
+//
+// Interface class; binary <-> AliROOT handling of TPC data compression classes.
+//
+
+
+ClassImp(AliHLTDataCompressorHelper)
+
+
+Int_t AliHLTDataCompressorHelper::fgNumTimeBits = 12;
+Int_t AliHLTDataCompressorHelper::fgNumPadBits = 12;
+Int_t AliHLTDataCompressorHelper::fgNumChargeBits = 14;
+Int_t AliHLTDataCompressorHelper::fgNumShapeBits = 14;
+Float_t AliHLTDataCompressorHelper::fgXYResidualStep1 = 0.03;
+Float_t AliHLTDataCompressorHelper::fgXYResidualStep2 = 0.03;
+Float_t AliHLTDataCompressorHelper::fgXYResidualStep3 = 0.03;
+Float_t AliHLTDataCompressorHelper::fgZResidualStep1 = 0.05;
+Float_t AliHLTDataCompressorHelper::fgZResidualStep2 = 0.05;
+Float_t AliHLTDataCompressorHelper::fgZResidualStep3 = 0.05;
+Float_t AliHLTDataCompressorHelper::fgXYWidthStep = 0.005;
+Float_t AliHLTDataCompressorHelper::fgZWidthStep = 0.005;
+Int_t AliHLTDataCompressorHelper::fgClusterCharge = 100;
+Int_t AliHLTDataCompressorHelper::fgNumPadBitsRemaining = 18;
+Int_t AliHLTDataCompressorHelper::fgNumTimeBitsRemaining = 19;
+Int_t AliHLTDataCompressorHelper::fgNumShapeBitsRemaining = 11;
+
+void AliHLTDataCompressorHelper::SetBitNumbers(Int_t pad,Int_t time,Int_t charge,Int_t shape)
+{
+  // sets the numbers of bits
+  fgNumPadBits = pad;
+  fgNumTimeBits = time;
+  fgNumChargeBits = charge;
+  fgNumShapeBits = shape;
+}
+
+void AliHLTDataCompressorHelper::SetTransverseResolutions(Float_t res1,Float_t res2,Float_t res3,Float_t width)
+{
+  // sets the transverse resolution
+  fgXYResidualStep1 = res1;
+  fgXYResidualStep2 = res2;
+  fgXYResidualStep3 = res3;
+  fgXYWidthStep = width;
+}
+
+void AliHLTDataCompressorHelper::SetLongitudinalResolutions(Float_t res1,Float_t res2,Float_t res3,Float_t width)
+{
+  // sets the longitudinal resolution
+  fgZResidualStep1 = res1;
+  fgZResidualStep2 = res2;
+  fgZResidualStep3 = res3;
+  fgZWidthStep = width;
+}
+
+void AliHLTDataCompressorHelper::SetRemainingBitNumbers(Int_t pad,Int_t time,Int_t shape)
+{
+  // sets the numbers of remaining bits
+  fgNumPadBitsRemaining = pad;
+  fgNumTimeBitsRemaining = time;
+  fgNumShapeBitsRemaining = shape;
+}
+
+Float_t AliHLTDataCompressorHelper::GetXYResidualStep(Int_t row) 
+{
+  // gets the XY residual step
+  if(row < AliHLTTransform::GetNRowLow())
+    return fgXYResidualStep1;
+  else if(row < AliHLTTransform::GetNRowLow() + AliHLTTransform::GetNRowUp1())
+    return fgXYResidualStep2;
+  else if(row < AliHLTTransform::GetNRowLow() + AliHLTTransform::GetNRowUp1() + AliHLTTransform::GetNRowUp2())
+    return fgXYResidualStep3;
+  else
+    {
+      cerr<<"AliHLTDataCompressorHelper::GetXYResidualStep : Wrong row number "<<row<<endl;
+      return -1;
+    }
+}
+
+Float_t AliHLTDataCompressorHelper::GetZResidualStep(Int_t row) 
+{
+  // gets the Z residual step
+  if(row < AliHLTTransform::GetNRowLow())
+    return fgZResidualStep1;
+  else if(row < AliHLTTransform::GetNRowLow() + AliHLTTransform::GetNRowUp1())
+    return fgZResidualStep2;
+  else if(row < AliHLTTransform::GetNRowLow() + AliHLTTransform::GetNRowUp1() + AliHLTTransform::GetNRowUp2())
+    return fgZResidualStep3;
+  else
+    {
+      cerr<<"AliHLTDataCompressorHelper::GetXYResidualStep : Wrong row number "<<row<<endl;
+      return -1;
+    }
+}
+
+Float_t AliHLTDataCompressorHelper::GetPadPrecisionFactor()
+{
+  // gets pad precision factor
+  Int_t nbits = fgNumPadBitsRemaining;
+  if(nbits >=21)
+    return 10000;
+  if(nbits >= 18)
+    return 1000;
+  if(nbits >= 14) 
+    return 100;
+  if(nbits >= 11)
+    return 10;
+  if(nbits >= 8)
+    return 1;
+  else 
+    {
+      cerr<<"AliHLTDataCompressorHelper::GetRemainingPadFactor : Too few bits for the pad direction: "<<nbits<<endl;
+      return 1;
+    }
+}
+
+Float_t AliHLTDataCompressorHelper::GetTimePrecisionFactor()
+{
+  // gest time precision factor
+  Int_t nbits = fgNumTimeBitsRemaining;
+  if(nbits >=23)
+    return 10000;
+  if(nbits >= 19)
+    return 1000;
+  if(nbits >= 16) 
+    return 100;
+  if(nbits >= 13)
+    return 10;
+  if(nbits >= 9)
+    return 1;
+  else 
+    {
+      cerr<<"AliHLTDataCompressorHelper::GetRemainingPadFactor : Too few bits for the pad direction: "<<nbits<<endl;
+      return 1;
+    }
+}
+
+
+Int_t AliHLTDataCompressorHelper::Nint(Double_t x)
+{
+   // Round to nearest integer. Rounds half integers 
+   // to the nearest even integer.
+
+   Int_t i=0;
+   if (x >= 0) {
+      i = Int_t(x + 0.5);
+      if (x + 0.5 == Double_t(i) && i & 1) i--;
+   } else {
+      i = Int_t(x - 0.5);
+      if (x - 0.5 == Double_t(i) && i & 1) i++;
+
+   }
+   return i;
+}
similarity index 88%
rename from HLT/comp/AliL3DataCompressorHelper.h
rename to HLT/comp/AliHLTDataCompressorHelper.h
index 58b5e5f..88085df 100644 (file)
@@ -1,14 +1,14 @@
 // @(#) $Id$
 
-#ifndef AliL3_DataCompressorHelper
-#define AliL3_DataCompressorHelper
+#ifndef AliHLT_DataCompressorHelper
+#define AliHLT_DataCompressorHelper
 
-#include "AliL3RootTypes.h"
+#include "AliHLTRootTypes.h"
 
-class AliL3DataCompressorHelper {
+class AliHLTDataCompressorHelper {
   
  public:
-  virtual ~AliL3DataCompressorHelper() {}
+  virtual ~AliHLTDataCompressorHelper() {}
 
   static void SetBitNumbers(Int_t pad,Int_t time,Int_t charge,Int_t shape);
   static void SetTransverseResolutions(Float_t res1,Float_t res2,Float_t res3,Float_t width=0.005);
@@ -54,8 +54,10 @@ class AliL3DataCompressorHelper {
   static Int_t fgClusterCharge; // Cluster charge
 
 
-  ClassDef(AliL3DataCompressorHelper,1) 
+  ClassDef(AliHLTDataCompressorHelper,1) 
 
 };
 
+typedef AliHLTDataCompressorHelper AliL3DataCompressorHelper; // for backward compatibility
+
 #endif
similarity index 99%
rename from HLT/comp/AliL3FitUtilities.c
rename to HLT/comp/AliHLTFitUtilities.c
index 3639874..4853598 100644 (file)
@@ -4,7 +4,7 @@
 #include <stdlib.h>
 #include <math.h>
 #include <setjmp.h>
-#include "AliL3FitUtilities.h"
+#include "AliHLTFitUtilities.h"
 
 jmp_buf env;
 
similarity index 96%
rename from HLT/comp/AliL3FitUtilities.h
rename to HLT/comp/AliHLTFitUtilities.h
index 9e71163..6b22e36 100644 (file)
@@ -1,7 +1,7 @@
 /*@(#) $Id$*/
 
-#ifndef AliL3FitUtilities
-#define AliL3FitUtilities
+#ifndef AliHLTFitUtilities
+#define AliHLTFitUtilities
 
 /*This we do because this file is read both with c and c++ compiler, 
   and extern "C" is needed only in case of c++. */
diff --git a/HLT/comp/AliHLTModelTrack.cxx b/HLT/comp/AliHLTModelTrack.cxx
new file mode 100644 (file)
index 0000000..7867c89
--- /dev/null
@@ -0,0 +1,683 @@
+// @(#) $Id$
+
+// Author: Anders Vestbo <mailto:vestbo$fi.uib.no>
+//*-- Copyright &copy ALICE HLT Group
+//_____________________________________________________________
+// AliHLTModelTrack
+//
+// 
+
+
+#include "AliHLTStandardIncludes.h"
+
+#include "AliHLTLogging.h"
+#include "AliHLTTransform.h"
+#include "AliHLTVertex.h"
+#include "AliHLTDataCompressorHelper.h"
+
+#include "AliHLTModelTrack.h"
+
+#if __GNUC__ >= 3
+using namespace std;
+#endif
+
+ClassImp(AliHLTModelTrack)
+
+AliHLTModelTrack::AliHLTModelTrack() 
+{
+  // default constructor
+  fNClusters = 0;
+  fClusters = 0;
+  fOverlap = 0;
+  fPad=0;
+  fTime=0;
+  fNoverlaps=0;
+  fClusterCharge=0;
+  fTrackModel=0;
+  fCrossingAngle=0;
+  fParSigmaY2=0;
+  fParSigmaZ2=0;
+  fArraysCreated=kFALSE;
+}
+
+
+AliHLTModelTrack::~AliHLTModelTrack()
+{
+  // destructor
+  DeleteArrays();
+}
+
+void AliHLTModelTrack::DeleteArrays()
+{
+  // deletes all arrays
+  if(fClusters)
+    delete [] fClusters;
+  if(fPad)
+    delete [] fPad;
+  if(fTime)
+    delete [] fTime;
+  if(fCrossingAngle)
+    delete [] fCrossingAngle;
+  if(fParSigmaY2)
+    delete [] fParSigmaY2;
+  if(fParSigmaZ2)
+    delete [] fParSigmaZ2;
+  if(fTrackModel)
+    delete fTrackModel;
+  if(fNoverlaps)
+    delete [] fNoverlaps;
+  if(fOverlap)
+    {
+      for(Int_t i=0; i<AliHLTTransform::GetNRows(fPatch); i++)
+       delete [] fOverlap[i];
+      delete [] fOverlap;
+    }
+  fArraysCreated=kFALSE;
+}
+
+void AliHLTModelTrack::Init(Int_t /*slice*/,Int_t patch)
+{
+  // Initialization
+  if(fArraysCreated)
+    {               
+      DeleteArrays();
+    }
+  fNClusters=AliHLTTransform::GetNRows(patch);
+  fPatch=patch;
+  Int_t nrows = AliHLTTransform::GetNRows(fPatch);
+  fClusters = new AliHLTClusterModel[nrows];
+  fPad = new Float_t[nrows];
+  fTime = new Float_t[nrows];
+  fCrossingAngle = new Float_t[nrows];
+  fParSigmaY2 = new Float_t[nrows];
+  fParSigmaZ2 = new Float_t[nrows];
+  fTrackModel = new AliHLTTrackModel;
+  
+  fOverlap = new Int_t*[nrows];
+  fNoverlaps = new Int_t[nrows];
+  fMaxOverlaps = 5;
+  
+  memset(fNoverlaps,0,nrows*sizeof(Int_t));
+  memset(fClusters,0,nrows*sizeof(AliHLTClusterModel));
+  memset(fPad,0,nrows*sizeof(Float_t));
+  memset(fTime,0,nrows*sizeof(Float_t));
+  memset(fCrossingAngle,0,nrows*sizeof(Float_t));
+  memset(fParSigmaY2,0,nrows*sizeof(Float_t));
+  memset(fParSigmaZ2,0,nrows*sizeof(Float_t));
+  memset(fTrackModel,0,sizeof(AliHLTTrackModel));
+  for(Int_t i=0; i<nrows; i++)
+    {
+      fOverlap[i] = new Int_t[fMaxOverlaps];
+      for(Int_t j=0; j<fMaxOverlaps; j++)
+       fOverlap[i][j]=-1;
+      fClusters[i].fSlice = -1;
+    }
+  fArraysCreated=kTRUE;
+}
+
+
+
+void AliHLTModelTrack::CalculateClusterWidths(Int_t row,Bool_t parametrize)
+{
+  //Cluster widths
+  
+  Float_t xyz[3];
+  Int_t sr,lr;
+  Int_t index = row - AliHLTTransform::GetFirstRow(fPatch);
+  if(index < 0 || index > AliHLTTransform::GetNRows(fPatch))
+    {
+      cerr<<"AliHLTModelTrack::CalculcateClusterWidths : Wrond index "<<index<<" row "<<row<<endl;
+      return;
+    }
+  Int_t patch = AliHLTTransform::GetPatch(row);
+  AliHLTTransform::Slice2Sector(0,row,sr,lr);
+  AliHLTTransform::Raw2Local(xyz,sr,lr,GetPadHit(row),GetTimeHit(row));
+  fParSigmaY2[index] = AliHLTTransform::GetParSigmaY2(row,xyz[2],GetCrossingAngleLUT(row));
+  fParSigmaZ2[index] = AliHLTTransform::GetParSigmaZ2(row,xyz[2],GetTgl());
+  
+  if(parametrize)
+    {
+      fParSigmaY2[index] = (fParSigmaY2[index] + (1./12)*pow(AliHLTTransform::GetPadPitchWidth(patch),2) );
+      fParSigmaY2[index] *= 0.108;
+      if(patch<2)
+       fParSigmaY2[index] *= 2.07;
+     
+      fParSigmaZ2[index] = (fParSigmaZ2[index] + (1./12)*pow(AliHLTTransform::GetZWidth(),2) );
+      fParSigmaZ2[index] *= 0.169;
+      if(patch<2)
+       fParSigmaZ2[index] *= 1.77;
+    }
+  
+  //convert to raw coordinates:
+  fParSigmaY2[index] /= pow(AliHLTTransform::GetPadPitchWidth(patch),2);
+  fParSigmaZ2[index] /= pow(AliHLTTransform::GetZWidth(),2);
+}
+
+void AliHLTModelTrack::SetCluster(Int_t row,Float_t fpad,Float_t ftime,Float_t charge,
+                                Float_t sigmaY2,Float_t sigmaZ2,Int_t npads)
+{
+  AliHLTClusterModel *cl = GetClusterModel(row);
+  
+  //First bit: Cluster is present or not
+  //Second bit: Cluster was set, meaning an fit attempt was done (if true)
+  
+  cl->fPresent |= 0x2; //set second bit to true, because a fit attempt has been made
+  
+  Int_t patch = AliHLTTransform::GetPatch(row);
+  if(!charge || npads == 1)
+    {
+      cl->fPresent &= ~0x1; //set first bit to false
+    }
+  else
+    {
+      cl->fPresent|=0x1;//set first bit to true
+      cl->fDPad = (fpad - GetPadHit(row))/(AliHLTDataCompressorHelper::GetXYResidualStep(row)/AliHLTTransform::GetPadPitchWidth(patch));
+      cl->fDTime = (ftime - GetTimeHit(row))/(AliHLTDataCompressorHelper::GetZResidualStep(row)/AliHLTTransform::GetZWidth());
+      cl->fDCharge = charge;
+      if(sigmaY2==0 && sigmaZ2==0)
+       {
+         cl->fDSigmaY=0;//if width is zero, shape is not supposed to be written
+         cl->fDSigmaZ=0;
+       }
+      else
+       {
+         //cl->fDSigmaY2 = (sigmaY2 - GetParSigmaY2(row))/(pow(AliHLTDataCompressorHelper::GetXYWidthStep(),2)/pow(AliHLTTransform::GetPadPitchWidth(patch),2));
+         //cl->fDSigmaZ2 = (sigmaZ2 - GetParSigmaZ2(row))/(pow(AliHLTDataCompressorHelper::GetZWidthStep(),2)/pow(AliHLTTransform::GetZWidth(),2));
+         cl->fDSigmaY = (sqrt(sigmaY2) - sqrt(GetParSigmaY2(row)))/(AliHLTDataCompressorHelper::GetXYWidthStep()/AliHLTTransform::GetPadPitchWidth(patch));
+         cl->fDSigmaZ = (sqrt(sigmaZ2) - sqrt(GetParSigmaZ2(row)))/(AliHLTDataCompressorHelper::GetZWidthStep()/AliHLTTransform::GetZWidth());
+       }
+      cl->fNPads = npads;
+    }
+}
+
+
+void AliHLTModelTrack::Set(AliHLTTrack *tpt)
+{
+  // Sets track and does initialization
+  AliHLTModelTrack *tr = (AliHLTModelTrack*)tpt;
+  SetRowRange(tr->GetFirstRow(),tr->GetLastRow());
+  SetPhi0(tr->GetPhi0());
+  SetKappa(tr->GetKappa());
+  SetFirstPoint(tr->GetFirstPointX(),tr->GetFirstPointY(),tr->GetFirstPointZ());
+  SetLastPoint(tr->GetLastPointX(),tr->GetLastPointY(),tr->GetLastPointZ());
+  SetPt(tr->GetPt());
+  SetPsi(tr->GetPsi());
+  SetTgl(tr->GetTgl());
+  SetCharge(tr->GetCharge());
+  
+  if(fClusters)
+    {
+      cerr<<"AliHLTModelTrack::Set : Init has already been called for this object!"<<endl;
+      return;
+    }
+
+  //Init(tr->fSlice,tr->fPatch);
+  Init(0,tr->fPatch);
+  memcpy(fClusters,tr->fClusters,AliHLTTransform::GetNRows(fPatch)*sizeof(AliHLTClusterModel));
+  memcpy(fPad,tr->fPad,AliHLTTransform::GetNRows(fPatch)*sizeof(Float_t));
+  memcpy(fTime,tr->fTime,AliHLTTransform::GetNRows(fPatch)*sizeof(Float_t));
+  memcpy(fParSigmaY2,tr->fParSigmaY2,AliHLTTransform::GetNRows(fPatch)*sizeof(Float_t));
+  memcpy(fParSigmaZ2,tr->fParSigmaZ2,AliHLTTransform::GetNRows(fPatch)*sizeof(Float_t));
+  memcpy(fCrossingAngle,tr->fCrossingAngle,AliHLTTransform::GetNRows(fPatch)*sizeof(Float_t));
+  memcpy(fTrackModel,tr->fTrackModel,sizeof(AliHLTTrackModel));
+
+}
+
+Int_t AliHLTModelTrack::GetNPresentClusters()
+{
+  //Return the number of assigned clusters to the track.
+  //Differs from fNClusters, which should be equal to the 
+  //number of padrows in the present patch.
+  
+  Int_t count=0;
+
+  for(Int_t i=AliHLTTransform::GetFirstRow(fPatch); i<=AliHLTTransform::GetLastRow(fPatch); i++)
+    if(IsPresent(i))
+      count++;
+
+  return count;
+}
+
+void AliHLTModelTrack::FillModel()
+{
+  //Fill the track structure
+  
+  if(fNClusters != AliHLTTransform::GetNRows(fPatch))
+    {
+      cout<<"AliHLTModelTrack::FillModel : fNClusters != nrows; beware, this could be caused by a bug!!!"<<endl;
+      fNClusters = AliHLTTransform::GetNRows(fPatch);
+    }
+
+  if(!fTrackModel)
+    {
+      cerr<<"AliHLTModelTrack::FillModel() : No trackmodel "<<endl;
+      return;
+    }
+  Double_t impact[3];
+  AliHLTVertex vertex;
+  CalculateHelix();
+  GetClosestPoint(&vertex,impact[0],impact[1],impact[2]);
+  fTrackModel->fKappa = GetKappa();
+  fTrackModel->fPhi = atan2(impact[1],impact[0]);
+  fTrackModel->fD = sqrt(impact[0]*impact[0] + impact[1]*impact[1]);
+  fTrackModel->fZ0 = impact[2];
+  fTrackModel->fTgl = GetTgl();
+  
+  //We have to check on which of the vertex the track fit is lying
+  //This we need to encode the azimuthal angle coordinate of the center of curvature.
+  if(GetRadius() < sqrt(GetCenterX()*GetCenterX()+GetCenterY()*GetCenterY()))
+    fTrackModel->fD *=-1;
+  
+}
+
+void AliHLTModelTrack::FillTrack()
+{
+  //Fill the track parameters from the structure.
+  
+  if(!fTrackModel)
+    {
+      cerr<<"AliHLTModelTrack::FillTrack() : No data!!"<<endl;
+      return;
+    }
+  SetKappa(fTrackModel->fKappa);
+  Double_t impact[3],psi;
+  Float_t trackPhi0 = fTrackModel->fPhi;
+  if(fTrackModel->fD < 0)
+    trackPhi0 += AliHLTTransform::Pi();
+  Int_t charge = -1*(Int_t)copysign(1.,GetKappa());
+  impact[0] = fabs(fTrackModel->fD)*cos(fTrackModel->fPhi);
+  impact[1] = fabs(fTrackModel->fD)*sin(fTrackModel->fPhi);
+  impact[2] = fTrackModel->fZ0;
+
+  psi = trackPhi0 - charge*0.5*AliHLTTransform::Pi();
+  if(psi < 0) 
+    psi += 2*AliHLTTransform::Pi();
+
+  SetCharge(charge);
+  SetFirstPoint(impact[0],impact[1],impact[2]);
+  SetPsi(psi);
+  SetTgl(fTrackModel->fTgl);
+  SetPt((AliHLTTransform::GetBFact()*AliHLTTransform::GetBField())/fabs(GetKappa()));
+  fNClusters = AliHLTTransform::GetNRows(fPatch);
+  CalculateHelix();
+  
+  for(Int_t i=AliHLTTransform::GetFirstRow(fPatch); i<=AliHLTTransform::GetLastRow(fPatch); i++)
+    {
+      AliHLTClusterModel *cl = GetClusterModel(i);
+      if(!cl) continue;
+
+      if(cl->fSlice == -1)
+       {
+         SetPadHit(i,-1);
+         SetTimeHit(i,-1);
+         continue;
+       }
+      if(cl->fSlice < 0 || cl->fSlice > 35)
+       {
+         cerr<<"AliHLTModelTrack::FillTrack : Slice out of range "<<cl->fSlice<<" on row "<<i<<endl;
+         exit(5);
+       }
+      
+      Float_t angle = 0;
+      
+      AliHLTTransform::Local2GlobalAngle(&angle,cl->fSlice);
+      if(!CalculateReferencePoint(angle,AliHLTTransform::Row2X(i)))
+       {
+         if(IsPresent(i))
+           {
+             cerr<<"AliHLTModelTrack::FillTrack : Track does not cross slice "<<cl->fSlice<<" row "<<i<<" Points "
+                 <<GetPointX()<<" "<<GetPointY()<<" "<<GetPointZ()<<endl;
+             Print();
+             exit(5);
+           }
+         SetPadHit(i,-1);
+         SetTimeHit(i,-1);
+         continue;
+       }
+      Float_t hit[3] = {GetPointX(),GetPointY(),GetPointZ()};
+      Int_t sector,row;
+      AliHLTTransform::Slice2Sector(cl->fSlice,i,sector,row);
+      AliHLTTransform::Global2Raw(hit,sector,row);
+
+      SetPadHit(i,hit[1]);
+      SetTimeHit(i,hit[2]);
+
+      Float_t crossingangle = GetCrossingAngle(i,cl->fSlice);
+      
+      SetCrossingAngleLUT(i,crossingangle);
+      CalculateClusterWidths(i,kTRUE);
+      
+    }