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