Updating
[u/mrichter/AliRoot.git] / HLT / hough / AliL3HoughTransformer.cxx
1 //Author:        Anders Strand Vestbo
2 //Last Modified: 28.6.01
3
4 #include <math.h>
5 #include <TH2.h>
6 #include <time.h>
7
8 #include <TFile.h>
9 #include <TTree.h>
10
11 #include "AliTPCParam.h"
12 #include "AliSimDigits.h"
13
14 #include "AliL3Histogram.h"
15 #include "AliL3Logging.h"
16 #include "AliL3Defs.h"
17 #include "AliL3Transform.h"
18 #include "AliL3HoughTransformer.h"
19 #include "AliL3HoughTrack.h"
20 #include "AliL3TrackArray.h"
21 #include "AliL3DigitData.h"
22
23 ClassImp(AliL3HoughTransformer)
24
25 AliL3HoughTransformer::AliL3HoughTransformer()
26 {
27   //Default constructor
28   
29 }
30
31
32 AliL3HoughTransformer::AliL3HoughTransformer(Int_t slice,Int_t patch,Float_t *etarange)
33 {
34   //Constructor
35   
36   fTransform = new AliL3Transform();
37
38   fEtaMin = etarange[0];
39   fEtaMax = etarange[1];
40   fSlice = slice; 
41   fPatch = patch;
42   fNumOfPadRows=NRowsSlice;
43 }
44
45 AliL3HoughTransformer::AliL3HoughTransformer(Int_t slice,Int_t patch,Double_t *etarange,Int_t n_eta_segments)
46 {
47   
48   fTransform = new AliL3Transform();
49   if(etarange)
50     {
51       //assumes you want to look at a given etaslice only
52       fEtaMin = etarange[0];
53       fEtaMax = etarange[1];
54     }
55   else
56     {
57       //transform in all etaslices
58       fEtaMin = 0;
59       fEtaMax = slice < 18 ? 0.9 : -0.9;
60     }
61   fNumEtaSegments = n_eta_segments;
62   fSlice = slice;
63   fPatch = patch;
64   fNumOfPadRows = NRowsSlice;
65   
66   fNRowsInPatch = NRows[fPatch][1]-NRows[fPatch][0] + 1;
67   fBinTableBounds = (fNRowsInPatch+1)*(MaxNPads+1);
68   fNDigitRowData = 0;
69   fDigitRowData = 0;
70   fHistoPt = 0;
71 }
72
73
74 AliL3HoughTransformer::~AliL3HoughTransformer()
75 {
76   //Destructor
77   if(fBinTable)
78     {
79       for(Int_t i=0; i<fBinTableBounds; i++)
80         delete [] fBinTable[i];
81       delete [] fBinTable;
82     }
83   if(fEtaIndex)
84     delete [] fEtaIndex;
85   if(fTrackTable)
86     {
87       for(Int_t i=0; i<fNumEtaSegments; i++)
88         delete [] fTrackTable[i];
89       delete [] fTrackTable;
90     }
91   if(fTransform)
92     delete fTransform;
93   
94   
95 }
96
97 void AliL3HoughTransformer::SetInputData(UInt_t ndigits,AliL3DigitRowData *ptr)
98 {
99   fNDigitRowData = ndigits;
100   fDigitRowData = ptr;
101 }
102
103 void AliL3HoughTransformer::InitTables()
104 {
105   //Create LUT for the circle transform.
106   //the actual transformation is done in TransformTables.
107
108   AliL3Histogram *hist = fHistoPt;
109   
110   Int_t nbinsy = hist->GetNbinsY();
111   
112   fBinTable = new Int_t*[fBinTableBounds];
113   Int_t index;
114
115   Double_t etaslice = fEtaMax/fNumEtaSegments;
116   
117   Int_t etabounds = (MaxNPads+1)*(fNRowsInPatch+1)*(MaxNTimeBins+1);
118
119   fEtaIndex = new Int_t[etabounds];
120   for(Int_t i=0; i<etabounds; i++)
121     fEtaIndex[i] = -1;
122   
123   fTrackTable = new Char_t*[fNumEtaSegments];
124   for(Int_t i=0; i<fNumEtaSegments; i++)
125     {
126       fTrackTable[i] = new Char_t[fBinTableBounds];
127       for(Int_t j=0; j<fBinTableBounds; j++)
128         fTrackTable[i][j] = 0;
129     }
130   
131   for(Int_t r=NRows[fPatch][0]; r<=NRows[fPatch][1]; r++)
132     {
133       Int_t prow = r - NRows[fPatch][0];
134       
135       for(Int_t p=0; p<fTransform->GetNPads(r); p++)
136         {
137           Float_t xyz[3];
138           Int_t sector,row;
139           for(Int_t t=0; t<fTransform->GetNTimeBins(); t++)
140             {
141               fTransform->Slice2Sector(fSlice,r,sector,row);
142               fTransform->Raw2Local(xyz,sector,row,p,t);
143               Double_t eta = fTransform->GetEta(xyz);
144               if(eta < fEtaMin || eta > fEtaMax) continue;
145               Int_t ind = (prow<<17) + (p<<9) + t;
146               if(fEtaIndex[ind]>=0)
147                 printf("AliL3HoughTransformer::InitTables : Overlapping indexes in eta!!\n");
148               Int_t eta_index = (Int_t)(eta/etaslice);        
149               if(eta_index < 0 || eta_index > fNumEtaSegments)
150                 continue;
151               fEtaIndex[ind] = eta_index;
152               
153             }
154           
155           Double_t r_pix = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
156           Double_t phi_pix = fTransform->GetPhi(xyz);
157           index = (prow<<8) + p;
158           fBinTable[index] = new Int_t[nbinsy+1];
159           
160           for(Int_t b=hist->GetFirstYbin(); b<=hist->GetLastYbin(); b++)
161             {
162               Double_t phi0 = hist->GetBinCenterY(b);
163               Double_t kappa = 2*sin(phi_pix-phi0)/r_pix;
164               Int_t bin = hist->FindBin(kappa,phi0);
165               if(fBinTable[index][b]!=0)
166                 printf("AliL3HoughTransformer::InitTables : Overlapping indexes %d %d b %d\n",fBinTable[index][b],index,b);
167               fBinTable[index][b] = bin;
168             }
169         }
170
171     }
172
173 }
174
175 void AliL3HoughTransformer::TransformTables(AliL3Histogram **histos,AliL3Histogram **images)
176 {
177   //Transform all the pixels while reading, and fill the corresponding histograms.
178   //Transform is done using LUT created in InitTables.
179   //fTrackTable : table telling whether a specific pixel is active (nonzero):
180   //fTrackTable = 0  ->  no track
181   //fTrackindex > 0  ->  track present
182   //fTrackindex = -1  ->  track has been removed (already found)
183   //fEtaIndex : table storing the etaindex -> used to find correct histogram to fill
184   //fBinTable : table storing all the bins to fill for each nonzero pixel
185     
186   Int_t eta_index;
187   AliL3DigitRowData *tempPt = (AliL3DigitRowData*)fDigitRowData;
188   AliL3Histogram *hist;
189   
190   if(!tempPt)
191     {
192       LOG(AliL3Log::kError,"AliL3HoughTransformer::TransformTables","data")<<
193         "Zero datapointer"<<ENDLOG;
194       return;
195     }
196
197   Int_t out_count=0,tot_count=0;
198   Int_t index,ind;
199
200   for(Int_t i=NRows[fPatch][0]; i<=NRows[fPatch][1]; i++)
201     {
202       Int_t prow = i - NRows[fPatch][0];
203       AliL3DigitData *bins = tempPt->fDigitData;
204       for(UInt_t dig=0; dig<tempPt->fNDigit; dig++)
205         {
206           index = (prow<<8) + bins[dig].fPad;
207           ind = (prow<<17) + (bins[dig].fPad<<9) + bins[dig].fTime;
208           eta_index = fEtaIndex[ind];
209           if(eta_index < 0) continue;  //pixel out of etarange
210           
211           if(fTrackTable[eta_index][index]<0) continue; //this pixel has already been removed. 
212           fTrackTable[eta_index][index]++; //this pixel is now marked as active (it is nonzero)
213           
214           tot_count++;
215           hist = histos[eta_index];
216           
217           if(images)
218             {
219               //Display the transformed images.
220               AliL3Histogram *image = images[eta_index];
221               Float_t xyz_local[3];
222               Int_t sector,row;
223               fTransform->Slice2Sector(fSlice,i,sector,row);
224               fTransform->Raw2Local(xyz_local,sector,row,bins[dig].fPad,bins[dig].fTime);
225               image->Fill(xyz_local[0],xyz_local[1],bins[dig].fCharge);
226             }
227           
228           if(!hist)
229             {
230               printf("Error getting histogram!\n");
231               continue;
232             }
233           for(Int_t p=hist->GetFirstYbin(); p<=hist->GetLastYbin(); p++)
234             hist->AddBinContent(fBinTable[index][p],bins[dig].fCharge);
235           
236         }
237       
238       Byte_t *tmp = (Byte_t*)tempPt;
239       Int_t size = sizeof(AliL3DigitRowData) + tempPt->fNDigit*sizeof(AliL3DigitData);
240       tmp += size;
241       tempPt = (AliL3DigitRowData*)tmp;
242     }  
243   
244 }
245
246 void AliL3HoughTransformer::WriteTables()
247 {
248   //Write the tables to asci files.
249   
250   AliL3Histogram *hist = fHistoPt;
251   Char_t name[100];
252   sprintf(name,"histogram_table_%d.txt",fPatch);
253   FILE *file = fopen(name,"w");
254   
255   Int_t etabounds = (MaxNPads+1)*(fNRowsInPatch+1)*(MaxNTimeBins+1);
256   for(Int_t i=0; i<etabounds; i++)
257     {
258       if(fEtaIndex[i]<0) continue;
259       fprintf(file,"%d %d\n",i,fEtaIndex[i]);
260     }
261   fclose(file);
262   
263   sprintf(name,"bin_table_%d.txt",fPatch);
264   FILE *file2 = fopen(name,"w");
265   for(Int_t i=0; i<fBinTableBounds; i++)
266     {
267       if(!fBinTable[i]) continue;
268       fprintf(file2,"%d ",i);
269       for(Int_t j=hist->GetFirstYbin(); j<=hist->GetLastYbin(); j++)
270         {
271           fprintf(file2,"%d ",fBinTable[i][j]);
272         }
273       fprintf(file2,"\n");
274     }
275   fclose(file2);
276 }
277
278 Double_t AliL3HoughTransformer::CpuTime()
279 {
280   return (Double_t)(clock()) / CLOCKS_PER_SEC;
281 }
282
283 /*
284 void AliL3HoughTransformer::InitTemplates(TH2F *hist)
285 {
286
287   AliL3Digits *pixel;
288
289   Int_t ymin = hist->GetYaxis()->GetFirst();
290   Int_t ymax = hist->GetYaxis()->GetLast();
291   Int_t nbinsy = hist->GetNbinsY();
292
293   fIndex = new Int_t*[fNDigits];
294   for(Int_t i=0; i<fNDigits; i++)
295     fIndex[i] = new Int_t[nbinsy+1];
296     
297   Int_t sector,row;
298   
299   for(Int_t padrow = NRows[fPatch][0]; padrow <= NRows[fPatch][1]; padrow++)
300     {        
301       
302       for(pixel=(AliL3Digits*)fRowContainer[padrow].first; pixel!=0; pixel=(AliL3Digits*)pixel->nextRowPixel)
303         {
304           Float_t xyz[3];
305           fTransform->Slice2Sector(fSlice,padrow,sector,row);
306           fTransform->Raw2Local(xyz,sector,row,pixel->fPad,pixel->fTime);
307           
308           Double_t r_pix = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
309           
310           Double_t phi_pix = fTransform->GetPhi(xyz);
311           Int_t index = pixel->fIndex;
312           if(index >= fNDigits)
313             printf("AliL3HoughTransformer::InitTemplates : Index error! %d\n",index);
314           for(Int_t p=ymin; p<=ymax; p++)
315             {
316               
317               Double_t phi0 = hist->GetYaxis()->GetBinCenter(p);
318               Double_t kappa = 2*sin(phi_pix-phi0)/r_pix;
319               //printf("kappa %f phi0 %f\n",kappa,phi0);
320               Int_t bin = hist->FindBin(kappa,phi0);
321               if(fIndex[index][p]!=0)
322                 printf("AliL3HoughTransformer::InitTemplates : Overlapping indexes\n");
323               fIndex[index][p] = bin;
324             }
325         }
326     }
327   
328 }
329
330
331 void AliL3HoughTransformer::Transform2Circle(TH2F *hist,Int_t eta_index)
332 {
333   //Transformation is done with respect to local coordinates in slice.
334   //Transform every pixel into whole phirange, using parametrisation:
335   //kappa = 2*sin(phi-phi0)/R
336   //Assumes you run InitTemplates first!!!!
337
338   AliL3Digits *pix1;
339     
340   Int_t nbinsy = hist->GetNbinsY();
341
342   Int_t totsignal=0,vol_index;
343   if(fNumEtaSegments==1)
344     eta_index=0; //only looking in one etaslice.
345
346   for(Int_t padrow = NRows[fPatch][0]; padrow <= NRows[fPatch][1]; padrow++)
347     {
348       vol_index = eta_index*fNumOfPadRows + padrow;
349       //for(pix1=(AliL3Digits*)fRowContainer[padrow].first; pix1!=0; pix1=(AliL3Digits*)pix1->nextRowPixel)
350       for(pix1=(AliL3Digits*)fVolume[vol_index].first; pix1!=0; pix1=(AliL3Digits*)pix1->fNextVolumePixel)
351         {
352           Float_t xyz[3];
353           fTransform->Raw2Global(xyz,2,padrow,pix1->fPad,pix1->fTime);
354           Double_t eta = fTransform->GetEta(xyz);
355           if(eta < fEtaMin || eta > fEtaMax)
356             printf("\n Eta OUT OF RANGE\n");
357
358           Short_t signal = pix1->fCharge;
359           Int_t index = pix1->fIndex;
360           if(index < 0) continue; //This pixel has been removed.
361           totsignal += signal;
362           for(Int_t p=0; p <= nbinsy; p++)
363             hist->AddBinContent(fIndex[index][p],signal);
364                           
365         }
366       
367     }
368     
369   printf("Total signal %d\n",totsignal);
370 }
371
372 void AliL3HoughTransformer::Transform2Circle(TH2F **histos,Int_t n_eta_segments,UInt_t ndigits,AliL3DigitRowData *ptr)
373 {
374   //Transform all the pixels while reading them, and fill the corresponding histograms.
375   //Everything is done in one go here. 
376
377   Double_t etaslice = 0.9/n_eta_segments;
378   Int_t eta_index;
379   AliL3DigitRowData *tempPt = (AliL3DigitRowData*)ptr;
380   TH2F *hist;
381
382   Int_t out_count=0,tot_count=0;
383   for(Int_t i=NRows[fPatch][0]; i<=NRows[fPatch][1]; i++)
384     {
385       printf("doing row %d\n",i);
386       for(UInt_t dig=0; dig<tempPt->fNDigit; dig++)
387         {
388           
389           AliL3DigitData *bins = tempPt->fDigitData;
390           Float_t xyz[3];
391           Int_t sector,row;
392           fTransform->Slice2Sector(fSlice,i,sector,row);
393           fTransform->Raw2Local(xyz,sector,row,bins[dig].fPad,bins[dig].fTime);
394           Double_t eta = fTransform->GetEta(xyz);
395           eta_index = (Int_t)(eta/etaslice);
396           if(eta_index < 0 || eta_index >= n_eta_segments)
397             {
398               //printf("Eta index out of range %d\n",eta_index);
399               out_count++;
400               continue;
401             }
402           tot_count++;
403           hist = histos[eta_index];
404           if(!hist)
405             {
406               printf("Error getting histogramm!\n");
407               return;
408             }
409           
410           Int_t ymin = hist->GetYaxis()->GetFirst();
411           Int_t ymax = hist->GetYaxis()->GetLast();
412           
413           Double_t r_pix = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
414           Double_t phi_pix = fTransform->GetPhi(xyz);
415           for(Int_t p=ymin; p<=ymax; p++)
416             {
417               Double_t phi0 = hist->GetYaxis()->GetBinCenter(p);
418               Double_t kappa = 2*sin(phi_pix-phi0)/r_pix;
419               //printf("kappa %f phi0 %f\n",kappa,phi0);
420               hist->Fill(kappa,phi0,bins[dig].fCharge);
421             }
422         }
423       
424       
425       Byte_t *tmp = (Byte_t*)tempPt;
426       Int_t size = sizeof(AliL3DigitRowData) + tempPt->fNDigit*sizeof(AliL3DigitData);
427       tmp += size;
428       tempPt = (AliL3DigitRowData*)tmp;
429       
430     }
431   
432   printf("There were %d pixels out of range and %d inside\n", out_count,tot_count);
433
434 }
435
436
437 void AliL3HoughTransformer::TransformLines2Circle(TH2F *hist,AliL3TrackArray *tracks)
438 {
439
440   for(Int_t i=0; i<tracks->GetNTracks(); i++)
441     {
442       AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->GetCheckedTrack(i);
443       if(!track) {printf("AliL3HoughTransformer::TransformLines2Circle : NO TRACK IN ARRAY\n"); continue;}
444      
445       Double_t xmin = fTransform->Row2X(track->GetFirstRow());
446       Double_t xmax = fTransform->Row2X(track->GetLastRow());
447       
448       Double_t a = -1./tan(track->GetPsiLine());
449       Double_t b = track->GetDLine()/sin(track->GetPsiLine());
450       
451       Double_t ymin = a*xmin + b;
452       Double_t ymax = a*xmax + b;
453       
454       Double_t middle_x = xmin + (xmax-xmin)/2;
455       Double_t middle_y = ymin + (ymax-ymin)/2;
456       
457       Double_t r_middle = sqrt(middle_x*middle_x + middle_y*middle_y);
458       Double_t phi = atan2(middle_y,middle_x);
459       Double_t phi0 = 2*phi - track->GetPsiLine();
460       Double_t kappa = 2*sin(phi-phi0)/r_middle;
461       hist->Fill(kappa,phi0,track->GetWeight());
462      
463     }
464
465   
466 }
467
468 void AliL3HoughTransformer::Transform2Line(TH2F *hist,Int_t ref_row,Int_t *rowrange,Double_t *phirange,TH2F *raw)
469 {
470   //Transform every pixel into histogram, using parametrisation:
471   //D = x*cos(psi) + y*sin(psi)
472
473   //  printf("In Transform; rowrange %d %d ref_row %d phirange %f %f\n",rowrange[0],rowrange[1],ref_row,phirange[0],phirange[1]);
474
475   AliL3Digits *pix1;
476   
477   Int_t xmin = hist->GetXaxis()->GetFirst();
478   Int_t xmax = hist->GetXaxis()->GetLast();
479   
480   Double_t x0 = fTransform->Row2X(ref_row);
481   Double_t y0 = 0;
482
483   Int_t sector,row;
484   //for(Int_t padrow = NRows[fPatch][0]; padrow <= NRows[fPatch][1]; padrow++)
485   
486   Double_t phi_min = -10*ToRad;
487   Double_t phi_max = 10*ToRad;
488   Double_t delta_phi = (phi_max-phi_min)/fNPhiSegments;
489   
490
491   Int_t phi_min_index = (Int_t)((phirange[0]*ToRad-phi_min)/delta_phi);
492   Int_t phi_max_index = (Int_t)((phirange[1]*ToRad-phi_min)/delta_phi);
493     
494   
495   Int_t index;
496   
497   for(Int_t phi=phi_min_index; phi <= phi_max_index; phi++)
498     {
499       for(Int_t padrow = rowrange[0]; padrow <= rowrange[1]; padrow++)
500         {
501           
502           index = phi*fNumOfPadRows + padrow;
503           //printf("Looping index %d\n",index);
504           if(index > fContainerBounds || index < 0)
505             {
506               printf("AliL3HoughTransformer::Transform2Line : index %d out of range \n",index);
507               return;
508             }
509           for(pix1=(AliL3Digits*)fRowContainer[padrow].first; pix1!=0; pix1=(AliL3Digits*)pix1->nextRowPixel)
510           //for(pix1=(AliL3Digits*)fPhiRowContainer[index].first; pix1!=0; pix1=(AliL3Digits*)pix1->nextPhiRowPixel)
511             {
512               //printf("Transforming pixel in index %d pad %d time %d padrow %d\n",index,pix1->fPad,pix1->fTime,padrow);
513               Float_t xyz[3];
514               fTransform->Slice2Sector(fSlice,padrow,sector,row);
515               fTransform->Raw2Local(xyz,sector,row,pix1->fPad,pix1->fTime);
516                   
517               if(raw)
518                 raw->Fill(xyz[0],xyz[1],pix1->fCharge);
519
520               xyz[0] = xyz[0]-x0;
521               xyz[1] = xyz[1]-y0;
522               
523               //printf("calculating...");
524               for(Int_t d=xmin+1; d<=xmax; d++)
525                 {
526                   Double_t psi = hist->GetXaxis()->GetBinCenter(d);
527                   Double_t D = xyz[0]*cos(psi) + xyz[1]*sin(psi);
528                   
529                   Short_t signal = pix1->fCharge;
530                   hist->Fill(psi,D,signal);
531                   //printf("Filling histo, psi %f D %f\n",psi,D);
532                 }
533               //printf("done\n");
534             }
535           //printf(" done\n");
536         }
537       
538     }
539     
540 }
541
542
543 void AliL3HoughTransformer::GetPixels(Char_t *rootfile,TH2F *hist)
544 {
545
546   //read data from rootfile. more or less obsolete code this.
547
548   TFile *file = new TFile(rootfile);
549   file->cd();
550
551   AliTPCParam *param=(AliTPCParam *)file->Get("75x40_100x60");
552   TTree *t=(TTree*)file->Get("TreeD_75x40_100x60");      
553     
554   AliSimDigits da, *digarr=&da;
555   t->GetBranch("Segment")->SetAddress(&digarr);
556   Stat_t num_of_entries=t->GetEntries();
557
558   Int_t digit_counter=0;
559   Float_t xyz[3];
560   Double_t eta;
561   
562   Int_t nrows = NRows[fPatch][1] - NRows[fPatch][0] + 1;
563   printf("nrows %d slice %d patch %d\n",nrows,fSlice,fPatch);
564   
565   if(fRowContainer)
566     delete [] fRowContainer;
567   fRowContainer = new AliL3HoughContainer[fNumOfPadRows];
568   memset(fRowContainer,0,fNumOfPadRows*sizeof(AliL3HoughContainer));
569
570
571   //fContainerBounds = (fNPhiSegments+1)*(fNumOfPadRows+1);
572   //printf("Allocating %d bytes to container of size %d\n",fContainerBounds*sizeof(AliL3HoughContainer),fContainerBounds);
573
574   
575   //  if(fPhiRowContainer)
576   //  delete [] fPhiRowContainer;
577   //  fPhiRowContainer = new AliL3HoughContainer[fContainerBounds];
578   //  memset(fPhiRowContainer,0,fContainerBounds*sizeof(AliL3HoughContainer));
579   
580   fContainerBounds = (fNumEtaSegments+1)*(fNumOfPadRows+1);
581   if(fVolume)
582     delete [] fVolume;
583   fVolume = new AliL3HoughContainer[fContainerBounds];
584   memset(fVolume,0,fContainerBounds*sizeof(AliL3HoughContainer));
585   
586   //  Double_t phi_min = -10*ToRad;
587   //  Double_t phi_max = 10*ToRad;
588   //  Double_t delta_phi = (phi_max-phi_min)/fNPhiSegments;
589   
590   Double_t eta_slice = (fEtaMax-fEtaMin)/fNumEtaSegments;
591   Int_t index;
592   digit_counter=0;
593
594   //printf("\nLoading ALL pixels in slice\n\n");
595
596   for (Int_t i=0; i<num_of_entries; i++) 
597     { 
598       t->GetEvent(i);
599       Int_t sector; 
600       Int_t row;    
601       param->AdjustSectorRow(digarr->GetID(),sector,row);
602       Int_t slice,padrow;
603       fTransform->Sector2Slice(slice,padrow,sector,row);
604       if(slice != fSlice) continue;
605       if(padrow < NRows[fPatch][0]) continue;
606       if(padrow > NRows[fPatch][1]) break;
607       digarr->First();
608       do {
609         Int_t time=digarr->CurrentRow();
610         Int_t pad=digarr->CurrentColumn();
611         Short_t signal=digarr->CurrentDigit();
612         if(time < param->GetMaxTBin()-1 && time > 0)
613           if(digarr->GetDigit(time-1,pad) <= param->GetZeroSup()
614              && digarr->GetDigit(time+1,pad) <= param->GetZeroSup()) 
615             continue;
616         
617         
618         fTransform->Raw2Global(xyz,sector,row,pad,time);
619         eta = fTransform->GetEta(xyz);
620         
621         if(eta < fEtaMin || eta > fEtaMax) continue;
622         fTransform->Global2Local(xyz,sector);
623         
624         
625         //phi = fTransform->GetPhi(xyz);
626         if(hist)
627           hist->Fill(xyz[0],xyz[1],signal);
628         
629         AliL3Digits *dig = new AliL3Digits;
630         dig->fIndex = digit_counter;
631         digit_counter++;
632         dig->fCharge = signal;
633         dig->fPad = pad;
634         dig->fTime = time;
635         
636         if(fRowContainer[padrow].first == NULL)
637           fRowContainer[padrow].first = (void*)dig;
638         else
639           ((AliL3Digits*)(fRowContainer[padrow].last))->nextRowPixel=dig;
640         fRowContainer[padrow].last = (void*)dig;
641         
642         //thisHit->etaIndex=(Int_t)((thisHit->GetEta()-fEtaMin)/etaSlice + 1);
643         Int_t eta_index = (Int_t)((eta-fEtaMin)/eta_slice);
644         index = eta_index*fNumOfPadRows + padrow;
645         if(index > fContainerBounds || index < 0)
646           {
647             
648             //printf("AliL3HoughTransformer::GetPixels : index out of range %d %d eta_index %d padrow %d\n",index,fContainerBounds,eta_index,padrow);
649             continue;
650           }
651         
652         if(fVolume[index].first == NULL)
653           fVolume[index].first = (void*)dig;
654         else
655           ((AliL3Digits*)(fVolume[index].last))->fNextVolumePixel = dig;
656         fVolume[index].last = (void*)dig;
657         
658         
659         //  Int_t phi_index = (Int_t)((phi-phi_min)/delta_phi);
660         //  index = phi_index*fNumOfPadRows + padrow;
661         //  if(phi_index > fContainerBounds || phi_index < 0)
662         // {
663         //  printf("AliL3HoughTransform::GetPixels : index out of range %d\n",phi_index);
664         //  continue;
665         //  }
666           
667         //  if(fPhiRowContainer[index].first == NULL)
668         //  fPhiRowContainer[index].first = (void*)dig;
669         //  else
670         //  ((AliL3Digits*)(fPhiRowContainer[index].last))->nextPhiRowPixel = dig;
671         //  fPhiRowContainer[index].last=(void*)dig;
672         
673       }while (digarr->Next());
674       
675     }
676   
677   fNDigits = digit_counter;
678   printf("digitcounter %d\n",digit_counter);
679   printf("Allocated %d bytes to pixels\n",digit_counter*sizeof(AliL3Digits));
680   file->Close();
681   delete file;
682   
683 }
684 */