AliL3FileHandler *fFileHandler = new AliL3FileHandler();
fFileHandler->SetAliInput(in);
- AliL3Transform *fTransformer = new AliL3Transform(path);
- fFileHandler->SetTransformer(fTransformer);
+ AliL3Transform::Init(path);
for(int slice=first; slice<=last; slice++){
for(int patch=0;patch<npatch;patch++){
fclose(f);
}
+void Make_Default(char *file,char *tofile)
+{
+ /*
+ Macro to write out default values, which should be used to initialize
+ the static data members of the AliL3Transform class. Macro does more
+ or less the same as the above, only the output syntax is changed in order
+ to use it for static data member initialization.
+ */
+
+ TFile * rootf = new TFile(file,"READ");
+
+ if(!rootf->IsOpen()){
+ cerr<<"no file: "<<file<<endl;
+ return;
+ }
+
+ AliTPCParam* par = (AliTPCParam*)rootf->Get("75x40_100x60");
+
+ if(!par){
+ cerr<<"no AliTPCParam 75x40_100x60 in file: "<<file<<endl;
+ return;
+ }
+
+ int fNTimeBins = par->GetMaxTBin()+1;
+ int fNRowLow = par->GetNRowLow();
+ int fNRowUp = par->GetNRowUp();
+ int fNRow= fNRowLow + fNRowUp;
+ int fNSectorLow = par->GetNInnerSector();
+ int fNSectorUp = par->GetNOuterSector();
+ int fNSector = fNSectorLow + fNSectorUp;
+ int fNSlice = fNSectorLow;
+
+ FILE *f = fopen(tofile,"w");
+ fprintf(f,"Int_t AliL3Transform::fNTimeBins = %d ;\n",fNTimeBins);
+ fprintf(f,"Int_t AliL3Transform::fNRowLow = %d ;\n",fNRowLow);
+ fprintf(f,"Int_t AliL3Transform::fNRowUp = %d ;\n",fNRowUp);
+ fprintf(f,"Int_t AliL3Transform::fNSectorLow = %d ;\n",fNSectorLow);
+ fprintf(f,"Int_t AliL3Transform::fNSectorUp = %d ;\n",fNSectorUp);
+ fprintf(f,"Int_t AliL3Transform::fNSector = %d ;\n",fNSector);
+ fprintf(f,"Double_t AliL3Transform::fPadPitchWidthLow = %f ;\n",par->GetPadPitchWidth(0));
+ fprintf(f,"Double_t AliL3Transform::fPadPitchWidthUp = %f ;\n",par->GetPadPitchWidth(fNSectorLow));
+ fprintf(f,"Double_t AliL3Transform::fZWidth = %.20f ;\n",par->GetZWidth());
+ fprintf(f,"Double_t AliL3Transform::fZSigma = %.20f ;\n",par->GetZSigma());
+ fprintf(f,"Int_t AliL3Transform::fNSlice = %d ;\n",fNSectorLow);
+ fprintf(f,"Int_t AliL3Transform::fNRow = %d ;\n",fNRow);
+ fprintf(f,"Double_t AliL3Transform::fNRotShift = 0.5 ;\n");
+ fprintf(f,"Double_t AliL3Transform::fPi = %.15f ;\n",TMath::Pi());
+ fprintf(f,"Double_t AliL3Transform::fX[176] = {\n");
+ for(Int_t i=0;i<fNRow;i++){
+ int sec,row;
+ if( i < fNRowLow){sec =0;row =i;}
+ else{sec = fNSectorLow;row =i-fNRowLow;}
+
+ fprintf(f," %3.15f,\n",par->GetPadRowRadii(sec,row));
+ }
+ fprintf(f,"};\n\n");
+
+ fprintf(f,"Int_t AliL3Transform::fNPads[176] = {\n");
+ for(Int_t i=0;i<fNRow;i++){
+ int sec,row;
+ if( i < fNRowLow){sec =0;row =i;}
+ else{sec = fNSectorLow;row =i-fNRowLow;}
+ fprintf(f," %d,\n",par->GetNPads(sec,row));
+ }
+ fprintf(f,"};\n");
+ fclose(f);
+}
fMerger = 0;
fInterMerger = 0;
fGlobalMerger = 0;
- fTransform = 0;
}
delete fPeakFinder;
if(fGlobalMerger)
delete fGlobalMerger;
- if(fTransform)
- delete fTransform;
}
void AliL3Hough::CleanUp()
{
fPeakThreshold = 0;
fNPatches = NPatches;
- fTransform = new AliL3Transform(fPath);
+ AliL3Transform::Init(fPath);
fHoughTransformer = new AliL3HoughBaseTransformer*[fNPatches];
#ifdef use_aliroot
fMemHandler = new AliL3FileHandler*[fNPatches];
for(Int_t i=0; i<fNPatches; i++)
{
fHoughTransformer[i] = new AliL3HoughTransformer(1,i,fNEtaSegments);
- 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);
{
if(fAddHistograms) //Nothing to merge here
return;
- fMerger->SetTransformer(fTransform);
fMerger->MergePatches(kTRUE);
}
class AliL3MemHandler;
class AliL3FileHandler;
class AliL3HoughEval;
-class AliL3Transform;
class AliL3TrackArray;
class AliL3HoughMerger;
class AliL3HoughIntMerger;
class AliL3HoughGlobalMerger;
-class AliL3Transform;
class AliL3Hough {
AliL3HoughMerger *fMerger; //!
AliL3HoughIntMerger *fInterMerger; //!
AliL3HoughGlobalMerger *fGlobalMerger; //!
- AliL3Transform *fTransform; //!
void CleanUp();
void Init();
#include "AliL3Logging.h"
#include "AliL3HoughBaseTransformer.h"
#include "AliL3Defs.h"
-#include "AliL3Transform.h"
#include "AliL3DigitData.h"
#include "AliL3Histogram.h"
AliL3HoughBaseTransformer::AliL3HoughBaseTransformer()
{
//Default constructor
- fTransform = 0;
fDigitRowData = 0;
}
fEtaMax = fSlice < 18 ? 0.9 : -0.9;
fThreshold = 0;
fDigitRowData = 0;
- fTransform = 0;
}
AliL3HoughBaseTransformer::~AliL3HoughBaseTransformer()
#include "AliL3RootTypes.h"
-class AliL3Transform;
class AliL3DigitRowData;
class AliL3Histogram;
AliL3DigitRowData *fDigitRowData; //!
- 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;
AliL3HoughDisplay::~AliL3HoughDisplay()
{
- if(fTransform)
- delete fTransform;
}
void AliL3HoughDisplay::Init()
cerr<<"AliL3HoughDisplay::AliL3HoughDisplay : Geometry file alice.geom does not exist"<<endl;
fGeom = (TGeometry*)file->Get("AliceGeom");
file->Close();
- fTransform = new AliL3Transform();
}
{
if(track->GetCrossingPoint(i,xyz))
{
- fTransform->Local2Global(xyz,slice);
+ AliL3Transform::Local2Global(xyz,slice);
x[n] = xyz[0];
y[n] = xyz[1];
z[n] = xyz[2];
Int_t padrow = (Int_t)tempPt->fRow;
for(UInt_t j=0; j<tempPt->fNDigit; j++)
{
- fTransform->Slice2Sector(fShowSlice,padrow,sector,row);
- fTransform->Raw2Global(xyz,sector,row,(Int_t)digPt->fPad,(Int_t)digPt->fTime);
+ AliL3Transform::Slice2Sector(fShowSlice,padrow,sector,row);
+ AliL3Transform::Raw2Global(xyz,sector,row,(Int_t)digPt->fPad,(Int_t)digPt->fTime);
pm->SetPoint(count,xyz[0],xyz[1],xyz[2]);
count++;
}
class TGeometry;
class AliL3TrackArray;
-class AliL3Transform;
class AliL3DigitRowData;
class TPolyMarker3D;
class AliL3HoughTrack;
TGeometry *fGeom; //!
AliL3TrackArray *fTracks; //!
- AliL3Transform *fTransform; //!
AliL3DigitRowData *fDigitRowData; //!
UInt_t fNDigitRowData; //!
Int_t fShowSlice;
AliL3HoughEval::AliL3HoughEval()
{
- fTransform = new AliL3Transform();
fRemoveFoundTracks = kFALSE;
fNumOfPadsToLook = 1;
fNumOfRowsToMiss = 1;
AliL3HoughEval::~AliL3HoughEval()
{
fHoughTransformer = 0;
- if(fTransform)
- delete fTransform;
if(fRowPointers)
{
for(Int_t i=0; i<fNrows; i++)
for(Int_t padrow = NRows[fPatch][0]; padrow <= NRows[fPatch][1]; padrow++)
{
- if(fTransform->Row2X(padrow) > maxrow) break;//The track has left this slice
+ if(AliL3Transform::Row2X(padrow) > maxrow) break;//The track has left this slice
rows_crossed++;
Int_t prow = padrow - NRows[fPatch][0];
if(!track->GetCrossingPoint(padrow,xyz))
continue;
}
- fTransform->Slice2Sector(fSlice,padrow,sector,row);
- fTransform->Local2Raw(xyz,sector,row);
+ AliL3Transform::Slice2Sector(fSlice,padrow,sector,row);
+ AliL3Transform::Local2Raw(xyz,sector,row);
npixs=0;
if(pad < p) continue;
if(pad > p) break;
UShort_t time = digPt[j].fTime;
- Double_t eta = fTransform->GetEta(padrow,pad,time);
+ Double_t eta = AliL3Transform::GetEta(padrow,pad,time);
Int_t pixel_index = (Int_t)(eta/etaslice);
if(pixel_index > eta_index) continue;
if(pixel_index != eta_index) break;
continue;
}
- fTransform->Slice2Sector(fSlice,padrow,sector,row);
- fTransform->Local2Raw(xyz,sector,row);
+ AliL3Transform::Slice2Sector(fSlice,padrow,sector,row);
+ AliL3Transform::Local2Raw(xyz,sector,row);
//Get the timebins for this pad
AliL3DigitRowData *tempPt = fRowPointers[prow];
if(pad < p) continue;
if(pad > p) break;
UShort_t time = digPt[j].fTime;
- Double_t eta = fTransform->GetEta(padrow,pad,time);
+ Double_t eta = AliL3Transform::GetEta(padrow,pad,time);
Int_t pixel_index = (Int_t)(eta/etaslice);
if(pixel_index > track->GetEtaIndex()+1) continue;
if(pixel_index < track->GetEtaIndex()-1) break;
if(charge < fHoughTransformer->GetThreshold()) continue;
Float_t xyz[3];
Int_t sector,row;
- fTransform->Slice2Sector(fSlice,padrow,sector,row);
- fTransform->Raw2Local(xyz,sector,row,pad,time);
- Double_t eta = fTransform->GetEta(xyz);
+ AliL3Transform::Slice2Sector(fSlice,padrow,sector,row);
+ AliL3Transform::Raw2Local(xyz,sector,row,pad,time);
+ Double_t eta = AliL3Transform::GetEta(xyz);
Int_t pixel_index = (Int_t)(eta/etaslice);
if(pixel_index != eta_index) continue;
hist->Fill(xyz[0],xyz[1],charge);
class AliL3HoughBaseTransformer;
-class AliL3Transform;
class AliL3HoughTrack;
class AliL3DigitRowData;
class AliL3Histogram;
//Flags
Bool_t fRemoveFoundTracks;
- AliL3Transform *fTransform; //!
AliL3HoughBaseTransformer *fHoughTransformer; //!
AliL3DigitRowData **fRowPointers; //!
#include "AliL3HoughTrack.h"
#include "AliL3HoughGlobalMerger.h"
#include "AliL3Track.h"
-#include "AliL3Transform.h"
#include "AliL3TrackArray.h"
+#include "AliL3Transform.h"
//_____________________________________________________________
// Merging Hough tracks across slices
if(slice2==fNSlices) slice2 =0;
AliL3TrackArray *ttt1=GetInTracks(slice2);
Float_t angle = PI/18.; //10 degrees -> the border of the slices
- fTransformer->Local2GlobalAngle(&angle,slice);
+ AliL3Transform::Local2GlobalAngle(&angle,slice);
if(i==0)
ttt0->QSort();
ttt1->QSort();
if(slice2==fNSlices) slice2 =0;
AliL3TrackArray *ttt1=GetInTracks(slice2);
Float_t angle = PI/18.; //10 degrees -> the border of the slices
- fTransformer->Local2GlobalAngle(&angle,slice);
+ AliL3Transform::Local2GlobalAngle(&angle,slice);
if(i==0)
ttt0->QSort();
ttt1->QSort();
#include <string.h>
#include <math.h>
#include <stdlib.h>
+#include <stream.h>
#include "AliL3Histogram.h"
#include "AliL3TrackArray.h"
}
-AliL3TrackArray *AliL3HoughMaxFinder::FindMaxima(AliL3Histogram *hist,Int_t *rowrange,Int_t ref_row)
+void AliL3HoughMaxFinder::FindMaxima(Float_t *xpeaks,Float_t *ypeaks,Int_t *weight,Int_t &entries)
{
//Locate all the maxima in input histogram.
//Maxima is defined as bins with more entries than the
//immediately neighbouring bins.
- Int_t xmin = hist->GetFirstXbin();
- Int_t xmax = hist->GetLastXbin();
- Int_t ymin = hist->GetFirstYbin();
- Int_t ymax = hist->GetLastYbin();
- Int_t bin[9],track_counter=0;
+ Int_t max_entries = entries;
+ entries = 0;
+ Int_t xmin = fCurrentHisto->GetFirstXbin();
+ Int_t xmax = fCurrentHisto->GetLastXbin();
+ Int_t ymin = fCurrentHisto->GetFirstYbin();
+ Int_t ymax = fCurrentHisto->GetLastYbin();
+ Int_t bin[9];
Double_t value[9];
- AliL3TrackArray *tracks = new AliL3TrackArray("AliL3HoughTrack");
- AliL3HoughTrack *track;
-
+ Double_t kappa_overlap = 0.001;
+ Double_t phi_overlap = 0.05;
+
for(Int_t xbin=xmin+1; xbin<xmax-1; xbin++)
{
for(Int_t ybin=ymin+1; ybin<ymax-1; ybin++)
{
- bin[0] = hist->GetBin(xbin-1,ybin-1);
- bin[1] = hist->GetBin(xbin,ybin-1);
- bin[2] = hist->GetBin(xbin+1,ybin-1);
- bin[3] = hist->GetBin(xbin-1,ybin);
- bin[4] = hist->GetBin(xbin,ybin);
- bin[5] = hist->GetBin(xbin+1,ybin);
- bin[6] = hist->GetBin(xbin-1,ybin+1);
- bin[7] = hist->GetBin(xbin,ybin+1);
- bin[8] = hist->GetBin(xbin+1,ybin+1);
- value[0] = hist->GetBinContent(bin[0]);
- value[1] = hist->GetBinContent(bin[1]);
- value[2] = hist->GetBinContent(bin[2]);
- value[3] = hist->GetBinContent(bin[3]);
- value[4] = hist->GetBinContent(bin[4]);
- value[5] = hist->GetBinContent(bin[5]);
- value[6] = hist->GetBinContent(bin[6]);
- value[7] = hist->GetBinContent(bin[7]);
- value[8] = hist->GetBinContent(bin[8]);
+ bin[0] = fCurrentHisto->GetBin(xbin-1,ybin-1);
+ bin[1] = fCurrentHisto->GetBin(xbin,ybin-1);
+ bin[2] = fCurrentHisto->GetBin(xbin+1,ybin-1);
+ bin[3] = fCurrentHisto->GetBin(xbin-1,ybin);
+ bin[4] = fCurrentHisto->GetBin(xbin,ybin);
+ bin[5] = fCurrentHisto->GetBin(xbin+1,ybin);
+ bin[6] = fCurrentHisto->GetBin(xbin-1,ybin+1);
+ bin[7] = fCurrentHisto->GetBin(xbin,ybin+1);
+ bin[8] = fCurrentHisto->GetBin(xbin+1,ybin+1);
+ value[0] = fCurrentHisto->GetBinContent(bin[0]);
+ value[1] = fCurrentHisto->GetBinContent(bin[1]);
+ value[2] = fCurrentHisto->GetBinContent(bin[2]);
+ value[3] = fCurrentHisto->GetBinContent(bin[3]);
+ value[4] = fCurrentHisto->GetBinContent(bin[4]);
+ value[5] = fCurrentHisto->GetBinContent(bin[5]);
+ value[6] = fCurrentHisto->GetBinContent(bin[6]);
+ value[7] = fCurrentHisto->GetBinContent(bin[7]);
+ value[8] = fCurrentHisto->GetBinContent(bin[8]);
+
- if(value[4] <= fThreshold) continue;//central bin below threshold
if(value[4]>value[0] && value[4]>value[1] && value[4]>value[2]
&& value[4]>value[3] && value[4]>value[5] && value[4]>value[6]
&& value[4]>value[7] && value[4]>value[8])
{
//Found a local maxima
- Float_t max_x = hist->GetBinCenterX(xbin);
- Float_t max_y = hist->GetBinCenterY(ybin);
+ Float_t max_x = fCurrentHisto->GetBinCenterX(xbin);
+ Float_t max_y = fCurrentHisto->GetBinCenterY(ybin);
- track = (AliL3HoughTrack*)tracks->NextTrack();
+ if((Int_t)value[4] <= fThreshold) continue;//central bin below threshold
- switch(fHistoType)
+ if(entries >= max_entries)
{
- case 'c':
- track->SetTrackParameters(max_x,max_y,(Int_t)value[4]);
- break;
- case 'l':
- track->SetLineParameters(max_x,max_y,(Int_t)value[4],rowrange,ref_row);
- break;
- default:
- printf("AliL3HoughMaxFinder: Error in tracktype\n");
+ cerr<<"AliL3HoughMaxFinder::FindMaxima : Array out of range : "<<entries<<" "<<max_entries<<endl;
+ return;
}
- track_counter++;
-
-
+ //Check if the peak is overlapping with a previous:
+ Bool_t bigger = kFALSE;
+ for(Int_t p=0; p<entries; p++)
+ {
+ if(fabs(max_x - xpeaks[p]) < kappa_overlap && fabs(max_y - ypeaks[p]) < phi_overlap)
+ {
+ bigger = kTRUE;
+ if(value[4] > weight[p]) //this peak is bigger.
+ {
+ xpeaks[p] = max_x;
+ ypeaks[p] = max_y;
+ weight[p] = (Int_t)value[4];
+ }
+ else
+ continue; //previous peak is bigger.
+ }
+ }
+ if(!bigger) //there were no overlapping peaks.
+ {
+ xpeaks[entries] = max_x;
+ ypeaks[entries] = max_y;
+ weight[entries] = (Int_t)value[4];
+ entries++;
+ }
}
else
continue; //not a maxima
}
}
- tracks->QSort();
- return tracks;
+
}
//Sort the windows according to the weight
SortPeaks(windowPt,0,nbinsx);
- //for(Int_t i=0; i<nbinsx; i++)
- //printf("xbin %f weight %d\n",fCurrentHisto->GetBinCenterX(windowPt[i]->xbin),windowPt[i]->weight);
-
Float_t top,butt;
for(Int_t i=0; i<nbinsx; i++)
{
}
xpeaks[n] = fCurrentHisto->GetBinCenterX(windowPt[i]->xbin);
ypeaks[n] = top/butt;
+ weight[n] = (Int_t)butt;
+ //cout<<"mean in y "<<ypeaks[n]<<" on x "<<windowPt[i]->xbin<<" content "<<butt<<endl;
n++;
if(n==max_entries) break;
}
prev = xbin - x_bin_sides+1;
for(Int_t j=xbin-x_bin_sides; j<=xbin+x_bin_sides; j++)
{
+ /*
//Check if the windows are overlapping:
if(anotherPt[j]->ymin > anotherPt[prev]->ymax) {prev=j; continue;}
if(anotherPt[j]->ymax < anotherPt[prev]->ymin) {prev=j; continue;}
prev = j;
-
+ */
+
top += fCurrentHisto->GetBinCenterX(j)*anotherPt[j]->weight;
butt += anotherPt[j]->weight;
xpeaks[i] = top/butt;
ypeaks[i] = ytop/ybutt;
weight[i] = w;
-
+ //cout<<"Setting weight "<<w<<" kappa "<<xpeaks[i]<<" phi0 "<<ypeaks[i]<<endl;
//Check if this peak is overlapping with a previous:
for(Int_t p=0; p<i-1; p++)
void FindAbsMaxima(Int_t &max_xbin,Int_t &max_ybin);
AliL3TrackArray *FindBigMaxima(AliL3Histogram *hist);
- AliL3TrackArray *FindMaxima(AliL3Histogram *hist,Int_t *rowrange=0,Int_t ref_row=0);
+ void FindMaxima(Float_t *xpeaks,Float_t *ypeaks,Int_t *weight,Int_t &entries);
AliL3TrackArray *LookForPeaks(AliL3Histogram *hist,Int_t nbins);
void FindPeak(Int_t t1,Double_t t2,Int_t t3,Float_t &kappa,Float_t &phi0);
AliL3TrackArray *tout = GetOutTracks();
if(i==subsec) tout = GetInTracks(subsec+1);
AliL3TrackArray *tin = GetInTracks(i);
- Double_t xval = fTransformer->Row2X(NRows[i][1]);
- Double_t xmax = fTransformer->Row2X(NRows[i+1][1]);
+ Double_t xval = AliL3Transform::Row2X(NRows[i][1]);
+ Double_t xmax = AliL3Transform::Row2X(NRows[i+1][1]);
Double_t ymax = xval*tan(edge0);
for(Int_t out=0;out<tout->GetNTracks();out++){
AliL3Track *outtrack=tout->GetCheckedTrack(out);
#include <math.h>
#include "AliL3Logging.h"
-#include "AliL3Transform.h"
#include "AliL3Defs.h"
#include "AliL3HoughTrack.h"
<<"No input data "<<ENDLOG;
return;
}
- if(!fTransform)
- {
- LOG(AliL3Log::kError,"AliL3HoughTransformer::TransformCircle","Transformer")
- <<"No AliL3Transform object"<<ENDLOG;
- return;
- }
//Loop over the padrows:
for(Int_t i=NRows[GetPatch()][0]; i<=NRows[GetPatch()][1]; i++)
Float_t xyz[3];
//Transform data to local cartesian coordinates:
- fTransform->Slice2Sector(GetSlice(),i,sector,row);
- fTransform->Raw2Local(xyz,sector,row,(Int_t)pad,(Int_t)time);
+ AliL3Transform::Slice2Sector(GetSlice(),i,sector,row);
+ AliL3Transform::Raw2Local(xyz,sector,row,(Int_t)pad,(Int_t)time);
//Calculate the eta:
- Double_t eta = fTransform->GetEta(xyz);
+ Double_t eta = AliL3Transform::GetEta(xyz);
//Get the corresponding index, which determines which histogram to fill:
Int_t eta_index = GetEtaIndex(eta);
//Do the transformation:
Float_t R = sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]);
- Float_t phi = fTransform->GetPhi(xyz);
+ Float_t phi = AliL3Transform::GetPhi(xyz);
//Fill the histogram along the phirange
for(Int_t b=hist->GetFirstYbin(); b<=hist->GetLastYbin(); b++)
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++)
{
charge = digPt[di].fCharge;
pad = digPt[di].fPad;
time = digPt[di].fTime;
- fTransform->Slice2Sector(GetSlice(),i,sector,row);
- fTransform->Raw2Local(xyz,sector,row,(Int_t)pad,(Int_t)time);
- eta = fTransform->GetEta(xyz);
+ AliL3Transform::Slice2Sector(GetSlice(),i,sector,row);
+ AliL3Transform::Raw2Local(xyz,sector,row,(Int_t)pad,(Int_t)time);
+ eta = AliL3Transform::GetEta(xyz);
digits[counter].row = i;
digits[counter].r = sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]);
digits[counter].phi = atan2(xyz[1],xyz[0]);
<<"No input data "<<ENDLOG;
return;
}
- if(!fTransform)
- {
- LOG(AliL3Log::kError,"AliL3HoughTransformer::TransformLine","Transformer")
- <<"No AliL3Transform object"<<ENDLOG;
- return;
- }
for(Int_t i=NRows[GetPatch()][0]; i<=NRows[GetPatch()][1]; i++)
{
continue;
Int_t sector,row;
Float_t xyz[3];
- fTransform->Slice2Sector(GetSlice(),i,sector,row);
- fTransform->Raw2Local(xyz,sector,row,(Int_t)pad,(Int_t)time);
- Float_t eta = fTransform->GetEta(xyz);
+ AliL3Transform::Slice2Sector(GetSlice(),i,sector,row);
+ AliL3Transform::Raw2Local(xyz,sector,row,(Int_t)pad,(Int_t)time);
+ Float_t eta = AliL3Transform::GetEta(xyz);
Int_t eta_index = GetEtaIndex(eta);//(Int_t)(eta/etaslice);
if(eta_index < 0 || eta_index >= GetNEtaSegments())
continue;
void GetGoodParticles(Int_t minslice,Int_t maxslice,char *eventfile,char *digitfile,Int_t event)
{
- Int_t good_number = 10; //Minimum number of points on a good track
+ Int_t good_number = 70; //Minimum number of points on a good track
struct GoodTrack goodtracks[15000];
Int_t nt=0;
for(Int_t ii=0; ii<np; ii++)
good[ii] = 0;
- AliL3Transform *transform = new AliL3Transform();
+
TFile *digfile = TFile::Open(digitfile);
Char_t dname[100];
Int_t sec,row;
param->AdjustSectorRow(digits->GetID(),sec,row);
Int_t sl,padrow;
- transform->Sector2Slice(sl,padrow,sec,row);
+ AliL3Transform::Sector2Slice(sl,padrow,sec,row);
if(sl < minslice) continue;
if(sl > maxslice) break;
digits->First();
evfile->Close();
digfile->Close();
- delete transform;
}
unsigned int ndigits=0;
AliL3MemHandler file; //Does all the file/data handling
- AliL3Transform transform; //Storing all detector-spesific quantities, needed by the clusterfinder.
- AliL3ClustFinderNew cf(&transform); //The cluster finder itself.
+ //AliL3Transform::Init(path); //Storing all detector-spesific quantities, needed by the clusterfinder.
+ AliL3ClustFinderNew cf; //The cluster finder itself.
//Open the data file:
if(!file.SetBinaryInput(argv[1]))
{
fDataSize=0;
fTracks=0;
- fTransform=0;
fDigitRowData=0;
fOutput=0;
fVertex=0;
{
if(fTracks)
delete fTracks;
- if(fTransform)
- delete fTransform;
}
void AliL3Trigger::InitTrigger()
{
if(fTracks)
delete fTracks;
- if(fTransform)
- delete fTransform;
fTracks = new AliL3TrackArray();
- fTransform = new AliL3Transform;
}
void AliL3Trigger::InitPatch(Int_t slice,Int_t patch)
AliL3Track *track = fTracks->GetCheckedTrack(j);
if(!track) continue;
track->GetCrossingPoint(i,hit);
- fTransform->Slice2Sector(fSlice,i,sector,row);
- fTransform->Local2Raw(hit,sector,row);
+ AliL3Transform::Slice2Sector(fSlice,i,sector,row);
+ AliL3Transform::Local2Raw(hit,sector,row);
row_cross[j].pad = (Int_t)rint(hit[1]);
row_cross[j].time = (Int_t)rint(hit[2]);
}
class AliL3TrackSegmentData;
class AliL3DigitRowData;
class AliL3TrackArray;
-class AliL3Transform;
class AliL3Vertex;
class AliL3Trigger {
AliL3DigitRowData *fDigitRowData; //!
AliL3DigitRowData *fOutput; //!
AliL3Vertex *fVertex; //!
- AliL3Transform *fTransform;//!
Int_t fDataSize;
Float_t fZcut;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff