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))
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)
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)
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");
// @(#) $Id$
-// Original file : src/AliL3StandardIncludes.h,v 1.5
+// Original file : src/AliHLTStandardIncludes.h,v 1.5
#ifndef ALIHLTSTDINCLUDESH
#define ALIHLTSTDINCLUDESH
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
--- /dev/null
+
+#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
* 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>
// 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();
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;
}
//______________________________________________________________________
-AliESDVertex* AliL3ITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTree *tR){
+AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTree *tR){
// Defines the AliESDVertex for the current event
fCurrentVertex = 0;
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
// 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);
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
#include <TMath.h>
-#include "AliL3ITStrack.h"
+#include "AliHLTITStrack.h"
-ClassImp(AliL3ITStrack)
+ClassImp(AliHLTITStrack)
//____________________________________________________________________________
-AliL3ITStrack::AliL3ITStrack()
+AliHLTITStrack::AliHLTITStrack()
:AliITStrackV2()
{
//------------------------------------------------------------------
}
//____________________________________________________________________________
-AliL3ITStrack::AliL3ITStrack(AliESDtrack& t)
+AliHLTITStrack::AliHLTITStrack(AliESDtrack& t)
:AliITStrackV2(t)
{
//------------------------------------------------------------------
}
//____________________________________________________________________________
-AliL3ITStrack::AliL3ITStrack(const AliL3ITStrack& t)
+AliHLTITStrack::AliHLTITStrack(const AliHLTITStrack& t)
: AliITStrackV2(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();
#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
//-------------------------------------------------------------------------
#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) {
//--------------------------------------------------------------------
return 0;
}
-Int_t AliL3ITStracker::Clusters2Tracks(AliESD *event) {
+Int_t AliHLTITStracker::Clusters2Tracks(AliESD *event) {
//--------------------------------------------------------------------
// This functions reconstructs HLT ITS tracks
//--------------------------------------------------------------------
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;
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);
return 0;
}
-Int_t AliL3ITStracker::PropagateBack(AliESD *event) {
+Int_t AliHLTITStracker::PropagateBack(AliESD *event) {
//--------------------------------------------------------------------
// This functions propagates reconstructed ITS tracks back
//--------------------------------------------------------------------
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
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
+++ /dev/null
-
-#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
#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();
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;}
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();
$(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 $@ $<
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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. *
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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>
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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_
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// $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
// @(#) $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
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
//$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 © Uli
// @(#) $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
// @(#) $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 © ALICE HLT Group
//_____________________________________________________________
// @(#) $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
// @(#) $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
// @(#) $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
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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_
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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
// @(#) $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 © ALICE HLT Group
// @(#) $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
// @(#) $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>
// 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
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
// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
//*-- Copyright © 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;
fEvent=0;
}
-AliL3ClusterFitter::AliL3ClusterFitter(Char_t *path)
+AliHLTClusterFitter::AliHLTClusterFitter(Char_t *path)
{
// constructor
strcpy(fPath,path);
fEvent=0;
}
-AliL3ClusterFitter::~AliL3ClusterFitter()
+AliHLTClusterFitter::~AliHLTClusterFitter()
{
// destructor
if(fSeeds)
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;
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]);
{
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);
}
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);
}
// 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();
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]);
}
}
-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;
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();
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);
//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;
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:
}
//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;
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;
}
}
- 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();
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);
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;
}
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;
fFailed++;
}
}
- AliL3MemHandler::UpdateRowPointer(rowPt);
+ AliHLTMemHandler::UpdateRowPointer(rowPt);
}
fSeeding = kTRUE;
}
-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;
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;
}
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;
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;
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;
{
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;
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;
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;
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;
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);
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
//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;
//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 "
{
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;
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;
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))
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;
//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);
//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++;
}
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.
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);
}
}
-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
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();
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;
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);
}
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;
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;
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];
}
}
-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)
{
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);
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];
// @(#) $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();
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
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
--- /dev/null
+// @(#) $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
+
//*-- Copyright © 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;
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;
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];
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:
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++;
}
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.
}
else
{
- cerr<<"AliL3Compress::ReadFile() : Wrong option"<<endl;
+ cerr<<"AliHLTCompress::ReadFile() : Wrong option"<<endl;
return kFALSE;
}
}
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();
}
return kTRUE;
}
-Bool_t AliL3Compress::CompressFile()
+Bool_t AliHLTCompress::CompressFile()
{
// compresses file
Char_t fname[100];
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;
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;
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);
}
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);
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)
{
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++;
return kTRUE;
}
-Bool_t AliL3Compress::ExpandFile()
+Bool_t AliHLTCompress::ExpandFile()
{
// expands file
Char_t fname[100];
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;
//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;
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;
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++)
{
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;
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
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);
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
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]++;
}
}
-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++)
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;
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
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));
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]++;
--- /dev/null
+// @(#) $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
//*-- Copyright © 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;
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;
fCode=0;
}
-AliL3CompressAC::~AliL3CompressAC()
+AliHLTCompressAC::~AliHLTCompressAC()
{
// destructor
ClearArrays();
}
-void AliL3CompressAC::ClearArrays()
+void AliHLTCompressAC::ClearArrays()
{
// cleans all arrays
fMax=0;
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.
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)
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.
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
fTotals[fMax+2] = fTotals[fMax+1]+1;//Used for the scale
}
-void AliL3CompressAC::PrintTotals() const
+void AliHLTCompressAC::PrintTotals() const
{
// prints totals
cout<<"Totals:"<<endl;
}
}
-void AliL3CompressAC::InitEncoder()
+void AliHLTCompressAC::InitEncoder()
{
// inits the encoder
fLow = 0;
fUnderflowBits=0;
}
-void AliL3CompressAC::InitDecoder(BIT_FILE *input)
+void AliHLTCompressAC::InitDecoder(BIT_FILE *input)
{
// inits the decoder
fCode=0;
fHigh = 0xffff;
}
-void AliL3CompressAC::ConvertIntToSymbol(Int_t value)
+void AliHLTCompressAC::ConvertIntToSymbol(Int_t value)
{
// converst integer to symbol
UInt_t range = fHigh - fLow + 1;
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;
return j;
}
-void AliL3CompressAC::EncodeSymbol(BIT_FILE *output)
+void AliHLTCompressAC::EncodeSymbol(BIT_FILE *output)
{
// encodes symbol
while(1)
}
}
-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;
}
}
-void AliL3CompressAC::FlushEncoder(BIT_FILE *output)
+void AliHLTCompressAC::FlushEncoder(BIT_FILE *output)
{
//Flush the encoder:
OutputBit(output,fLow & 0x4000);
}
-Bool_t AliL3CompressAC::CompressFile()
+Bool_t AliHLTCompressAC::CompressFile()
{
// comresses file
Char_t fname[100];
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;
//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);
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);
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);
}
//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);
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]++;
}
{
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));
}
if(counter != clustercount[i])
{
- cerr<<"AliL3CompressAC::CompressFile : Mismatching clustercount "<<counter<<" "<<clustercount[i]<<endl;
+ cerr<<"AliHLTCompressAC::CompressFile : Mismatching clustercount "<<counter<<" "<<clustercount[i]<<endl;
exit(5);
}
return kTRUE;
}
-Bool_t AliL3CompressAC::ExpandFile()
+Bool_t AliHLTCompressAC::ExpandFile()
{
// expands file
Char_t fname[100];
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;
}
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);
}
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;
}
//Read charge information:
- temp=InputBits(input,(AliL3DataCompressorHelper::GetNChargeBits()));
+ temp=InputBits(input,(AliHLTDataCompressorHelper::GetNChargeBits()));
clusters[i][j].fDCharge = temp;
//Read sign information of the residuals:
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;
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;
if(count != clustercount[i])
{
- cerr<<"AliL3CompressAC::ExpandFile : Mismatching clustercount "<<count<<" "<<clustercount[i]<<endl;
+ cerr<<"AliHLTCompressAC::ExpandFile : Mismatching clustercount "<<count<<" "<<clustercount[i]<<endl;
exit(5);
}
}
//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);
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++)
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;
// @(#) $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();
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
//*-- Copyright © 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>
#include <TH2F.h>
#endif
-#include "AliL3DataCompressorHelper.h"
-#include "AliL3DataCompressor.h"
+#include "AliHLTDataCompressorHelper.h"
+#include "AliHLTDataCompressor.h"
#include <math.h>
#if __GNUC__ == 3
#endif
-ClassImp(AliL3DataCompressor)
+ClassImp(AliHLTDataCompressor)
-AliL3DataCompressor::AliL3DataCompressor()
+AliHLTDataCompressor::AliHLTDataCompressor()
{
// default constructor
fBenchmark=0;
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;
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
OpenOutputFile();
}
-AliL3DataCompressor::~AliL3DataCompressor()
+AliHLTDataCompressor::~AliHLTDataCompressor()
{
// destructor
if(fInputTracks)
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];
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());
#endif
}
-void AliL3DataCompressor::CloseOutputFile()
+void AliHLTDataCompressor::CloseOutputFile()
{
// closes the output file
if(fCompRatioFile)
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++)
{
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();
//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;
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());
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);
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]);
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.
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))
{
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) );
{
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]);
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;
}
-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;
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)
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
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;
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++)
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));
}
Int_t size =0;
Byte_t *data = 0;
- AliL3RemainingRow *tempPt=0;
+ AliHLTRemainingRow *tempPt=0;
Int_t lastRow = -2;
Int_t localcounter=0;
{
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);
}
}
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;
}
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;
}
}
-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:
//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;
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:
}
-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;
}
-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
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;
}
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++)
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;
}
}
#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;
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);
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;
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++)
{
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;
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();
}
}
-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;
}
}
-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;
// @(#) $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;
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);
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
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);
void OpenOutputFile();
void CloseOutputFile();
- ClassDef(AliL3DataCompressor,1)
+ ClassDef(AliHLTDataCompressor,1)
};
+typedef AliHLTDataCompressor AliL3DataCompressor; // for backward compatibility
+
#endif
--- /dev/null
+// @(#) $Id$
+
+// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
+//*-- Copyright © 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;
+}
// @(#) $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);
static Int_t fgClusterCharge; // Cluster charge
- ClassDef(AliL3DataCompressorHelper,1)
+ ClassDef(AliHLTDataCompressorHelper,1)
};
+typedef AliHLTDataCompressorHelper AliL3DataCompressorHelper; // for backward compatibility
+
#endif
#include <stdlib.h>
#include <math.h>
#include <setjmp.h>
-#include "AliL3FitUtilities.h"
+#include "AliHLTFitUtilities.h"
jmp_buf env;
/*@(#) $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++. */
--- /dev/null
+// @(#) $Id$
+
+// Author: Anders Vestbo <mailto:vestbo$fi.uib.no>
+//*-- Copyright © 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);
+
+ }
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff