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