Bug fix for the case of more than 30 timebins
[u/mrichter/AliRoot.git] / TRD / AliTRDpropagationLayer.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 //  The TRD propagation layer                                             //
21 //                                                                        //
22 //  Authors:                                                              //
23 //    Marian Ivanov <M.Ivanov@gsi.de>                                     //
24 //    Alex Bercuci <A.Bercuci@gsi.de>                                     //
25 //    Markus Fasel <M.Fasel@gsi.de>                                       //
26 //                                                                        //
27 ////////////////////////////////////////////////////////////////////////////
28
29 #include "string.h"
30
31 #include "TMath.h"
32
33 #include "AliTRDpropagationLayer.h"
34 //#include "AliTRDtracker.h"
35 #include "AliTRDcluster.h"
36 #include "AliTRDgeometry.h"
37
38 //_____________________________________________________________________________
39 AliTRDpropagationLayer::AliTRDpropagationLayer()
40   :TObject()
41   ,fN(0)
42   ,fSec(0)
43   ,fClusters(NULL)
44   ,fIndex(NULL)
45   ,fX(0.)
46   ,fdX(0.)
47   ,fRho(0.)
48   ,fX0(0.)
49   ,fTimeBinIndex(0)
50   ,fPlane(0)
51   ,fYmax(0)
52   ,fYmaxSensitive(0)
53   ,fHole(kFALSE)
54   ,fHoleZc(0)
55   ,fHoleZmax(0)
56   ,fHoleYc(0)
57   ,fHoleYmax(0)
58   ,fHoleRho(0)
59   ,fHoleX0(0)
60 {
61   //
62   // Default constructor
63   //
64
65 }
66
67 //_____________________________________________________________________________
68 AliTRDpropagationLayer::AliTRDpropagationLayer(Double_t x, Double_t dx, Double_t rho
69                                              , Double_t radLength, Int_t tbIndex, Int_t plane)
70   :TObject()
71   ,fN(0)
72   ,fSec(0)
73   ,fClusters(NULL)
74   ,fIndex(NULL)
75   ,fX(x)
76   ,fdX(dx)
77   ,fRho(rho)
78   ,fX0(radLength)
79   ,fTimeBinIndex(tbIndex)
80   ,fPlane(plane)
81   ,fYmax(0)
82   ,fYmaxSensitive(0)
83   ,fHole(kFALSE)
84   ,fHoleZc(0)
85   ,fHoleZmax(0)
86   ,fHoleYc(0)
87   ,fHoleYmax(0)
88   ,fHoleRho(0)
89   ,fHoleX0(0)
90
91   //
92   // AliTRDpropagationLayer constructor
93   //
94
95   for (Int_t i = 0; i < (Int_t)kZones; i++) {
96     fZc[i]   = 0; 
97     fZmax[i] = 0;
98   }
99
100   if (fTimeBinIndex >= 0) { 
101     fClusters = new AliTRDcluster*[kMaxClusterPerTimeBin];
102     fIndex    = new UInt_t[kMaxClusterPerTimeBin];
103   }
104
105   for (Int_t i = 0; i < 5; i++) {
106     fIsHole[i] = kFALSE;
107   }
108
109 }
110
111 //_____________________________________________________________________________
112 AliTRDpropagationLayer::AliTRDpropagationLayer(const AliTRDpropagationLayer &p)
113   :TObject((TObject&)p)
114   ,fN(p.fN)
115   ,fSec(p.fSec)
116   ,fClusters(NULL)
117   ,fIndex(NULL)
118   ,fX(p.fX)
119   ,fdX(p.fdX)
120   ,fRho(p.fRho)
121   ,fX0(p.fX0)
122   ,fTimeBinIndex(p.fTimeBinIndex)
123   ,fPlane(p.fPlane)
124   ,fYmax(p.fYmax)
125   ,fYmaxSensitive(p.fYmaxSensitive)
126   ,fHole(p.fHole)
127   ,fHoleZc(p.fHoleZc)
128   ,fHoleZmax(p.fHoleZmax)
129   ,fHoleYc(p.fHoleYc)
130   ,fHoleYmax(p.fHoleYmax)
131   ,fHoleRho(p.fHoleRho)
132   ,fHoleX0(p.fHoleX0)
133 {
134   //
135   // AliTRDpropagationLayer copy constructor
136   //
137
138   for (Int_t i = 0; i < (Int_t)kZones; i++) {
139     fZc[i]   = p.fZc[i]; 
140     fZmax[i] = p.fZmax[i];
141                 fIsHole[i] = p.fIsHole[i];
142                 fZmaxSensitive[i] = p.fZmaxSensitive[i];  
143         }
144
145         // Make a deep copy of the Clusters array and the Index array unless they are needed in class AliTRDstackLayer
146         Int_t arrsize = (Int_t)kMaxClusterPerTimeBin;
147          if (fTimeBinIndex >= 0) { 
148     fClusters = new AliTRDcluster*[arrsize];
149     fIndex    = new UInt_t[arrsize];
150   }
151         memset(fIndex, 0, sizeof(UInt_t)*arrsize);
152         memset(fClusters, 0, sizeof(AliTRDcluster *)*arrsize);
153         for(Int_t i = 0; i < arrsize; i++){
154                 fClusters[i] = p.fClusters[i];
155                 fIndex[i] = p.fIndex[i];
156         }
157 }
158  
159 //_____________________________________________________________________________
160 AliTRDpropagationLayer::~AliTRDpropagationLayer()
161 {
162   //
163   // Destructor
164   //
165
166   if (fTimeBinIndex >= 0) { 
167     delete[] fClusters;
168     delete[] fIndex;
169   }
170
171 }
172
173 //_____________________________________________________________________________
174 void AliTRDpropagationLayer::Copy(TObject &o) const 
175 {
176   //
177   // Copy function
178   //
179
180   AliTRDpropagationLayer &p = (AliTRDpropagationLayer &)o; 
181   p.fN   = fN;
182   p.fSec = fSec;
183   p.fX = fX;
184   p.fdX = fdX;
185   p.fRho = fRho;
186   p.fX0  = fX0;
187   p.fTimeBinIndex = fTimeBinIndex;
188   p.fPlane  = fPlane;
189   p.fYmax = fYmax;
190   p.fYmaxSensitive  = fYmaxSensitive;
191   p.fHole = fHole;
192   p.fHoleZc = fHoleZc;
193   p.fHoleZmax = fHoleZmax;
194   p.fHoleYc = fHoleYc;
195   p.fHoleYmax = fHoleYmax;
196   p.fHoleRho = fHoleRho;
197   p.fHoleX0 = fHoleX0;
198
199   for (Int_t i = 0; i < (Int_t)kZones; i++) {
200     p.fZc[i]   = fZc[i]; 
201     p.fZmax[i] = fZmax[i];
202     p.fIsHole[i] = fIsHole[i];
203     p.fZmaxSensitive[i] = fZmaxSensitive[i];  
204   }
205         
206   // Make a deep copy of the Clusters array and the Index array
207   // unless they are needed in class AliTRDstackLayer
208   if (fTimeBinIndex >= 0) { 
209     if (!p.fClusters) 
210       p.fClusters = new AliTRDcluster*[(Int_t)kMaxClusterPerTimeBin];
211     if (!p.fIndex)
212       p.fIndex    = new UInt_t[(Int_t)kMaxClusterPerTimeBin];
213   }
214   for (Int_t i = 0; i < (Int_t)kMaxClusterPerTimeBin; i++){
215     //overwrite
216     p.fClusters[i] = fClusters[i];
217     p.fIndex[i] = fIndex[i];
218   }
219
220 }
221
222 //_____________________________________________________________________________
223 void AliTRDpropagationLayer::SetZ(Double_t * const center, Double_t * const w, Double_t * const wsensitive )
224 {
225   //
226   // Set centers and the width of sectors
227   //
228
229   for (Int_t istack = 0; istack < AliTRDgeometry::kNstack; istack++) {
230     fZc[istack]            = center[istack];  
231     fZmax[istack]          = w[istack];
232     fZmaxSensitive[istack] = wsensitive[istack];
233   }  
234
235 }
236
237 //_____________________________________________________________________________
238 void AliTRDpropagationLayer::SetHoles(Bool_t * const holes)
239 {
240   //
241   // Set centers and the width of sectors
242   //
243
244   fHole = kFALSE;
245
246   for (Int_t istack = 0; istack < AliTRDgeometry::kNstack; istack++) {
247     fIsHole[istack] = holes[istack]; 
248     if (holes[istack]) {
249       fHole = kTRUE;
250     }
251   }  
252
253 }
254
255 //_____________________________________________________________________________
256 void AliTRDpropagationLayer::InsertCluster(AliTRDcluster *c, UInt_t index) 
257 {
258   //
259   // Insert cluster in cluster array.
260   // Clusters are sorted according to Y coordinate.  
261   //
262
263   if (fTimeBinIndex < 0) { 
264     //AliWarning("Attempt to insert cluster into non-sensitive time bin!\n");
265     return;
266   }
267
268   if (fN == (Int_t) kMaxClusterPerTimeBin) {
269     //AliWarning("Too many clusters !\n"); 
270     return;
271   }
272
273   if (fN == 0) {
274     fIndex[0]       = index; 
275     fClusters[fN++] = c; 
276     return;
277   }
278
279   Int_t i = Find(c->GetY());
280   memmove(fClusters+i+1,fClusters+i,(fN-i)*sizeof(AliTRDcluster*));
281   memmove(fIndex   +i+1,fIndex   +i,(fN-i)*sizeof(UInt_t)); 
282   fIndex[i]    = index; 
283   fClusters[i] = c; 
284   fN++;
285
286 }  
287
288 //_____________________________________________________________________________
289 Int_t AliTRDpropagationLayer::Find(Float_t y) const
290 {
291   //
292   // Returns index of the cluster nearest in Y    
293   //
294
295   if (fN <= 0) {
296     return 0;
297   }
298   if (y <= fClusters[0]->GetY()) {
299     return 0;
300   }
301   if (y >  fClusters[fN-1]->GetY()) {
302     return fN;
303   }
304
305   Int_t b = 0;
306   Int_t e = fN - 1;
307   Int_t m = (b + e) / 2;
308
309   for ( ; b < e; m = (b + e) / 2) {
310     if (y > fClusters[m]->GetY()) {
311       b = m + 1;
312     }
313     else {
314       e = m;
315     }
316   }
317
318   return m;
319
320 }    
321
322 //_____________________________________________________________________________
323 Int_t AliTRDpropagationLayer::FindNearestCluster(Float_t y, Float_t z
324                                                , Float_t maxroad
325                                                , Float_t maxroadz) const 
326 {
327   //
328   // Returns index of the cluster nearest to the given y,z
329   //
330
331   Int_t   index   = -1;
332   Int_t   maxn    = fN;
333   Float_t mindist = maxroad;                    
334
335   for (Int_t i = Find(y-maxroad); i < maxn; i++) {
336     AliTRDcluster *c = (AliTRDcluster *) (fClusters[i]);
337     Float_t ycl = c->GetY();
338     if (ycl > (y + maxroad)) {
339       break;
340     }
341     if (TMath::Abs(c->GetZ() - z) > maxroadz) {
342       continue;
343     }
344     if (TMath::Abs(ycl - y)       < mindist) {
345       mindist = TMath::Abs(ycl - y);
346       index   = fIndex[i];
347     }
348   }                                             
349
350   return index;
351
352 }             
353