Removed missleading comment.
[u/mrichter/AliRoot.git] / TPC / AliSimDigits.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /*
17 $Log$
18 Revision 1.2.4.3  2000/06/26 07:39:42  kowal2
19 Changes to obey the coding rules
20
21 Revision 1.2.4.2  2000/06/25 08:38:41  kowal2
22 Splitted from AliTPCtracking
23
24 Revision 1.2.4.1  2000/06/14 16:45:13  kowal2
25 Improved algorithms. Compiler warnings removed.
26
27 Revision 1.2  2000/04/17 09:37:33  kowal2
28 removed obsolete AliTPCDigitsDisplay.C
29
30 Revision 1.1.4.2  2000/04/10 11:37:42  kowal2
31
32 Digits handling in a new data structure
33
34 */
35
36 //
37
38 ///////////////////////////////////////////////////////////////////////////////
39 //                                                                           //
40 //  Alice segment manager object                                             //
41 //                                
42 //  AliSimDigits object   (derived from AliDigits)                            //
43 //  provide additional track information to digit                            //
44 //  
45 //   Origin: Marian Ivanov  GSI Darmstadt                                     //
46 //
47 //                                                                           //
48 //                                                                          //
49 ///////////////////////////////////////////////////////////////////////////////
50
51 #include "TClass.h"
52 #include <iostream.h>
53 #include "TError.h"
54 #include "AliSegmentID.h"
55 #include "AliH2F.h"
56 #include "AliArrayI.h"
57 #include "AliArrayS.h"
58 #include "AliDigits.h"
59 #include "AliSimDigits.h"
60 #include "AliTPC.h"
61
62
63
64 //_____________________________________________________________________________
65 //_____________________________________________________________________________
66 //_____________________________________________________________________________
67 ClassImp(AliSimDigits)
68
69 AliSimDigits::AliSimDigits()
70 {
71   //  AliDigits::Invalite();
72   fTracks = 0;
73   fTrIndex = 0;  
74   InvalidateTrack();
75 }
76 AliSimDigits::~AliSimDigits()
77 {
78   //  AliDigits::Invalidate();
79   if (fTracks != 0) fTracks->Delete();
80   if (fTrIndex != 0) fTrIndex->Delete();  
81
82 }
83
84 void AliSimDigits::InvalidateTrack() 
85
86   //
87   //set default (invalid parameters)
88   if ( fTracks != 0) delete fTracks;
89   fTracks = new AliArrayI;
90   if ( fTrIndex  != 0) delete fTrIndex;
91   fTrIndex = new AliArrayI;
92
93   for (Int_t i = 0; i<3; i++){
94     fTracks->Set(0);
95     fTrIndex->Set(0);
96   }
97 }
98
99 void  AliSimDigits::AllocateTrack(Int_t length)
100 {
101   //
102   //construct empty buffer fElements and fTracks with size fNrows x fNcols x
103   //length 
104   InvalidateTrack();
105   fNlevel = length;
106   fTracks->Set(fNcols*fNrows*fNlevel);
107   fTrIndex->Set(0); 
108   fTrBufType =0;
109 }
110
111 Int_t AliSimDigits::GetTrackID(Int_t row, Int_t column, Int_t level) 
112 {
113   //
114   //Get track ID 
115   if (fTrBufType == 0) return  GetTrackIDFast(row, column,level);
116   if (fTrBufType == 1) return  GetTrackID1(row, column,level); 
117   if (fTrBufType == 2) return  GetTrackID2(row, column,level); 
118   return 0;
119 }
120
121 void AliSimDigits::ExpandTrackBuffer()
122 {  
123   //
124   //expand buffer to two dimensional array 
125   if (fTrBufType<0)  {
126     Error("ExpandBuffer", "buffer doesn't exist");
127     return;
128   }
129   if (fTrBufType==0)      return;  //buffer expanded
130   if (fTrBufType==1)  {ExpandTrackBuffer1(); return;}
131   if (fTrBufType==2)  ExpandTrackBuffer2();
132  
133 }
134
135 void AliSimDigits::CompresTrackBuffer(Int_t bufType)
136 {
137   //
138   //compres buffer according buffertype algorithm
139   //
140   if (fTrBufType<0)  {
141     Error("CompressBuffer", "buffer doesn't exist");
142     return;
143   }
144   if (fTrBufType == bufType) return;
145   //
146   if (fTrBufType>0) ExpandTrackBuffer();
147   if (fTrBufType !=0)  {
148     Error("CompressBuffer", "buffer doesn't exist");
149     return;
150   }
151   //compress buffer of type 1
152   
153   if (bufType==1)      {CompresTrackBuffer1();return;}
154   if (bufType==2)      CompresTrackBuffer2();
155    
156 }
157
158 Int_t  AliSimDigits::GetTrackID1(Int_t row, Int_t column, Int_t level)
159 {
160   //return  track ID of digits - for buffer compresion 2
161   Int_t i,n1,n2;
162   i = level*fNcols+column;
163   if ( (i+1)>=fTrIndex->fN) n2 = fTracks->fN;
164   else 
165     n2 = fTrIndex->At(i+1);
166   n1 = fTrIndex->At(i);
167   Int_t rownew = 0;
168   Int_t rowold=0;
169   Int_t id;
170   for (i = n1;(i<n2);i++){
171     id = 0;
172     Int_t num = fTracks->At(i);
173     if (num<0) {
174       rownew-=num;  
175       rowold = rownew;
176       i++;
177       if (i<n2){
178         num = fTracks->At(i);
179         rownew+=num;
180         i++;
181         id = fTracks->At(i);
182       }
183     }
184     else {
185       rowold = rownew;
186       rownew+=num;
187       i++;
188       id = fTracks->At(i);
189     }
190     id-=2;
191     if ( (row>=rowold) && (row<=rownew) ) return id;
192     if (row < rownew ) return -2; //empty track
193   }
194   return -2;
195 }
196
197 void  AliSimDigits::ExpandTrackBuffer1()
198 {
199   //
200   //expand  track compressed according algorithm 1 (track id comression independent to the digit compression)
201   // !!in expanded tracks we don't use fTrIndex array
202   //  
203   fTrBufType = 0;
204   Int_t i,j;
205   Int_t all   = fNrows*fNcols;  //total number of digits
206   Int_t elems = all*fNlevel;  //length of the buffer
207
208   AliArrayI * buf = new AliArrayI;
209   buf->Set(elems);
210   fTrIndex->Set(0);
211   //
212   Int_t level = 0;
213   Int_t col=0;
214   Int_t row = 0;
215   Int_t n=fTracks->fN;
216   //
217   for (i=0;i<n;i++){
218     //oposite signa means how many unwrited (under threshold) values
219     Int_t num = fTracks->At(i);
220     if (num<0) row-=num;   //negative number mean number of zeroes (no tracks of gibven level no need to write to array) 
221     else {
222       i++;
223       Int_t id =  fTracks->At(i);
224       for (j = 0; j<num; j++,row++) (*buf)[level*all+col*fNrows+row]=id;       
225     }
226     if (row>=fNrows) {
227       row=0;
228       col++;
229     }
230     if (col>=fNcols) {
231       col=0;
232       level++;
233     }    
234   }//end of loop over digits
235   delete fTracks;
236   fTracks = buf;
237 }
238
239 void  AliSimDigits::CompresTrackBuffer1()
240 {
241   //
242   //comress track according algorithm 1 (track id comression independent to the digit compression)
243   //
244   fTrBufType = 1;  
245
246   AliArrayI *  buf = new AliArrayI;   //create  new buffer 
247   buf->Set(fNrows*fNcols*fNlevel); //lets have the nearly the "worst case"
248   AliArrayI *  index = new AliArrayI;
249   index->Set(fNcols*fNlevel);
250
251   Int_t icurrent=-1;  //current index
252   Int_t izero;      //number of zero
253   Int_t inum;      //number of digits  with the same current track id  
254   Int_t lastID =0;  //last track id
255   for (Int_t lev =0; lev<fNlevel; lev++){    //loop over levels 
256     for (Int_t col = 0; col<fNcols; col++){    //loop over columns
257       izero = 0;
258       inum =  0;
259       lastID = 0;
260       (*index)[lev*fNcols+col]=icurrent+1;//set collumn pointer
261       Int_t id=0;  //current id
262       for (Int_t row = 0; row< fNrows;row++){ //loop over rows
263         id = GetTrackIDFast(row,col,lev);
264         if (id <= 0) {
265           if ( inum> 0 ) { //if we have some tracks in buffer
266             icurrent++;
267             if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
268             (*buf)[icurrent] = inum;
269             icurrent++;
270             (*buf)[icurrent] = lastID;  
271             inum = 0;      
272             lastID = 0;
273           }
274           izero++;
275         }
276         else
277           if (id != lastID) 
278             if ( izero > 0 ) { 
279               //if we have currently izero count of non tracks digits
280               icurrent++;         
281               if (icurrent>=buf->fN) buf->Expand(icurrent*2);
282               (*buf)[icurrent]= -izero;  //write how many under zero
283               inum++;
284               izero = 0;             
285               lastID = id;
286             }
287             else{ 
288               //if we change track id from another track id         
289               icurrent++;         
290               if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
291               (*buf)[icurrent] = inum;
292               icurrent++;
293               (*buf)[icurrent] = lastID;        
294               lastID = id;
295               inum = 1;      
296               izero = 0;
297             }   
298           else {          
299             inum++;
300           }
301         
302       }//end of loop over rows
303       if ( izero > 0 ) { 
304         //if we have currently izero count of non tracks digits
305         icurrent++;       
306         if (icurrent>=buf->fN) buf->Expand(icurrent*2);
307         (*buf)[icurrent]= -izero;  //write how many under zero  
308       }
309       if ( inum> 0 ) { //if we have some tracks in buffer
310         icurrent++;
311         if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
312         (*buf)[icurrent] = inum;
313         icurrent++;
314         (*buf)[icurrent] = id;  
315       }      
316     }//end of loop over columns
317   }//end of loop over differnet track level  
318   buf->Expand(icurrent+1);
319   delete fTracks;
320   fTracks = buf;
321   delete fTrIndex;
322   fTrIndex = index;
323 }
324
325
326
327 void  AliSimDigits::ExpandTrackBuffer2()
328 {
329   //
330   //comress track according algorithm 2 (track id comression according  digit compression)
331   fTrBufType = 0;
332 }
333
334 void  AliSimDigits::CompresTrackBuffer2()
335 {
336   //
337   //comress track according algorithm 2 (track id comression according  digit compression)
338   fTrBufType = 2;
339 }
340
341
342 Int_t  AliSimDigits::GetTrackID2(Int_t row, Int_t column, Int_t level)
343 {
344   //returnb track id of digits - for buffer compresion 2
345   return -2;
346 }
347
348
349
350 AliH2F *  AliSimDigits::DrawTracks( const char *option,Int_t level, 
351                               Float_t x1, Float_t x2, Float_t y1, Float_t y2)
352 {
353   //
354   //draw digits in given array
355   //  
356   //make digits histo 
357   char ch[30];
358   sprintf(ch,"Track Segment_%d level %d ",GetID(),level );
359   if ( (fNrows<1)|| (fNcols<1)) {
360     return 0;
361   }
362   AliH2F * his  = new AliH2F("Track histo",ch,fNrows,0,fNrows,fNcols,0,fNcols);
363   ExpandTrackBuffer();
364   //set histogram  values
365   for (Int_t i = 0; i<fNrows;i++)    
366     for (Int_t j = 0; j<fNcols;j++)
367         his->Fill(i,j,GetTrackIDFast(i,j,level));
368   if (x1>=0) {
369       AliH2F *h2fsub = his->GetSubrange2d(x1,x2,y1,y2);
370       delete his;
371       his=h2fsub;
372   }
373   if (his==0) return 0;
374   if (option!=0) his->Draw(option);
375   else his->Draw();
376   return his;  
377 }
378
379 TClonesArray *  AliSimDigits::GenerTPCClonesArray(TClonesArray * arr)
380 {
381   //
382   //generate TClonnesArray of digits
383   //
384   TClonesArray * digits;
385   if (arr==0)  digits=new TClonesArray("AliTPCdigit",300);
386   else digits = arr; 
387   Int_t index = digits->GetEntriesFast();
388   for (Int_t row =0; row<fNrows; row++)
389     for (Int_t col =0; col<fNcols; col++){
390       Int_t amp = GetDigit(row,col);
391       if (amp>GetThreshold()){
392         AliTPCdigit dig;
393         dig.fPad = col;
394         dig.fTime = row;
395         dig.fSignal= amp;
396         dig.fPadRow =fSegmentID;
397         dig.fSector =fSegmentID;
398         dig.fTracks[0]= GetTrackID(row,col,0);
399         dig.fTracks[1]= GetTrackID(row,col,1);
400         dig.fTracks[2]= GetTrackID(row,col,2);
401         TClonesArray &ldigits = *digits;
402         new(ldigits[index++]) AliTPCdigit(dig);
403       }
404     }    
405   return digits;
406 }
407