}
-#ifdef use_root
+
void AliL3Histogram::Draw(Char_t *option)
{
+#ifdef use_root
fRootHisto = new TH2F(fName,"",fNxbins,fXmin,fXmax,fNybins,fYmin,fYmax);
for(Int_t bin=0; bin<fNcells; bin++)
{
}
fRootHisto->Draw(option);
+ return;
+#endif
+ cerr<<"AliL3Histogram::Draw : You need to compile with ROOT in order to draw histogram"<<endl;
}
-#endif
+
#ifndef ALIL3_HISTOGRAM
#define ALIL3_HISTOGRAM
+#include <stream.h>
#include "AliL3RootTypes.h"
+
#ifdef use_root
#include <TH2.h>
#endif
void AddBinContent(Int_t bin,Int_t weight);
void Add(AliL3Histogram *h1,Double_t weight=1);
void SetThreshold(Int_t i) {fThreshold = i;}
+ void Draw(Char_t *option="hist");
#ifdef use_root
- void Draw(Char_t *option="hist");
- TH2F *GetRootHisto() {return fRootHisto;}
+ TH2F *GetRootHisto();
+#else
+ void *GetRootHisto();
#endif
Double_t GetXmin() {return fXmin;}
};
+#ifdef use_root
+inline TH2F *AliL3Histogram::GetRootHisto()
+{
+ if(!fRootHisto)
+ {
+ cerr<<"AliL3Histogram::GetRootHisto() : You must first Draw histogram before accessing it"<<endl;
+ return 0;
+ }
+ else
+ return fRootHisto;
+}
+#else
+inline void *AliL3Histogram::GetRootHisto()
+{
+ cerr<<"AliL3Histogram::GetRootHisto() : You must compile with ROOT in order to interface the ROOT histogram"<<endl;
+ return 0;
+}
+#endif
+
#endif
//_____________________________________________________________
// AliL3Hough
//
-// Base class for the Hough transform
+// Interface class for the Hough transform
//
-
+// Example how to use:
+//
+// AliL3Hough *hough = new AliL3Hough(path,kTRUE,NumberOfEtaSegments);
+// hough->ReadData(slice);
+// hough->Transform();
+// hough->FindTrackCandidates();
+//
+// AliL3TrackArray *tracks = hough->GetTracks(patch);
ClassImp(AliL3Hough)
fDoIterative = kFALSE;
fWriteDigits=kFALSE;
fNPatches=0;
+ fMemHandler = 0;
+ fHoughTransformer = 0;
+ fEval = 0;
+ fPeakFinder = 0;
+ fTracks = 0;
+ fMerger = 0;
+ fInterMerger = 0;
+ fGlobalMerger = 0;
+ fTransform = 0;
}
AliL3Hough::AliL3Hough(Char_t *path,Bool_t binary,Int_t n_eta_segments)
{
+ //Default ctor.
+
fBinary = binary;
strcpy(fPath,path);
fNEtaSegments = n_eta_segments;
AliL3Hough::~AliL3Hough()
{
+ //dtor
+
CleanUp();
if(fMerger)
delete fMerger;
delete fPeakFinder;
if(fGlobalMerger)
delete fGlobalMerger;
+ if(fTransform)
+ delete fTransform;
}
void AliL3Hough::CleanUp()
void AliL3Hough::Init()
{
+ fPeakThreshold = 0;
fNPatches = NPatches;
- fHoughTransformer = new AliL3HoughTransformer*[fNPatches];
+ fTransform = new AliL3Transform(fPath);
+ fHoughTransformer = new AliL3HoughBaseTransformer*[fNPatches];
#ifdef use_aliroot
fMemHandler = new AliL3FileHandler*[fNPatches];
#else
for(Int_t i=0; i<fNPatches; i++)
{
fHoughTransformer[i] = new AliL3HoughTransformer(1,i,fNEtaSegments);
- fHoughTransformer[i]->CreateHistograms(64,-0.003,0.003,64,-0.26,0.26);
+ fHoughTransformer[i]->SetTransformer(fTransform);
+ //fHoughTransformer[i]->CreateHistograms(64,-0.003,0.003,64,-0.26,0.26);
+ fHoughTransformer[i]->CreateHistograms(64,0.1,64,-30,30);
fHoughTransformer[i]->SetThreshold(3);
fEval[i] = new AliL3HoughEval();
fTracks[i] = new AliL3TrackArray("AliL3HoughTrack");
fPeakFinder = new AliL3HoughMaxFinder("KappaPhi");
fMerger = new AliL3HoughMerger(fNPatches);
fInterMerger = new AliL3HoughIntMerger();
+ fGlobalMerger = 0;
}
void AliL3Hough::Process(Int_t minslice,Int_t maxslice)
}
}
-void AliL3Hough::Transform()
+void AliL3Hough::Transform(Int_t row_range)
{
//Transform all data given to the transformer within the given slice
//(after ReadData(slice))
for(Int_t i=0; i<fNPatches; i++)
{
fHoughTransformer[i]->Reset();//Reset the histograms
- fHoughTransformer[i]->TransformCircle();
+ if(row_range < 0)
+ fHoughTransformer[i]->TransformCircle();
+ else
+ fHoughTransformer[i]->TransformCircleC(row_range);
}
}
{
if(fAddHistograms) //Nothing to merge here
return;
- AliL3Transform *tr = new AliL3Transform();
- fMerger->SetTransformer(tr);
+ fMerger->SetTransformer(fTransform);
fMerger->MergePatches(kTRUE);
- delete tr;
}
void AliL3Hough::MergeInternally()
//transform + peakfinding + evaluation + transform +...
Int_t num_of_tries = 10;
- AliL3HoughTransformer *tr = fHoughTransformer[patch];
+ AliL3HoughBaseTransformer *tr = fHoughTransformer[patch];
AliL3TrackArray *tracks = fTracks[patch];
tracks->Reset();
AliL3HoughEval *ev = fEval[patch];
hist = tr->GetHistogram(i);
if(hist->GetNEntries()==0) continue;
fPeakFinder->SetHistogram(hist);
- Int_t n=1;
+ //Int_t n=1;
Float_t x,y;
//fPeakFinder->FindAbsMaxima(*x,*y);
fPeakFinder->FindPeak(3,0.95,5,x,y);
n_patches = 1; //Histograms has been added.
else
n_patches = fNPatches;
+
for(Int_t i=0; i<n_patches; i++)
{
- AliL3HoughTransformer *tr = fHoughTransformer[i];
+ AliL3HoughBaseTransformer *tr = fHoughTransformer[i];
+ Double_t eta_slice = (tr->GetEtaMax()-tr->GetEtaMin()/tr->GetNEtaSegments());
fTracks[i]->Reset();
for(Int_t j=0; j<fNEtaSegments; j++)
{
AliL3Histogram *hist = tr->GetHistogram(j);
if(hist->GetNEntries()==0) continue;
fPeakFinder->SetHistogram(hist);
- Int_t n=10;
- Float_t x[10];
- Float_t y[10];
- Int_t weight[10];
- fPeakFinder->FindPeak1(x,y,weight,n,1);
+ fPeakFinder->SetThreshold(fPeakThreshold);
+ Int_t n=20;
+ Float_t x[n];
+ Float_t y[n];
+ Int_t weight[n];
+ //fPeakFinder->FindPeak1(x,y,weight,n,2,1);
+ fPeakFinder->FindMaxima(x,y,weight,n);
for(Int_t k=0; k<n; k++)
{
if(weight[k] == 0) continue;
+
AliL3HoughTrack *track = (AliL3HoughTrack*)fTracks[i]->NextTrack();
track->SetTrackParameters(x[k],y[k],weight[k]);
track->SetEtaIndex(j);
- track->SetEta((Double_t)(j*tr->GetEtaSlice()));
+ track->SetEta((Double_t)(j*eta_slice));
track->SetRowRange(NRows[0][0],NRows[5][1]);
}
}
for(Int_t i=0; i<fNPatches; i++)
{
fEval[i]->InitTransformer(fHoughTransformer[i]);
+ continue;
fEval[i]->SetNumOfRowsToMiss(2);
fEval[i]->SetNumOfPadsToLook(road_width);
if(fAddHistograms)
#include "AliL3RootTypes.h"
class AliL3HoughMaxFinder;
-class AliL3HoughTransformer;
+class AliL3HoughBaseTransformer;
class AliL3Histogram;
class AliL3MemHandler;
class AliL3FileHandler;
class AliL3HoughMerger;
class AliL3HoughIntMerger;
class AliL3HoughGlobalMerger;
+class AliL3Transform;
class AliL3Hough {
Bool_t fWriteDigits;
Int_t fNEtaSegments;
Int_t fNPatches;
+ Int_t fPeakThreshold;
#ifdef use_aliroot
AliL3FileHandler **fMemHandler; //!
#else
AliL3MemHandler **fMemHandler; //!
#endif
- AliL3HoughTransformer **fHoughTransformer; //!
+ AliL3HoughBaseTransformer **fHoughTransformer; //!
AliL3HoughEval **fEval; //!
AliL3HoughMaxFinder *fPeakFinder; //!
AliL3TrackArray **fTracks; //!
AliL3HoughMerger *fMerger; //!
AliL3HoughIntMerger *fInterMerger; //!
AliL3HoughGlobalMerger *fGlobalMerger; //!
+ AliL3Transform *fTransform; //!
void CleanUp();
void Init();
void Process(Int_t minslice,Int_t maxslice);
void ReadData(Int_t slice);
- void Transform();
+ void Transform(Int_t row_range = -1);
void ProcessSliceIter();
void ProcessPatchIter(Int_t patch);
void MergePatches();
void SetAddHistograms() {fAddHistograms = kTRUE;}
void DoIterative() {fDoIterative = kTRUE;}
void SetWriteDigits() {fWriteDigits = kTRUE;}
+ void SetPeakThreshold(Int_t i) {fPeakThreshold = i;}
//Getters
- AliL3HoughTransformer *GetTransformer(Int_t i) {if(!fHoughTransformer[i]) return 0; return fHoughTransformer[i];}
+ AliL3HoughBaseTransformer *GetTransformer(Int_t i) {if(!fHoughTransformer[i]) return 0; return fHoughTransformer[i];}
AliL3TrackArray *GetTracks(Int_t i) {if(!fTracks[i]) return 0; return fTracks[i];}
AliL3HoughEval *GetEval(Int_t i) {if(!fEval[i]) return 0; return fEval[i];}
AliL3HoughMerger *GetMerger() {if(!fMerger) return 0; return fMerger;}
// AliL3HoughBaseTransformer
//
// The base class for implementations of Hough Transform on ALICE TPC data.
+//
+// This is an abstract class, and is only meant to provide the interface
+// to the different implementations.
ClassImp(AliL3HoughBaseTransformer)
//Default constructor
fTransform = 0;
fDigitRowData = 0;
-
}
AliL3HoughBaseTransformer::AliL3HoughBaseTransformer(Int_t slice,Int_t patch,Int_t n_eta_segments)
fNEtaSegments = n_eta_segments;
fEtaMin = 0;
fEtaMax = fSlice < 18 ? 0.9 : -0.9;
- fTransform = new AliL3Transform();
fThreshold = 0;
- fDigitRowData=0;
+ fDigitRowData = 0;
+ fTransform = 0;
}
AliL3HoughBaseTransformer::~AliL3HoughBaseTransformer()
{
- if(fTransform)
- delete fTransform;
-}
+}
protected:
AliL3Transform *fTransform; //!
-
+
public:
AliL3HoughBaseTransformer();
AliL3HoughBaseTransformer(Int_t slice,Int_t patch,Int_t n_eta_segments);
virtual ~AliL3HoughBaseTransformer();
+ void SetTransformer(AliL3Transform *tr) {fTransform = tr;}
void SetInputData(UInt_t ndigits,AliL3DigitRowData *ptr) {fDigitRowData = ptr;}
virtual void CreateHistograms(Int_t nxbin,Double_t ptmin,Int_t nybin,Double_t phimin,Double_t phimax) = 0;
#include "AliL3TrackArray.h"
#include "AliL3Logging.h"
#include "AliL3HoughEval.h"
-#include "AliL3HoughTransformer.h"
+#include "AliL3HoughBaseTransformer.h"
#include "AliL3DigitData.h"
#include "AliL3HoughTrack.h"
#include "AliL3Transform.h"
}
}
-void AliL3HoughEval::InitTransformer(AliL3HoughTransformer *transformer)
+void AliL3HoughEval::InitTransformer(AliL3HoughBaseTransformer *transformer)
{
fHoughTransformer = transformer;
fSlice = fHoughTransformer->GetSlice();
#include "AliL3RootTypes.h"
-class AliL3HoughTransformer;
+class AliL3HoughBaseTransformer;
class AliL3Transform;
class AliL3HoughTrack;
class AliL3DigitRowData;
Bool_t fRemoveFoundTracks;
AliL3Transform *fTransform; //!
- AliL3HoughTransformer *fHoughTransformer; //!
+ AliL3HoughBaseTransformer *fHoughTransformer; //!
AliL3DigitRowData **fRowPointers; //!
public:
AliL3HoughEval();
virtual ~AliL3HoughEval();
- void InitTransformer(AliL3HoughTransformer *transformer);
+ void InitTransformer(AliL3HoughBaseTransformer *transformer);
void GenerateLUT();
void DisplayEtaSlice(Int_t eta_index,AliL3Histogram *hist);
Bool_t LookInsideRoad(AliL3HoughTrack *track,Int_t eta_index,Bool_t remove=kFALSE);
fWeight = 0;
fMinDist=0;
- fTransform = new AliL3Transform();
fDLine = 0;
fPsiLine = 0;
fIsHelix = true;
AliL3HoughTrack::~AliL3HoughTrack()
{
- //Destructor
- if(fTransform)
- delete fTransform;
+
}
void AliL3HoughTrack::Set(AliL3Track *track)
//Transform line parameters to coordinate system of slice:
+ /*
D = D + fTransform->Row2X(ref_row)*cos(psi);
fDLine = D;
SetNHits(weight);
SetRowRange(rowrange[0],rowrange[1]);
fIsHelix = false;
-
+ */
}
void AliL3HoughTrack::SetBestMCid(Int_t mcid,Double_t min_dist)
void AliL3HoughTrack::GetLineCrossingPoint(Int_t padrow,Double_t *xy)
{
-
+ /*
if(fIsHelix)
{
printf("AliL3HoughTrack::GetLineCrossingPoint : Track is not a line\n");
Double_t yhit = a*xhit + b;
xy[0] = xhit;
xy[1] = yhit;
-
+ */
}
/*
#include "AliL3Track.h"
-class AliL3Transform;
-
class AliL3HoughTrack : public AliL3Track {
private:
-
- AliL3Transform *fTransform; //!
+
Double_t fMinDist;
Int_t fWeight;
Int_t fEtaIndex;
AliL3HoughTransformer::AliL3HoughTransformer(Int_t slice,Int_t patch,Int_t n_eta_segments) : AliL3HoughBaseTransformer(slice,patch,n_eta_segments)
{
//Normal constructor
-
- fParamSpace = 0;
+ fParamSpace = 0;
}
AliL3HoughTransformer::~AliL3HoughTransformer()
AliL3DigitRowData *tempPt = GetDataPointer();
if(!tempPt)
{
- printf("\nAliL3HoughTransformer::TransformCircle : No input data!!!\n\n");
+ LOG(AliL3Log::kError,"AliL3HoughTransformer::TransformCircle","Data")
+ <<"No input data "<<ENDLOG;
+ return;
+ }
+ if(!fTransform)
+ {
+ LOG(AliL3Log::kError,"AliL3HoughTransformer::TransformCircle","Transformer")
+ <<"No AliL3Transform object"<<ENDLOG;
return;
}
AliL3DigitRowData *tempPt = GetDataPointer();
if(!tempPt)
- printf("\nAliL3HoughTransformer::TransformCircleC() : Zero data pointer\n");
+ LOG(AliL3Log::kError,"AliL3HoughTransformer::TransformCircleC","Data")
+ <<"No input data "<<ENDLOG;
+
+ if(!fTransform)
+ {
+ LOG(AliL3Log::kError,"AliL3HoughTransformer::TransformCircleC","Transformer")
+ <<"No AliL3Transform object"<<ENDLOG;
+ return;
+ }
Int_t counter=0;
for(Int_t i=NRows[GetPatch()][0]; i<=NRows[GetPatch()][1]; i++)
AliL3DigitRowData *tempPt = GetDataPointer();
if(!tempPt)
{
- printf("\nAliL3HoughTransformer::TransformLine : No input data!!!\n\n");
+ LOG(AliL3Log::kError,"AliL3HoughTransformer::TransformLine","Data")
+ <<"No input data "<<ENDLOG;
+ return;
+ }
+ if(!fTransform)
+ {
+ LOG(AliL3Log::kError,"AliL3HoughTransformer::TransformLine","Transformer")
+ <<"No AliL3Transform object"<<ENDLOG;
return;
}
AliL3Histogram *GetHistogram(Int_t eta_index);
- ClassDef(AliL3HoughTransformer,1) //Hough transformation class
+ ClassDef(AliL3HoughTransformer,1) //Normal Hough transformation class
};
SRCS = AliL3HoughTransformer.cxx AliL3Hough.cxx AliL3HoughTrack.cxx\
AliL3HoughMaxFinder.cxx AliL3HoughEval.cxx AliL3HoughMerger.cxx \
- AliL3Histogram.cxx AliL3Histogram1D.cxx \
+ AliL3Histogram.cxx AliL3Histogram1D.cxx AliL3HoughBaseTransformer.cxx \
AliL3HoughIntMerger.cxx AliL3HoughGlobalMerger.cxx
DICT = AliL3HoughCint.cxx