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