#include "AliL3HoughClusterTransformer.h"
#include "AliL3HoughTransformerLUT.h"
#include "AliL3HoughTransformerVhdl.h"
+#include "AliL3HoughTransformerRow.h"
#include "AliL3HoughMaxFinder.h"
#include "AliL3Benchmark.h"
#ifdef use_aliroot
#include "AliL3TrackArray.h"
#include "AliL3HoughTrack.h"
#include "AliL3DDLDataFileHandler.h"
+#include "AliL3HoughKalmanTrack.h"
-#if GCCVERSION == 3
+#include "TThread.h"
+
+#if __GNUC__ == 3
using namespace std;
#endif
// hough->FindTrackCandidates();
//
// AliL3TrackArray *tracks = hough->GetTracks(patch);
+//
//</pre>
*/
fNEtaSegments = 0;
fNPatches = 0;
+ fLastPatch =-1;
fVersion = 0;
fCurrentSlice = 0;
fEvent = 0;
-
+
+ fKappaSpread = 6;
+ fPeakRatio = 0.5;
+ fInputFile = 0;
+ fInputPtr = 0;
+ fRawEvent = 0;
+
SetTransformerParams();
SetThreshold();
SetNSaveIterations();
#ifdef use_aliroot
//just be sure that index is empty for new event
AliL3FileHandler::CleanStaticIndex();
+#ifdef use_newio
+ fRunLoader = 0;
+#endif
#endif
+ fThread = 0;
}
-AliL3Hough::AliL3Hough(Char_t *path,Bool_t binary,Int_t n_eta_segments,Bool_t bit8,Int_t tv,Char_t *infile)
+AliL3Hough::AliL3Hough(Char_t *path,Bool_t binary,Int_t netasegments,Bool_t bit8,Int_t tv,Char_t *infile,Char_t *ptr)
{
+ //Normal constructor
fBinary = binary;
strcpy(fPath,path);
- fNEtaSegments = n_eta_segments;
+ fNEtaSegments = netasegments;
fAddHistograms = kFALSE;
fDoIterative = kFALSE;
fWriteDigits = kFALSE;
fUse8bits = bit8;
fVersion = tv;
- if(!fBinary)
- fInputFile = infile;
- else
+ fKappaSpread=6;
+ fPeakRatio=0.5;
+ if(!fBinary) {
+ if(infile) {
+ fInputFile = infile;
+ fInputPtr = 0;
+ }
+ else {
+ fInputFile = 0;
+ fInputPtr = ptr;
+ }
+ }
+ else {
fInputFile = 0;
-
+ fInputPtr = 0;
+ }
#ifdef use_aliroot
//just be sure that index is empty for new event
AliL3FileHandler::CleanStaticIndex();
+#ifdef use_newio
+ fRunLoader = 0;
+#endif
#endif
+ fThread = 0;
}
AliL3Hough::~AliL3Hough()
if(fGlobalTracks)
delete fGlobalTracks;
//cout << "Cleaned class globaltracks " << endl;
+ if(fThread) {
+ // fThread->Delete();
+ delete fThread;
+ fThread = 0;
+ }
}
void AliL3Hough::CleanUp()
//cout << "Cleaned class mem " << endl;
}
-void AliL3Hough::Init(Char_t *path,Bool_t binary,Int_t n_eta_segments,Bool_t bit8,Int_t tv,Char_t *infile)
+void AliL3Hough::Init(Int_t netasegments,Int_t tv,AliRawEvent *rawevent,Float_t zvertex)
{
+ //Normal constructor
+ fNEtaSegments = netasegments;
+ fVersion = tv;
+ fRawEvent = rawevent;
+ fZVertex = zvertex;
+
+ Init();
+}
+
+void AliL3Hough::Init(Char_t *path,Bool_t binary,Int_t netasegments,Bool_t bit8,Int_t tv,Char_t *infile,Char_t *ptr,Float_t zvertex)
+{
+ //Normal init of the AliL3Hough
fBinary = binary;
strcpy(fPath,path);
- fNEtaSegments = n_eta_segments;
+ fNEtaSegments = netasegments;
fWriteDigits = kFALSE;
fUse8bits = bit8;
fVersion = tv;
- if(!fBinary)
- fInputFile = infile;
- else
+ if(!fBinary) {
+ if(infile) {
+ fInputFile = infile;
+ fInputPtr = 0;
+ }
+ else {
+ fInputFile = 0;
+ fInputPtr = ptr;
+ }
+ }
+ else {
fInputFile = 0;
+ fInputPtr = 0;
+ }
+ fZVertex = zvertex;
Init(); //do the rest
}
void AliL3Hough::Init(Bool_t doit, Bool_t addhists)
{
+ // Init
fDoIterative = doit;
fAddHistograms = addhists;
fNPatches = AliL3Transform::GetNPatches();
-
fHoughTransformer = new AliL3HoughBaseTransformer*[fNPatches];
fMemHandler = new AliL3MemHandler*[fNPatches];
fGlobalTracks = new AliL3TrackArray("AliL3HoughTrack");
+ AliL3HoughBaseTransformer *lasttransformer = 0;
+
for(Int_t i=0; i<fNPatches; i++)
{
switch (fVersion){ //choose Transformer
case 3:
fHoughTransformer[i] = new AliL3HoughTransformerVhdl(0,i,fNEtaSegments,fNSaveIterations);
break;
+ case 4:
+ fHoughTransformer[i] = new AliL3HoughTransformerRow(0,i,fNEtaSegments,kFALSE,fZVertex);
+ break;
default:
fHoughTransformer[i] = new AliL3HoughTransformer(0,i,fNEtaSegments,kFALSE,kFALSE);
}
- fHoughTransformer[i]->CreateHistograms(fNBinX[i],fLowPt[i],fNBinY[i],-fPhi[i],fPhi[i]);
+ fHoughTransformer[i]->SetLastTransformer(lasttransformer);
+ lasttransformer = fHoughTransformer[i];
+ // fHoughTransformer[i]->CreateHistograms(fNBinX[i],fLowPt[i],fNBinY[i],-fPhi[i],fPhi[i]);
+ fHoughTransformer[i]->CreateHistograms(fNBinX[i],-fLowPt[i],fLowPt[i],fNBinY[i],-fPhi[i],fPhi[i]);
//fHoughTransformer[i]->CreateHistograms(fLowPt[i],fUpperPt[i],fPtRes[i],fNBinY[i],fPhi[i]);
fHoughTransformer[i]->SetLowerThreshold(fThreshold[i]);
else
#ifdef use_aliroot
{
- if(!fInputFile) {
- /* In case of reading digits file */
- fMemHandler[i] = new AliL3FileHandler(kTRUE); //use static index
- if(!fBinary) {
- Char_t filename[1024];
- sprintf(filename,"%s/digitfile.root",fPath);
- fMemHandler[i]->SetAliInput(filename);
+ if(!fRawEvent) {
+ if(!fInputFile) {
+ if(!fInputPtr) {
+ /* In case of reading digits file */
+ fMemHandler[i] = new AliL3FileHandler(kTRUE); //use static index
+ if(!fBinary) {
+#if use_newio
+ if(!fRunLoader) {
+#endif
+ Char_t filename[1024];
+ sprintf(filename,"%s/digitfile.root",fPath);
+ fMemHandler[i]->SetAliInput(filename);
+#if use_newio
+ }
+ else {
+ fMemHandler[i]->SetAliInput(fRunLoader);
+ }
+#endif
+ }
+ }
+ else {
+ /* In case of reading from DATE */
+ fMemHandler[i] = new AliL3DDLDataFileHandler();
+ fMemHandler[i]->SetReaderInput(fInputPtr,-1);
+ }
+ }
+ else {
+ /* In case of reading rawdata from ROOT file */
+ fMemHandler[i] = new AliL3DDLDataFileHandler();
+ fMemHandler[i]->SetReaderInput(fInputFile);
}
}
else {
- /* In case of reading rawdata from ROOT file */
+ /* In case of reading rawdata using AliRawEvent */
fMemHandler[i] = new AliL3DDLDataFileHandler();
- fMemHandler[i]->SetReaderInput(fInputFile);
+ fMemHandler[i]->SetReaderInput(fRawEvent);
}
}
#else
#endif
}
- fPeakFinder = new AliL3HoughMaxFinder("KappaPhi",1000);
- fMerger = new AliL3HoughMerger(fNPatches);
- fInterMerger = new AliL3HoughIntMerger();
+ fPeakFinder = new AliL3HoughMaxFinder("KappaPhi",50000);
+ if(fVersion!=4) {
+ fMerger = new AliL3HoughMerger(fNPatches);
+ fInterMerger = new AliL3HoughIntMerger();
+ }
+ else {
+ fMerger = 0;
+ fInterMerger = 0;
+ }
fGlobalMerger = 0;
fBenchmark = new AliL3Benchmark();
}
void AliL3Hough::SetTransformerParams(Float_t ptres,Float_t ptmin,Float_t ptmax,Int_t ny,Int_t patch)
{
+ // Setup the parameters for the Hough Transformer
+ // This includes the bin size and limits for
+ // the parameter space histograms
Int_t mrow;
Float_t psi=0;
fNBinY[patch] = ny;
fPhi[patch] = psi;
}
-
+/*
void AliL3Hough::SetTransformerParams(Int_t nx,Int_t ny,Float_t ptmin,Int_t patch)
{
+ // Setup the parameters for the Hough Transformer
Int_t mrow=80;
Double_t lineradius = sqrt(pow(AliL3Transform::Row2X(mrow),2) + pow(AliL3Transform::GetMaxY(mrow),2));
i++;
}
}
+*/
+void AliL3Hough::SetTransformerParams(Int_t nx,Int_t ny,Float_t ptmin,Int_t /*patch*/)
+{
+ // Setup the parameters for the Hough Transformer
+
+ Double_t lineradius = 1.0/(AliL3HoughTransformerRow::GetBeta1()*sqrt(1.0+tan(AliL3Transform::Pi()*10/180)*tan(AliL3Transform::Pi()*10/180)));
+ Double_t alpha1 = AliL3HoughTransformerRow::GetBeta1()*tan(AliL3Transform::Pi()*10/180);
+ Double_t kappa = 1*AliL3Transform::GetBField()*AliL3Transform::GetBFact()/(ptmin*0.9);
+ Double_t psi = AliL3Transform::Deg2Rad(10) - asin(lineradius*kappa/2);
+ // cout<<"Calculated psi range "<<psi<<" in patch "<<patch<<endl;
+ Double_t alpha2 = alpha1 - (AliL3HoughTransformerRow::GetBeta1()-AliL3HoughTransformerRow::GetBeta2())*tan(psi);
+ // cout<<"Calculated alphas range "<<alpha1<<" "<<alpha2<<" in patch "<<patch<<endl;
+
+ Int_t i=0;
+ while(i < 6)
+ {
+ fLowPt[i] = 1.1*alpha1;
+ fNBinY[i] = ny;
+ fNBinX[i] = nx;
+ fPhi[i] = alpha2;
+ i++;
+ }
+}
+
+void AliL3Hough::CalcTransformerParams(Float_t ptmin)
+{
+ // Setup the parameters for the Row Hough Transformer
+ // Automatically adjusts the number of bins in X and Y in a way
+ // that the size of the hough bin is 2x (in X) and 2.5 (in Y) the
+ // size of the tpc pads
+
+ Double_t lineradius = 1.0/(AliL3HoughTransformerRow::GetBeta1()*sqrt(1.0+tan(AliL3Transform::Pi()*10/180)*tan(AliL3Transform::Pi()*10/180)));
+ Double_t alpha1 = AliL3HoughTransformerRow::GetBeta1()*tan(AliL3Transform::Pi()*10/180);
+ Double_t kappa = 1*AliL3Transform::GetBField()*AliL3Transform::GetBFact()/(ptmin*0.9);
+ Double_t psi = AliL3Transform::Deg2Rad(10) - asin(lineradius*kappa/2);
+ // cout<<"Calculated psi range "<<psi<<endl;
+ Double_t alpha2 = alpha1 - (AliL3HoughTransformerRow::GetBeta1()-AliL3HoughTransformerRow::GetBeta2())*tan(psi);
+ alpha1 *= 1.1;
+ // cout<<"Calculated alphas range "<<alpha1<<" "<<alpha2<<endl;
+
+ Double_t sizex = 2.0*AliL3Transform::GetPadPitchWidthLow()*AliL3HoughTransformerRow::GetBeta1()*AliL3HoughTransformerRow::GetBeta1();
+ Double_t sizey = 2.5*AliL3Transform::GetPadPitchWidthUp()*AliL3HoughTransformerRow::GetBeta2()*AliL3HoughTransformerRow::GetBeta2();
+
+ Int_t nx = 2*(Int_t)(alpha1/sizex)+1;
+ Int_t ny = 2*(Int_t)(alpha2/sizey)+1;
+ // cout<<"Calculated number of bins "<<nx<<" "<<ny<<endl;
+
+ Int_t i=0;
+ while(i < 6)
+ {
+ fLowPt[i] = alpha1;
+ fNBinY[i] = ny;
+ fNBinX[i] = nx;
+ fPhi[i] = alpha2;
+ i++;
+ }
+}
void AliL3Hough::SetTransformerParams(Int_t nx,Int_t ny,Float_t lpt,Float_t phi)
{
void AliL3Hough::SetThreshold(Int_t t3,Int_t patch)
{
+ // Set digits threshold
if(patch==-1)
{
Int_t i=0;
void AliL3Hough::SetPeakThreshold(Int_t threshold,Int_t patch)
{
+ // Set Peak Finder threshold
if(patch==-1)
{
Int_t i=0;
{
ReadData(i);
Transform();
- if(fAddHistograms)
- AddAllHistograms();
+ if(fAddHistograms) {
+ if(fVersion != 4)
+ AddAllHistograms();
+ else
+ AddAllHistogramsRows();
+ }
FindTrackCandidates();
//Evaluate();
//fGlobalMerger->FillTracks(fTracks[0],i);
if(fEvent!=eventnr) //just be sure that index is empty for new event
AliL3FileHandler::CleanStaticIndex();
#endif
- fEvent=eventnr;
fCurrentSlice = slice;
for(Int_t i=0; i<fNPatches; i++)
else //read data from root file
{
#ifdef use_aliroot
+ if(fEvent!=eventnr)
+ fMemHandler[i]->FreeDigitsTree();//or else the new event is not loaded
digits=(AliL3DigitRowData *)fMemHandler[i]->AliAltroDigits2Memory(ndigits,eventnr);
#else
cerr<<"You cannot read from rootfile now"<<endl;
#endif
}
+ //Set the pointer to the TPCRawStream in case of fast raw data reading
+ fHoughTransformer[i]->SetTPCRawStream(fMemHandler[i]->GetTPCRawStream());
+
//set input data and init transformer
fHoughTransformer[i]->SetInputData(ndigits,digits);
fHoughTransformer[i]->Init(slice,i,fNEtaSegments);
}
+
+ fEvent=eventnr;
}
-void AliL3Hough::Transform(Int_t *row_range)
+void AliL3Hough::Transform(Int_t *rowrange)
{
//Transform all data given to the transformer within the given slice
//(after ReadData(slice))
Double_t initTime,cpuTime;
initTime = GetCpuTime();
+ Int_t patchorder[6] = {5,2,0,1,3,4}; //The order in which patches are processed
+ // Int_t patchorder[6] = {0,1,2,3,4,5}; //The order in which patches are processed
+ // Int_t patchorder[6] = {5,4,3,2,1,0}; //The order in which patches are processed
+ // Int_t patchorder[6] = {5,2,4,3,1,0}; //The order in which patches are processed
+ fLastPatch=-1;
for(Int_t i=0; i<fNPatches; i++)
{
- fHoughTransformer[i]->Reset();//Reset the histograms
+ // In case of Row transformer reset the arrays only once
+ if((fVersion != 4) || (i == 0)) {
+ fBenchmark->Start("Hough Reset");
+ fHoughTransformer[0]->Reset();//Reset the histograms
+ fBenchmark->Stop("Hough Reset");
+ }
fBenchmark->Start("Hough Transform");
- if(!row_range)
- fHoughTransformer[i]->TransformCircle();
+ PrepareForNextPatch(patchorder[i]);
+ if(!rowrange) {
+ char buf[256];
+ sprintf(buf,"Patch %d",patchorder[i]);
+ fBenchmark->Start(buf);
+ fHoughTransformer[patchorder[i]]->SetLastPatch(fLastPatch);
+ fHoughTransformer[patchorder[i]]->TransformCircle();
+ fBenchmark->Stop(buf);
+ }
else
- fHoughTransformer[i]->TransformCircleC(row_range,1);
+ fHoughTransformer[i]->TransformCircleC(rowrange,1);
fBenchmark->Stop("Hough Transform");
+ fLastPatch=patchorder[i];
}
cpuTime = GetCpuTime() - initTime;
LOG(AliL3Log::kInformational,"AliL3Hough::Transform()","Timing")
void AliL3Hough::MergePatches()
{
+ // Merge patches if they are not summed
if(fAddHistograms) //Nothing to merge here
return;
fMerger->MergePatches(kTRUE);
void AliL3Hough::MergeInternally()
{
+ // Merge patches internally
if(fAddHistograms)
fInterMerger->FillTracks(fTracks[0]);
else
//Process patch in a iterative way.
//transform + peakfinding + evaluation + transform +...
- Int_t num_of_tries = 5;
+ Int_t numoftries = 5;
AliL3HoughBaseTransformer *tr = fHoughTransformer[patch];
AliL3TrackArray *tracks = fTracks[patch];
tracks->Reset();
ev->SetNumOfRowsToMiss(3);
ev->SetNumOfPadsToLook(2);
AliL3Histogram *hist;
- for(Int_t t=0; t<num_of_tries; t++)
+ for(Int_t t=0; t<numoftries; t++)
{
tr->Reset();
tr->TransformCircle();
<<"Adding histograms in "<<cpuTime*1000<<" ms"<<ENDLOG;
}
+void AliL3Hough::AddAllHistogramsRows()
+{
+ //Add the histograms within one etaslice.
+ //Resulting histogram are in patch=0.
+
+ Double_t initTime,cpuTime;
+ initTime = GetCpuTime();
+ fBenchmark->Start("Add HistogramsRows");
+
+ UChar_t lastpatchlastrow = AliL3Transform::GetLastRowOnDDL(fLastPatch)+1;
+
+ UChar_t *tracklastrow = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetTrackLastRow();
+
+ for(Int_t i=0; i<fNEtaSegments; i++)
+ {
+ UChar_t *gapcount = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetGapCount(i);
+ UChar_t *currentrowcount = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetCurrentRowCount(i);
+
+ AliL3Histogram *hist = fHoughTransformer[0]->GetHistogram(i);
+ Int_t xmin = hist->GetFirstXbin();
+ Int_t xmax = hist->GetLastXbin();
+ Int_t ymin = hist->GetFirstYbin();
+ Int_t ymax = hist->GetLastYbin();
+ Int_t nxbins = hist->GetNbinsX()+2;
+
+ for(Int_t ybin=ymin; ybin<=ymax; ybin++)
+ {
+ for(Int_t xbin=xmin; xbin<=xmax; xbin++)
+ {
+ Int_t bin = xbin + ybin*nxbins; //Int_t bin = hist->GetBin(xbin,ybin);
+ if(gapcount[bin] < MAX_N_GAPS) {
+ if(tracklastrow[bin] > lastpatchlastrow) {
+ if(lastpatchlastrow > currentrowcount[bin])
+ gapcount[bin] += (lastpatchlastrow-currentrowcount[bin]-1);
+ }
+ else {
+ if(tracklastrow[bin] > currentrowcount[bin])
+ gapcount[bin] += (tracklastrow[bin]-currentrowcount[bin]-1);
+ }
+ if(gapcount[bin] < MAX_N_GAPS)
+ hist->AddBinContent(bin,(159-gapcount[bin]));
+ }
+ }
+ }
+ }
+
+ fBenchmark->Stop("Add HistogramsRows");
+ fAddHistograms = kTRUE;
+ cpuTime = GetCpuTime() - initTime;
+ LOG(AliL3Log::kInformational,"AliL3Hough::AddAllHistogramsRows()","Timing")
+ <<"Adding histograms in "<<cpuTime*1000<<" ms"<<ENDLOG;
+}
+
+void AliL3Hough::PrepareForNextPatch(Int_t nextpatch)
+{
+ // Prepare the parameter space for the processing of
+ // the next read patch. According to the already
+ // accumulated number of gaps in parameter space
+ // bins, the routine updates the dynamic
+ // pointers used in order to jump rapidly during the
+ // filling of the parameter space.
+
+ char buf[256];
+ sprintf(buf,"Prepare For Patch %d",nextpatch);
+ fBenchmark->Start(buf);
+
+ UChar_t lastpatchlastrow;
+ if(fLastPatch == -1)
+ lastpatchlastrow = 0;
+ else
+ lastpatchlastrow = AliL3Transform::GetLastRowOnDDL(fLastPatch)+1;
+ UChar_t nextpatchfirstrow;
+ if(nextpatch==0)
+ nextpatchfirstrow = 0;
+ else
+ nextpatchfirstrow = AliL3Transform::GetFirstRowOnDDL(nextpatch)-1;
+
+ UChar_t *trackfirstrow = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetTrackFirstRow();
+ UChar_t *tracklastrow = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetTrackLastRow();
+
+ for(Int_t i=0; i<fNEtaSegments; i++)
+ {
+ UChar_t *gapcount = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetGapCount(i);
+ UChar_t *currentrowcount = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetCurrentRowCount(i);
+ UChar_t *prevbin = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetPrevBin(i);
+ UChar_t *nextbin = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetNextBin(i);
+ UChar_t *nextrow = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetNextRow(i);
+
+ AliL3Histogram *hist = fHoughTransformer[0]->GetHistogram(i);
+ Int_t xmin = hist->GetFirstXbin();
+ Int_t xmax = hist->GetLastXbin();
+ Int_t ymin = hist->GetFirstYbin();
+ Int_t ymax = hist->GetLastYbin();
+ Int_t nxbins = hist->GetNbinsX()+2;
+
+ if(fLastPatch != -1) {
+ UChar_t lastyvalue = 0;
+ Int_t endybin = ymin - 1;
+ for(Int_t ybin=nextrow[ymin]; ybin<=ymax; ybin = nextrow[++ybin])
+ {
+ UChar_t lastxvalue = 0;
+ UChar_t maxvalue = 0;
+ Int_t endxbin = xmin - 1;
+ for(Int_t xbin=xmin; xbin<=xmax; xbin++)
+ {
+ Int_t bin = xbin + ybin*nxbins;
+ UChar_t value = 0;
+ if(gapcount[bin] < MAX_N_GAPS) {
+ if(tracklastrow[bin] > lastpatchlastrow) {
+ if(lastpatchlastrow > currentrowcount[bin])
+ gapcount[bin] += (lastpatchlastrow-currentrowcount[bin]-1);
+ }
+ else {
+ if(tracklastrow[bin] > currentrowcount[bin])
+ gapcount[bin] += (tracklastrow[bin]-currentrowcount[bin]-1);
+ }
+ if(gapcount[bin] < MAX_N_GAPS) {
+ value = 1;
+ maxvalue = 1;
+ if(trackfirstrow[bin] < nextpatchfirstrow)
+ currentrowcount[bin] = nextpatchfirstrow;
+ else
+ currentrowcount[bin] = trackfirstrow[bin];
+ }
+ }
+ if(value > 0)
+ {
+ nextbin[xbin + ybin*nxbins] = (UChar_t)xbin;
+ prevbin[xbin + ybin*nxbins] = (UChar_t)xbin;
+ if(value > lastxvalue)
+ {
+ UChar_t *tempnextbin = nextbin + endxbin + 1 + ybin*nxbins;
+ memset(tempnextbin,(UChar_t)xbin,xbin-endxbin-1);
+ }
+ endxbin = xbin;
+ }
+ else
+ {
+ prevbin[xbin + ybin*nxbins] = (UChar_t)endxbin;
+ }
+ lastxvalue = value;
+ }
+ UChar_t *tempnextbin = nextbin + endxbin + 1 + ybin*nxbins;
+ memset(tempnextbin,(UChar_t)(xmax+1),xmax-endxbin);
+ if(maxvalue > 0)
+ {
+ nextrow[ybin] = (UChar_t)ybin;
+ if(maxvalue > lastyvalue)
+ {
+ UChar_t *tempnextrow = nextrow + endybin + 1;
+ memset(tempnextrow,(UChar_t)ybin,ybin-endybin-1);
+ }
+ endybin = ybin;
+ }
+ lastyvalue = maxvalue;
+ }
+ UChar_t *tempnextrow = nextrow + endybin + 1;
+ memset(tempnextrow,(UChar_t)(ymax+1),ymax-endybin+1);
+ }
+ else {
+ UChar_t lastyvalue = 0;
+ Int_t endybin = ymin - 1;
+ for(Int_t ybin=ymin; ybin<=ymax; ybin++)
+ {
+ UChar_t maxvalue = 0;
+ for(Int_t xbin=xmin; xbin<=xmax; xbin++)
+ {
+ Int_t bin = xbin + ybin*nxbins;
+ if(gapcount[bin] < MAX_N_GAPS) {
+ maxvalue = 1;
+ if(trackfirstrow[bin] < nextpatchfirstrow)
+ currentrowcount[bin] = nextpatchfirstrow;
+ else
+ currentrowcount[bin] = trackfirstrow[bin];
+ }
+ }
+ if(maxvalue > 0)
+ {
+ nextrow[ybin] = (UChar_t)ybin;
+ if(maxvalue > lastyvalue)
+ {
+ UChar_t *tempnextrow = nextrow + endybin + 1;
+ memset(tempnextrow,(UChar_t)ybin,ybin-endybin-1);
+ }
+ endybin = ybin;
+ }
+ lastyvalue = maxvalue;
+ }
+ UChar_t *tempnextrow = nextrow + endybin + 1;
+ memset(tempnextrow,(UChar_t)(ymax+1),ymax-endybin+1);
+ }
+ }
+
+ fBenchmark->Stop(buf);
+}
+
void AliL3Hough::AddTracks()
{
+ // Add current slice slice tracks to the global list of found tracks
if(!fTracks[0])
{
cerr<<"AliL3Hough::AddTracks : No tracks"<<endl;
fGlobalTracks->AddTracks(fTracks[0],0,fCurrentSlice);
}
-void AliL3Hough::FindTrackCandidates()
+void AliL3Hough::FindTrackCandidatesRow()
{
+ // Find AliL3HoughTransformerRow track candidates
+ if(fVersion != 4) {
+ LOG(AliL3Log::kError,"AliL3Hough::FindTrackCandidatesRow()","")
+ <<"Incompatible Peak Finder version!"<<ENDLOG;
+ return;
+ }
+
//Look for peaks in histograms, and find the track candidates
+ Int_t npatches;
+ if(fAddHistograms)
+ npatches = 1; //Histograms have been added.
+ else
+ npatches = fNPatches;
+
+ Double_t initTime,cpuTime;
+ initTime = GetCpuTime();
+ fBenchmark->Start("Find Maxima");
+ for(Int_t i=0; i<npatches; i++)
+ {
+ AliL3HoughBaseTransformer *tr = fHoughTransformer[i];
+ AliL3Histogram *h = tr->GetHistogram(0);
+ Float_t deltax = h->GetBinWidthX()*AliL3HoughTransformerRow::GetDAlpha();
+ Float_t deltay = h->GetBinWidthY()*AliL3HoughTransformerRow::GetDAlpha();
+ Float_t deltaeta = (tr->GetEtaMax()-tr->GetEtaMin())/tr->GetNEtaSegments()*AliL3HoughTransformerRow::GetDEta();
+ Float_t zvertex = tr->GetZVertex();
+ fTracks[i]->Reset();
+ fPeakFinder->Reset();
+
+ for(Int_t j=0; j<fNEtaSegments; j++)
+ {
+ AliL3Histogram *hist = tr->GetHistogram(j);
+ if(hist->GetNEntries()==0) continue;
+ fPeakFinder->SetHistogram(hist);
+ fPeakFinder->SetEtaSlice(j);
+ fPeakFinder->SetTrackLUTs(((AliL3HoughTransformerRow *)tr)->GetTrackNRows(),((AliL3HoughTransformerRow *)tr)->GetTrackFirstRow(),((AliL3HoughTransformerRow *)tr)->GetTrackLastRow(),((AliL3HoughTransformerRow *)tr)->GetNextRow(j));
+#ifdef do_mc
+ LOG(AliL3Log::kInformational,"AliL3Hough::FindTrackCandidates()","")
+ <<"Starting "<<j<<" etaslice"<<ENDLOG;
+#endif
+ fPeakFinder->SetThreshold(fPeakThreshold[i]);
+ fPeakFinder->FindAdaptedRowPeaks(1,0,0);//Maxima finder for HoughTransformerRow
+ }
- Int_t n_patches;
+ for(Int_t k=0; k<fPeakFinder->GetEntries(); k++)
+ {
+ // if(fPeakFinder->GetWeight(k) < 0) continue;
+ AliL3HoughTrack *track = (AliL3HoughTrack*)fTracks[i]->NextTrack();
+ Double_t starteta = tr->GetEta(fPeakFinder->GetStartEta(k),fCurrentSlice);
+ Double_t endeta = tr->GetEta(fPeakFinder->GetEndEta(k),fCurrentSlice);
+ Double_t eta = (starteta+endeta)/2.0;
+ track->SetTrackParametersRow(fPeakFinder->GetXPeak(k),fPeakFinder->GetYPeak(k),eta,fPeakFinder->GetWeight(k));
+ track->SetPterr(deltax); track->SetPsierr(deltay); track->SetTglerr(deltaeta);
+ track->SetBinXY(fPeakFinder->GetXPeak(k),fPeakFinder->GetYPeak(k),fPeakFinder->GetXPeakSize(k),fPeakFinder->GetYPeakSize(k));
+ track->SetZ0(zvertex);
+ Int_t etaindex = (fPeakFinder->GetStartEta(k)+fPeakFinder->GetEndEta(k))/2;
+ track->SetEtaIndex(etaindex);
+ Int_t rows[2];
+ ((AliL3HoughTransformerRow *)tr)->GetTrackLength(fPeakFinder->GetXPeak(k),fPeakFinder->GetYPeak(k),rows);
+ track->SetRowRange(rows[0],rows[1]);
+ track->SetSector(fCurrentSlice);
+ track->SetSlice(fCurrentSlice);
+#ifdef do_mc
+ Int_t label = tr->GetTrackID(etaindex,fPeakFinder->GetXPeak(k),fPeakFinder->GetYPeak(k));
+ track->SetMCid(label);
+#endif
+ }
+ LOG(AliL3Log::kInformational,"AliL3Hough::FindTrackCandidates()","")
+ <<"Found "<<fTracks[i]->GetNTracks()<<" tracks in slice "<<fCurrentSlice<<ENDLOG;
+ fTracks[i]->QSort();
+ }
+ fBenchmark->Stop("Find Maxima");
+ cpuTime = GetCpuTime() - initTime;
+ LOG(AliL3Log::kInformational,"AliL3Hough::FindTrackCandidates()","Timing")
+ <<"Maxima finding done in "<<cpuTime*1000<<" ms"<<ENDLOG;
+}
+
+void AliL3Hough::FindTrackCandidates()
+{
+ // Find AliL3HoughTransformer track candidates
+ if(fVersion == 4) {
+ LOG(AliL3Log::kError,"AliL3Hough::FindTrackCandidatesRow()","")
+ <<"Incompatible Peak Finder version!"<<ENDLOG;
+ return;
+ }
+
+ Int_t npatches;
if(fAddHistograms)
- n_patches = 1; //Histograms have been added.
+ npatches = 1; //Histograms have been added.
else
- n_patches = fNPatches;
+ npatches = fNPatches;
Double_t initTime,cpuTime;
initTime = GetCpuTime();
fBenchmark->Start("Find Maxima");
- for(Int_t i=0; i<n_patches; i++)
+ for(Int_t i=0; i<npatches; i++)
{
AliL3HoughBaseTransformer *tr = fHoughTransformer[i];
fTracks[i]->Reset();
if(hist->GetNEntries()==0) continue;
fPeakFinder->Reset();
fPeakFinder->SetHistogram(hist);
-
+#ifdef do_mc
+ cout<<"Starting "<<j<<" etaslice"<<endl;
+#endif
fPeakFinder->SetThreshold(fPeakThreshold[i]);
- fPeakFinder->FindAdaptedPeaks(6,0.5);
-
- //fPeakFinder->FindMaxima(fPeakThreshold[i]); //Simple maxima finder
+ fPeakFinder->FindAdaptedPeaks(fKappaSpread,fPeakRatio);
for(Int_t k=0; k<fPeakFinder->GetEntries(); k++)
{
fEval[i]->InitTransformer(fHoughTransformer[i]);
}
-Int_t AliL3Hough::Evaluate(Int_t road_width,Int_t nrowstomiss)
+Int_t AliL3Hough::Evaluate(Int_t roadwidth,Int_t nrowstomiss)
{
//Evaluate the tracks, by looking along the road in the raw data.
//If track does not cross all padrows - rows2miss, it is removed from the arrray.
return 0;
}
- Int_t removed_tracks=0;
+ Int_t removedtracks=0;
AliL3TrackArray *tracks=0;
if(fAddHistograms)
}
for(Int_t i=0; i<fNPatches; i++)
- EvaluatePatch(i,road_width,nrowstomiss);
+ EvaluatePatch(i,roadwidth,nrowstomiss);
//Here we check the tracks globally;
//how many good rows (padrows with signal)
if(track->GetNHits() < AliL3Transform::GetNRows() - nrowstomiss)
{
tracks->Remove(j);
- removed_tracks++;
+ removedtracks++;
}
}
tracks->Compress();
tracks->QSort();
}
- return removed_tracks;
+ return removedtracks;
}
-void AliL3Hough::EvaluatePatch(Int_t i,Int_t road_width,Int_t nrowstomiss)
+void AliL3Hough::EvaluatePatch(Int_t i,Int_t roadwidth,Int_t nrowstomiss)
{
//Evaluate patch i.
fEval[i]->InitTransformer(fHoughTransformer[i]);
- fEval[i]->SetNumOfPadsToLook(road_width);
+ fEval[i]->SetNumOfPadsToLook(roadwidth);
fEval[i]->SetNumOfRowsToMiss(nrowstomiss);
//fEval[i]->RemoveFoundTracks();
void AliL3Hough::WriteTracks(Char_t *path)
{
+ // Write found tracks into file
//cout<<"AliL3Hough::WriteTracks : Sorting the tracsk"<<endl;
//fGlobalTracks->QSort();
void AliL3Hough::WriteTracks(Int_t slice,Char_t *path)
{
+ // Write found tracks slice by slice into file
AliL3MemHandler mem;
Char_t fname[100];
}
}
+#ifdef use_aliroot
+Int_t AliL3Hough::FillESD(AliESD *esd)
+{
+ // Fill the found hough transform tracks
+ // into the ESD. The tracks are stored as
+ // AliESDHLTtrack objects.
+
+ // No TPC PID so far,assuming pions
+ Double_t prob[AliPID::kSPECIES];
+ for(Int_t i=0;i<AliPID::kSPECIES;i++) {
+ if(i==AliPID::kPion) prob[i]=1.0;
+ else prob[i]=0.1;
+ }
+
+ if(!fGlobalTracks) return 0;
+ Int_t nglobaltracks = 0;
+ for(Int_t i=0; i<fGlobalTracks->GetNTracks(); i++)
+ {
+ AliL3HoughTrack *tpt = (AliL3HoughTrack *)fGlobalTracks->GetCheckedTrack(i);
+ if(!tpt) continue;
+
+ if(tpt->GetWeight()<0) continue;
+ AliL3HoughKalmanTrack *tpctrack = new AliL3HoughKalmanTrack(*tpt);
+ if(!tpctrack) continue;
+ AliESDtrack *esdtrack2 = new AliESDtrack() ;
+ esdtrack2->UpdateTrackParams(tpctrack,AliESDtrack::kTPCin);
+ esdtrack2->SetESDpid(prob);
+ esd->AddTrack(esdtrack2);
+ nglobaltracks++;
+ delete esdtrack2;
+ delete tpctrack;
+ }
+ return nglobaltracks;
+}
+#endif
+
void AliL3Hough::WriteDigits(Char_t *outfile)
{
-#ifdef use_aliroot
//Write the current data to a new rootfile.
+#ifdef use_aliroot
for(Int_t i=0; i<fNPatches; i++)
{
return tv.tv_sec+(((Double_t)tv.tv_usec)/1000000.);
}
+void *AliL3Hough::ProcessInThread(void *args)
+{
+ // Called in case Hough transform tracking
+ // is executed in a thread
+
+ AliL3Hough *instance = (AliL3Hough *)args;
+ Int_t minslice = instance->GetMinSlice();
+ Int_t maxslice = instance->GetMaxSlice();
+ for(Int_t i=minslice; i<=maxslice; i++)
+ {
+ instance->ReadData(i,0);
+ instance->Transform();
+ instance->AddAllHistogramsRows();
+ instance->FindTrackCandidatesRow();
+ instance->AddTracks();
+ }
+ return (void *)0;
+}
+
+void AliL3Hough::StartProcessInThread(Int_t minslice,Int_t maxslice)
+{
+ // Starts the Hough transform tracking as a
+ // separate thread. Takes as parameters the
+ // range of TPC slices (sectors) to be reconstructed
+
+ if(!fThread) {
+ char buf[255];
+ sprintf(buf,"houghtrans_%d_%d",minslice,maxslice);
+ SetMinMaxSlices(minslice,maxslice);
+ // fThread = new TThread(buf,(void (*) (void *))&ProcessInThread,(void *)this);
+ fThread = new TThread(buf,&ProcessInThread,(void *)this);
+ fThread->Run();
+ }
+ return;
+}
+
+Int_t AliL3Hough::WaitForThreadFinish()
+{
+ // Routine is used in case we run the
+ // Hough transform tracking in several
+ // threads and want to sync them before
+ // writing the results to the ESD
+
+#if ROOT_VERSION_CODE < 262403
+ return TThread::Join(fThread->GetId());
+#else
+ return fThread->Join(fThread->GetId());
+#endif
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff